var __create = Object.create;
var __defProp = Object.defineProperty;
var __defProps = Object.defineProperties;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getOwnPropSymbols = Object.getOwnPropertySymbols;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __propIsEnum = Object.prototype.propertyIsEnumerable;
var __defNormalProp = (obj, key2, value2) => key2 in obj ? __defProp(obj, key2, { enumerable: true, configurable: true, writable: true, value: value2 }) : obj[key2] = value2;
var __spreadValues = (a, b) => {
for (var prop in b ||= {})
if (__hasOwnProp.call(b, prop))
__defNormalProp(a, prop, b[prop]);
if (__getOwnPropSymbols)
for (var prop of __getOwnPropSymbols(b)) {
if (__propIsEnum.call(b, prop))
__defNormalProp(a, prop, b[prop]);
}
return a;
};
var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
var __commonJS = (cb, mod2) => function __require() {
return mod2 || (0, cb[__getOwnPropNames(cb)[0]])((mod2 = { exports: {} }).exports, mod2), mod2.exports;
};
var __copyProps = (to, from2, except, desc) => {
if (from2 && typeof from2 === "object" || typeof from2 === "function") {
for (let key2 of __getOwnPropNames(from2))
if (!__hasOwnProp.call(to, key2) && key2 !== except)
__defProp(to, key2, { get: () => from2[key2], enumerable: !(desc = __getOwnPropDesc(from2, key2)) || desc.enumerable });
}
return to;
};
var __toESM = (mod2, isNodeMode, target) => (target = mod2 != null ? __create(__getProtoOf(mod2)) : {}, __copyProps(
// If the importer is in node compatibility mode or this is not an ESM
// file that has been converted to a CommonJS file using a Babel-
// compatible transform (i.e. "__esModule" has not been set), then set
// "default" to the CommonJS "module.exports" for node compatibility.
isNodeMode || !mod2 || !mod2.__esModule ? __defProp(target, "default", { value: mod2, enumerable: true }) : target,
mod2
));
var __async = (__this, __arguments, generator) => {
return new Promise((resolve, reject) => {
var fulfilled = (value2) => {
try {
step(generator.next(value2));
} catch (e) {
reject(e);
}
};
var rejected = (value2) => {
try {
step(generator.throw(value2));
} catch (e) {
reject(e);
}
};
var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
step((generator = generator.apply(__this, __arguments)).next());
});
};
// node_modules/qrcode/lib/can-promise.js
var require_can_promise = __commonJS({
"node_modules/qrcode/lib/can-promise.js"(exports2, module2) {
"use strict";
module2.exports = function() {
return typeof Promise === "function" && Promise.prototype && Promise.prototype.then;
};
}
});
// node_modules/qrcode/lib/core/utils.js
var require_utils = __commonJS({
"node_modules/qrcode/lib/core/utils.js"(exports2) {
"use strict";
var toSJISFunction;
var CODEWORDS_COUNT = [
0,
// Not used
26,
44,
70,
100,
134,
172,
196,
242,
292,
346,
404,
466,
532,
581,
655,
733,
815,
901,
991,
1085,
1156,
1258,
1364,
1474,
1588,
1706,
1828,
1921,
2051,
2185,
2323,
2465,
2611,
2761,
2876,
3034,
3196,
3362,
3532,
3706
];
exports2.getSymbolSize = function getSymbolSize(version) {
if (!version)
throw new Error('"version" cannot be null or undefined');
if (version < 1 || version > 40)
throw new Error('"version" should be in range from 1 to 40');
return version * 4 + 17;
};
exports2.getSymbolTotalCodewords = function getSymbolTotalCodewords(version) {
return CODEWORDS_COUNT[version];
};
exports2.getBCHDigit = function(data2) {
let digit = 0;
while (data2 !== 0) {
digit++;
data2 >>>= 1;
}
return digit;
};
exports2.setToSJISFunction = function setToSJISFunction(f) {
if (typeof f !== "function") {
throw new Error('"toSJISFunc" is not a valid function.');
}
toSJISFunction = f;
};
exports2.isKanjiModeEnabled = function() {
return typeof toSJISFunction !== "undefined";
};
exports2.toSJIS = function toSJIS(kanji) {
return toSJISFunction(kanji);
};
}
});
// node_modules/qrcode/lib/core/error-correction-level.js
var require_error_correction_level = __commonJS({
"node_modules/qrcode/lib/core/error-correction-level.js"(exports2) {
"use strict";
exports2.L = { bit: 1 };
exports2.M = { bit: 0 };
exports2.Q = { bit: 3 };
exports2.H = { bit: 2 };
function fromString(string) {
if (typeof string !== "string") {
throw new Error("Param is not a string");
}
const lcStr = string.toLowerCase();
switch (lcStr) {
case "l":
case "low":
return exports2.L;
case "m":
case "medium":
return exports2.M;
case "q":
case "quartile":
return exports2.Q;
case "h":
case "high":
return exports2.H;
default:
throw new Error("Unknown EC Level: " + string);
}
}
exports2.isValid = function isValid(level) {
return level && typeof level.bit !== "undefined" && level.bit >= 0 && level.bit < 4;
};
exports2.from = function from2(value2, defaultValue) {
if (exports2.isValid(value2)) {
return value2;
}
try {
return fromString(value2);
} catch (e) {
return defaultValue;
}
};
}
});
// node_modules/qrcode/lib/core/bit-buffer.js
var require_bit_buffer = __commonJS({
"node_modules/qrcode/lib/core/bit-buffer.js"(exports2, module2) {
"use strict";
function BitBuffer() {
this.buffer = [];
this.length = 0;
}
BitBuffer.prototype = {
get: function(index2) {
const bufIndex = Math.floor(index2 / 8);
return (this.buffer[bufIndex] >>> 7 - index2 % 8 & 1) === 1;
},
put: function(num, length2) {
for (let i = 0; i < length2; i++) {
this.putBit((num >>> length2 - i - 1 & 1) === 1);
}
},
getLengthInBits: function() {
return this.length;
},
putBit: function(bit) {
const bufIndex = Math.floor(this.length / 8);
if (this.buffer.length <= bufIndex) {
this.buffer.push(0);
}
if (bit) {
this.buffer[bufIndex] |= 128 >>> this.length % 8;
}
this.length++;
}
};
module2.exports = BitBuffer;
}
});
// node_modules/qrcode/lib/core/bit-matrix.js
var require_bit_matrix = __commonJS({
"node_modules/qrcode/lib/core/bit-matrix.js"(exports2, module2) {
"use strict";
function BitMatrix(size) {
if (!size || size < 1) {
throw new Error("BitMatrix size must be defined and greater than 0");
}
this.size = size;
this.data = new Uint8Array(size * size);
this.reservedBit = new Uint8Array(size * size);
}
BitMatrix.prototype.set = function(row, col, value2, reserved) {
const index2 = row * this.size + col;
this.data[index2] = value2;
if (reserved)
this.reservedBit[index2] = true;
};
BitMatrix.prototype.get = function(row, col) {
return this.data[row * this.size + col];
};
BitMatrix.prototype.xor = function(row, col, value2) {
this.data[row * this.size + col] ^= value2;
};
BitMatrix.prototype.isReserved = function(row, col) {
return this.reservedBit[row * this.size + col];
};
module2.exports = BitMatrix;
}
});
// node_modules/qrcode/lib/core/alignment-pattern.js
var require_alignment_pattern = __commonJS({
"node_modules/qrcode/lib/core/alignment-pattern.js"(exports2) {
"use strict";
var getSymbolSize = require_utils().getSymbolSize;
exports2.getRowColCoords = function getRowColCoords(version) {
if (version === 1)
return [];
const posCount = Math.floor(version / 7) + 2;
const size = getSymbolSize(version);
const intervals = size === 145 ? 26 : Math.ceil((size - 13) / (2 * posCount - 2)) * 2;
const positions = [size - 7];
for (let i = 1; i < posCount - 1; i++) {
positions[i] = positions[i - 1] - intervals;
}
positions.push(6);
return positions.reverse();
};
exports2.getPositions = function getPositions(version) {
const coords = [];
const pos = exports2.getRowColCoords(version);
const posLength = pos.length;
for (let i = 0; i < posLength; i++) {
for (let j = 0; j < posLength; j++) {
if (i === 0 && j === 0 || // top-left
i === 0 && j === posLength - 1 || // bottom-left
i === posLength - 1 && j === 0) {
continue;
}
coords.push([pos[i], pos[j]]);
}
}
return coords;
};
}
});
// node_modules/qrcode/lib/core/finder-pattern.js
var require_finder_pattern = __commonJS({
"node_modules/qrcode/lib/core/finder-pattern.js"(exports2) {
"use strict";
var getSymbolSize = require_utils().getSymbolSize;
var FINDER_PATTERN_SIZE = 7;
exports2.getPositions = function getPositions(version) {
const size = getSymbolSize(version);
return [
// top-left
[0, 0],
// top-right
[size - FINDER_PATTERN_SIZE, 0],
// bottom-left
[0, size - FINDER_PATTERN_SIZE]
];
};
}
});
// node_modules/qrcode/lib/core/mask-pattern.js
var require_mask_pattern = __commonJS({
"node_modules/qrcode/lib/core/mask-pattern.js"(exports2) {
"use strict";
exports2.Patterns = {
PATTERN000: 0,
PATTERN001: 1,
PATTERN010: 2,
PATTERN011: 3,
PATTERN100: 4,
PATTERN101: 5,
PATTERN110: 6,
PATTERN111: 7
};
var PenaltyScores = {
N1: 3,
N2: 3,
N3: 40,
N4: 10
};
exports2.isValid = function isValid(mask2) {
return mask2 != null && mask2 !== "" && !isNaN(mask2) && mask2 >= 0 && mask2 <= 7;
};
exports2.from = function from2(value2) {
return exports2.isValid(value2) ? parseInt(value2, 10) : void 0;
};
exports2.getPenaltyN1 = function getPenaltyN1(data2) {
const size = data2.size;
let points = 0;
let sameCountCol = 0;
let sameCountRow = 0;
let lastCol = null;
let lastRow = null;
for (let row = 0; row < size; row++) {
sameCountCol = sameCountRow = 0;
lastCol = lastRow = null;
for (let col = 0; col < size; col++) {
let module3 = data2.get(row, col);
if (module3 === lastCol) {
sameCountCol++;
} else {
if (sameCountCol >= 5)
points += PenaltyScores.N1 + (sameCountCol - 5);
lastCol = module3;
sameCountCol = 1;
}
module3 = data2.get(col, row);
if (module3 === lastRow) {
sameCountRow++;
} else {
if (sameCountRow >= 5)
points += PenaltyScores.N1 + (sameCountRow - 5);
lastRow = module3;
sameCountRow = 1;
}
}
if (sameCountCol >= 5)
points += PenaltyScores.N1 + (sameCountCol - 5);
if (sameCountRow >= 5)
points += PenaltyScores.N1 + (sameCountRow - 5);
}
return points;
};
exports2.getPenaltyN2 = function getPenaltyN2(data2) {
const size = data2.size;
let points = 0;
for (let row = 0; row < size - 1; row++) {
for (let col = 0; col < size - 1; col++) {
const last4 = data2.get(row, col) + data2.get(row, col + 1) + data2.get(row + 1, col) + data2.get(row + 1, col + 1);
if (last4 === 4 || last4 === 0)
points++;
}
}
return points * PenaltyScores.N2;
};
exports2.getPenaltyN3 = function getPenaltyN3(data2) {
const size = data2.size;
let points = 0;
let bitsCol = 0;
let bitsRow = 0;
for (let row = 0; row < size; row++) {
bitsCol = bitsRow = 0;
for (let col = 0; col < size; col++) {
bitsCol = bitsCol << 1 & 2047 | data2.get(row, col);
if (col >= 10 && (bitsCol === 1488 || bitsCol === 93))
points++;
bitsRow = bitsRow << 1 & 2047 | data2.get(col, row);
if (col >= 10 && (bitsRow === 1488 || bitsRow === 93))
points++;
}
}
return points * PenaltyScores.N3;
};
exports2.getPenaltyN4 = function getPenaltyN4(data2) {
let darkCount = 0;
const modulesCount = data2.data.length;
for (let i = 0; i < modulesCount; i++)
darkCount += data2.data[i];
const k = Math.abs(Math.ceil(darkCount * 100 / modulesCount / 5) - 10);
return k * PenaltyScores.N4;
};
function getMaskAt(maskPattern, i, j) {
switch (maskPattern) {
case exports2.Patterns.PATTERN000:
return (i + j) % 2 === 0;
case exports2.Patterns.PATTERN001:
return i % 2 === 0;
case exports2.Patterns.PATTERN010:
return j % 3 === 0;
case exports2.Patterns.PATTERN011:
return (i + j) % 3 === 0;
case exports2.Patterns.PATTERN100:
return (Math.floor(i / 2) + Math.floor(j / 3)) % 2 === 0;
case exports2.Patterns.PATTERN101:
return i * j % 2 + i * j % 3 === 0;
case exports2.Patterns.PATTERN110:
return (i * j % 2 + i * j % 3) % 2 === 0;
case exports2.Patterns.PATTERN111:
return (i * j % 3 + (i + j) % 2) % 2 === 0;
default:
throw new Error("bad maskPattern:" + maskPattern);
}
}
exports2.applyMask = function applyMask(pattern, data2) {
const size = data2.size;
for (let col = 0; col < size; col++) {
for (let row = 0; row < size; row++) {
if (data2.isReserved(row, col))
continue;
data2.xor(row, col, getMaskAt(pattern, row, col));
}
}
};
exports2.getBestMask = function getBestMask(data2, setupFormatFunc) {
const numPatterns = Object.keys(exports2.Patterns).length;
let bestPattern = 0;
let lowerPenalty = Infinity;
for (let p = 0; p < numPatterns; p++) {
setupFormatFunc(p);
exports2.applyMask(p, data2);
const penalty = exports2.getPenaltyN1(data2) + exports2.getPenaltyN2(data2) + exports2.getPenaltyN3(data2) + exports2.getPenaltyN4(data2);
exports2.applyMask(p, data2);
if (penalty < lowerPenalty) {
lowerPenalty = penalty;
bestPattern = p;
}
}
return bestPattern;
};
}
});
// node_modules/qrcode/lib/core/error-correction-code.js
var require_error_correction_code = __commonJS({
"node_modules/qrcode/lib/core/error-correction-code.js"(exports2) {
"use strict";
var ECLevel = require_error_correction_level();
var EC_BLOCKS_TABLE = [
// L M Q H
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
2,
2,
1,
2,
2,
4,
1,
2,
4,
4,
2,
4,
4,
4,
2,
4,
6,
5,
2,
4,
6,
6,
2,
5,
8,
8,
4,
5,
8,
8,
4,
5,
8,
11,
4,
8,
10,
11,
4,
9,
12,
16,
4,
9,
16,
16,
6,
10,
12,
18,
6,
10,
17,
16,
6,
11,
16,
19,
6,
13,
18,
21,
7,
14,
21,
25,
8,
16,
20,
25,
8,
17,
23,
25,
9,
17,
23,
34,
9,
18,
25,
30,
10,
20,
27,
32,
12,
21,
29,
35,
12,
23,
34,
37,
12,
25,
34,
40,
13,
26,
35,
42,
14,
28,
38,
45,
15,
29,
40,
48,
16,
31,
43,
51,
17,
33,
45,
54,
18,
35,
48,
57,
19,
37,
51,
60,
19,
38,
53,
63,
20,
40,
56,
66,
21,
43,
59,
70,
22,
45,
62,
74,
24,
47,
65,
77,
25,
49,
68,
81
];
var EC_CODEWORDS_TABLE = [
// L M Q H
7,
10,
13,
17,
10,
16,
22,
28,
15,
26,
36,
44,
20,
36,
52,
64,
26,
48,
72,
88,
36,
64,
96,
112,
40,
72,
108,
130,
48,
88,
132,
156,
60,
110,
160,
192,
72,
130,
192,
224,
80,
150,
224,
264,
96,
176,
260,
308,
104,
198,
288,
352,
120,
216,
320,
384,
132,
240,
360,
432,
144,
280,
408,
480,
168,
308,
448,
532,
180,
338,
504,
588,
196,
364,
546,
650,
224,
416,
600,
700,
224,
442,
644,
750,
252,
476,
690,
816,
270,
504,
750,
900,
300,
560,
810,
960,
312,
588,
870,
1050,
336,
644,
952,
1110,
360,
700,
1020,
1200,
390,
728,
1050,
1260,
420,
784,
1140,
1350,
450,
812,
1200,
1440,
480,
868,
1290,
1530,
510,
924,
1350,
1620,
540,
980,
1440,
1710,
570,
1036,
1530,
1800,
570,
1064,
1590,
1890,
600,
1120,
1680,
1980,
630,
1204,
1770,
2100,
660,
1260,
1860,
2220,
720,
1316,
1950,
2310,
750,
1372,
2040,
2430
];
exports2.getBlocksCount = function getBlocksCount(version, errorCorrectionLevel) {
switch (errorCorrectionLevel) {
case ECLevel.L:
return EC_BLOCKS_TABLE[(version - 1) * 4 + 0];
case ECLevel.M:
return EC_BLOCKS_TABLE[(version - 1) * 4 + 1];
case ECLevel.Q:
return EC_BLOCKS_TABLE[(version - 1) * 4 + 2];
case ECLevel.H:
return EC_BLOCKS_TABLE[(version - 1) * 4 + 3];
default:
return void 0;
}
};
exports2.getTotalCodewordsCount = function getTotalCodewordsCount(version, errorCorrectionLevel) {
switch (errorCorrectionLevel) {
case ECLevel.L:
return EC_CODEWORDS_TABLE[(version - 1) * 4 + 0];
case ECLevel.M:
return EC_CODEWORDS_TABLE[(version - 1) * 4 + 1];
case ECLevel.Q:
return EC_CODEWORDS_TABLE[(version - 1) * 4 + 2];
case ECLevel.H:
return EC_CODEWORDS_TABLE[(version - 1) * 4 + 3];
default:
return void 0;
}
};
}
});
// node_modules/qrcode/lib/core/galois-field.js
var require_galois_field = __commonJS({
"node_modules/qrcode/lib/core/galois-field.js"(exports2) {
"use strict";
var EXP_TABLE = new Uint8Array(512);
var LOG_TABLE = new Uint8Array(256);
(function initTables() {
let x = 1;
for (let i = 0; i < 255; i++) {
EXP_TABLE[i] = x;
LOG_TABLE[x] = i;
x <<= 1;
if (x & 256) {
x ^= 285;
}
}
for (let i = 255; i < 512; i++) {
EXP_TABLE[i] = EXP_TABLE[i - 255];
}
})();
exports2.log = function log(n) {
if (n < 1)
throw new Error("log(" + n + ")");
return LOG_TABLE[n];
};
exports2.exp = function exp(n) {
return EXP_TABLE[n];
};
exports2.mul = function mul2(x, y) {
if (x === 0 || y === 0)
return 0;
return EXP_TABLE[LOG_TABLE[x] + LOG_TABLE[y]];
};
}
});
// node_modules/qrcode/lib/core/polynomial.js
var require_polynomial = __commonJS({
"node_modules/qrcode/lib/core/polynomial.js"(exports2) {
"use strict";
var GF = require_galois_field();
exports2.mul = function mul2(p1, p2) {
const coeff = new Uint8Array(p1.length + p2.length - 1);
for (let i = 0; i < p1.length; i++) {
for (let j = 0; j < p2.length; j++) {
coeff[i + j] ^= GF.mul(p1[i], p2[j]);
}
}
return coeff;
};
exports2.mod = function mod2(divident, divisor) {
let result = new Uint8Array(divident);
while (result.length - divisor.length >= 0) {
const coeff = result[0];
for (let i = 0; i < divisor.length; i++) {
result[i] ^= GF.mul(divisor[i], coeff);
}
let offset = 0;
while (offset < result.length && result[offset] === 0)
offset++;
result = result.slice(offset);
}
return result;
};
exports2.generateECPolynomial = function generateECPolynomial(degree) {
let poly = new Uint8Array([1]);
for (let i = 0; i < degree; i++) {
poly = exports2.mul(poly, new Uint8Array([1, GF.exp(i)]));
}
return poly;
};
}
});
// node_modules/qrcode/lib/core/reed-solomon-encoder.js
var require_reed_solomon_encoder = __commonJS({
"node_modules/qrcode/lib/core/reed-solomon-encoder.js"(exports2, module2) {
"use strict";
var Polynomial = require_polynomial();
function ReedSolomonEncoder(degree) {
this.genPoly = void 0;
this.degree = degree;
if (this.degree)
this.initialize(this.degree);
}
ReedSolomonEncoder.prototype.initialize = function initialize2(degree) {
this.degree = degree;
this.genPoly = Polynomial.generateECPolynomial(this.degree);
};
ReedSolomonEncoder.prototype.encode = function encode(data2) {
if (!this.genPoly) {
throw new Error("Encoder not initialized");
}
const paddedData = new Uint8Array(data2.length + this.degree);
paddedData.set(data2);
const remainder = Polynomial.mod(paddedData, this.genPoly);
const start = this.degree - remainder.length;
if (start > 0) {
const buff = new Uint8Array(this.degree);
buff.set(remainder, start);
return buff;
}
return remainder;
};
module2.exports = ReedSolomonEncoder;
}
});
// node_modules/qrcode/lib/core/version-check.js
var require_version_check = __commonJS({
"node_modules/qrcode/lib/core/version-check.js"(exports2) {
"use strict";
exports2.isValid = function isValid(version) {
return !isNaN(version) && version >= 1 && version <= 40;
};
}
});
// node_modules/qrcode/lib/core/regex.js
var require_regex = __commonJS({
"node_modules/qrcode/lib/core/regex.js"(exports2) {
"use strict";
var numeric = "[0-9]+";
var alphanumeric = "[A-Z $%*+\\-./:]+";
var kanji = "(?:[u3000-u303F]|[u3040-u309F]|[u30A0-u30FF]|[uFF00-uFFEF]|[u4E00-u9FAF]|[u2605-u2606]|[u2190-u2195]|u203B|[u2010u2015u2018u2019u2025u2026u201Cu201Du2225u2260]|[u0391-u0451]|[u00A7u00A8u00B1u00B4u00D7u00F7])+";
kanji = kanji.replace(/u/g, "\\u");
var byte = "(?:(?![A-Z0-9 $%*+\\-./:]|" + kanji + ")(?:.|[\r\n]))+";
exports2.KANJI = new RegExp(kanji, "g");
exports2.BYTE_KANJI = new RegExp("[^A-Z0-9 $%*+\\-./:]+", "g");
exports2.BYTE = new RegExp(byte, "g");
exports2.NUMERIC = new RegExp(numeric, "g");
exports2.ALPHANUMERIC = new RegExp(alphanumeric, "g");
var TEST_KANJI = new RegExp("^" + kanji + "$");
var TEST_NUMERIC = new RegExp("^" + numeric + "$");
var TEST_ALPHANUMERIC = new RegExp("^[A-Z0-9 $%*+\\-./:]+$");
exports2.testKanji = function testKanji(str) {
return TEST_KANJI.test(str);
};
exports2.testNumeric = function testNumeric(str) {
return TEST_NUMERIC.test(str);
};
exports2.testAlphanumeric = function testAlphanumeric(str) {
return TEST_ALPHANUMERIC.test(str);
};
}
});
// node_modules/qrcode/lib/core/mode.js
var require_mode = __commonJS({
"node_modules/qrcode/lib/core/mode.js"(exports2) {
"use strict";
var VersionCheck = require_version_check();
var Regex = require_regex();
exports2.NUMERIC = {
id: "Numeric",
bit: 1 << 0,
ccBits: [10, 12, 14]
};
exports2.ALPHANUMERIC = {
id: "Alphanumeric",
bit: 1 << 1,
ccBits: [9, 11, 13]
};
exports2.BYTE = {
id: "Byte",
bit: 1 << 2,
ccBits: [8, 16, 16]
};
exports2.KANJI = {
id: "Kanji",
bit: 1 << 3,
ccBits: [8, 10, 12]
};
exports2.MIXED = {
bit: -1
};
exports2.getCharCountIndicator = function getCharCountIndicator(mode, version) {
if (!mode.ccBits)
throw new Error("Invalid mode: " + mode);
if (!VersionCheck.isValid(version)) {
throw new Error("Invalid version: " + version);
}
if (version >= 1 && version < 10)
return mode.ccBits[0];
else if (version < 27)
return mode.ccBits[1];
return mode.ccBits[2];
};
exports2.getBestModeForData = function getBestModeForData(dataStr) {
if (Regex.testNumeric(dataStr))
return exports2.NUMERIC;
else if (Regex.testAlphanumeric(dataStr))
return exports2.ALPHANUMERIC;
else if (Regex.testKanji(dataStr))
return exports2.KANJI;
else
return exports2.BYTE;
};
exports2.toString = function toString2(mode) {
if (mode && mode.id)
return mode.id;
throw new Error("Invalid mode");
};
exports2.isValid = function isValid(mode) {
return mode && mode.bit && mode.ccBits;
};
function fromString(string) {
if (typeof string !== "string") {
throw new Error("Param is not a string");
}
const lcStr = string.toLowerCase();
switch (lcStr) {
case "numeric":
return exports2.NUMERIC;
case "alphanumeric":
return exports2.ALPHANUMERIC;
case "kanji":
return exports2.KANJI;
case "byte":
return exports2.BYTE;
default:
throw new Error("Unknown mode: " + string);
}
}
exports2.from = function from2(value2, defaultValue) {
if (exports2.isValid(value2)) {
return value2;
}
try {
return fromString(value2);
} catch (e) {
return defaultValue;
}
};
}
});
// node_modules/qrcode/lib/core/version.js
var require_version = __commonJS({
"node_modules/qrcode/lib/core/version.js"(exports2) {
"use strict";
var Utils = require_utils();
var ECCode = require_error_correction_code();
var ECLevel = require_error_correction_level();
var Mode = require_mode();
var VersionCheck = require_version_check();
var G18 = 1 << 12 | 1 << 11 | 1 << 10 | 1 << 9 | 1 << 8 | 1 << 5 | 1 << 2 | 1 << 0;
var G18_BCH = Utils.getBCHDigit(G18);
function getBestVersionForDataLength(mode, length2, errorCorrectionLevel) {
for (let currentVersion = 1; currentVersion <= 40; currentVersion++) {
if (length2 <= exports2.getCapacity(currentVersion, errorCorrectionLevel, mode)) {
return currentVersion;
}
}
return void 0;
}
function getReservedBitsCount(mode, version) {
return Mode.getCharCountIndicator(mode, version) + 4;
}
function getTotalBitsFromDataArray(segments, version) {
let totalBits = 0;
segments.forEach(function(data2) {
const reservedBits = getReservedBitsCount(data2.mode, version);
totalBits += reservedBits + data2.getBitsLength();
});
return totalBits;
}
function getBestVersionForMixedData(segments, errorCorrectionLevel) {
for (let currentVersion = 1; currentVersion <= 40; currentVersion++) {
const length2 = getTotalBitsFromDataArray(segments, currentVersion);
if (length2 <= exports2.getCapacity(currentVersion, errorCorrectionLevel, Mode.MIXED)) {
return currentVersion;
}
}
return void 0;
}
exports2.from = function from2(value2, defaultValue) {
if (VersionCheck.isValid(value2)) {
return parseInt(value2, 10);
}
return defaultValue;
};
exports2.getCapacity = function getCapacity(version, errorCorrectionLevel, mode) {
if (!VersionCheck.isValid(version)) {
throw new Error("Invalid QR Code version");
}
if (typeof mode === "undefined")
mode = Mode.BYTE;
const totalCodewords = Utils.getSymbolTotalCodewords(version);
const ecTotalCodewords = ECCode.getTotalCodewordsCount(version, errorCorrectionLevel);
const dataTotalCodewordsBits = (totalCodewords - ecTotalCodewords) * 8;
if (mode === Mode.MIXED)
return dataTotalCodewordsBits;
const usableBits = dataTotalCodewordsBits - getReservedBitsCount(mode, version);
switch (mode) {
case Mode.NUMERIC:
return Math.floor(usableBits / 10 * 3);
case Mode.ALPHANUMERIC:
return Math.floor(usableBits / 11 * 2);
case Mode.KANJI:
return Math.floor(usableBits / 13);
case Mode.BYTE:
default:
return Math.floor(usableBits / 8);
}
};
exports2.getBestVersionForData = function getBestVersionForData(data2, errorCorrectionLevel) {
let seg;
const ecl = ECLevel.from(errorCorrectionLevel, ECLevel.M);
if (Array.isArray(data2)) {
if (data2.length > 1) {
return getBestVersionForMixedData(data2, ecl);
}
if (data2.length === 0) {
return 1;
}
seg = data2[0];
} else {
seg = data2;
}
return getBestVersionForDataLength(seg.mode, seg.getLength(), ecl);
};
exports2.getEncodedBits = function getEncodedBits(version) {
if (!VersionCheck.isValid(version) || version < 7) {
throw new Error("Invalid QR Code version");
}
let d = version << 12;
while (Utils.getBCHDigit(d) - G18_BCH >= 0) {
d ^= G18 << Utils.getBCHDigit(d) - G18_BCH;
}
return version << 12 | d;
};
}
});
// node_modules/qrcode/lib/core/format-info.js
var require_format_info = __commonJS({
"node_modules/qrcode/lib/core/format-info.js"(exports2) {
"use strict";
var Utils = require_utils();
var G15 = 1 << 10 | 1 << 8 | 1 << 5 | 1 << 4 | 1 << 2 | 1 << 1 | 1 << 0;
var G15_MASK = 1 << 14 | 1 << 12 | 1 << 10 | 1 << 4 | 1 << 1;
var G15_BCH = Utils.getBCHDigit(G15);
exports2.getEncodedBits = function getEncodedBits(errorCorrectionLevel, mask2) {
const data2 = errorCorrectionLevel.bit << 3 | mask2;
let d = data2 << 10;
while (Utils.getBCHDigit(d) - G15_BCH >= 0) {
d ^= G15 << Utils.getBCHDigit(d) - G15_BCH;
}
return (data2 << 10 | d) ^ G15_MASK;
};
}
});
// node_modules/qrcode/lib/core/numeric-data.js
var require_numeric_data = __commonJS({
"node_modules/qrcode/lib/core/numeric-data.js"(exports2, module2) {
"use strict";
var Mode = require_mode();
function NumericData(data2) {
this.mode = Mode.NUMERIC;
this.data = data2.toString();
}
NumericData.getBitsLength = function getBitsLength(length2) {
return 10 * Math.floor(length2 / 3) + (length2 % 3 ? length2 % 3 * 3 + 1 : 0);
};
NumericData.prototype.getLength = function getLength() {
return this.data.length;
};
NumericData.prototype.getBitsLength = function getBitsLength() {
return NumericData.getBitsLength(this.data.length);
};
NumericData.prototype.write = function write(bitBuffer) {
let i, group, value2;
for (i = 0; i + 3 <= this.data.length; i += 3) {
group = this.data.substr(i, 3);
value2 = parseInt(group, 10);
bitBuffer.put(value2, 10);
}
const remainingNum = this.data.length - i;
if (remainingNum > 0) {
group = this.data.substr(i);
value2 = parseInt(group, 10);
bitBuffer.put(value2, remainingNum * 3 + 1);
}
};
module2.exports = NumericData;
}
});
// node_modules/qrcode/lib/core/alphanumeric-data.js
var require_alphanumeric_data = __commonJS({
"node_modules/qrcode/lib/core/alphanumeric-data.js"(exports2, module2) {
"use strict";
var Mode = require_mode();
var ALPHA_NUM_CHARS = [
"0",
"1",
"2",
"3",
"4",
"5",
"6",
"7",
"8",
"9",
"A",
"B",
"C",
"D",
"E",
"F",
"G",
"H",
"I",
"J",
"K",
"L",
"M",
"N",
"O",
"P",
"Q",
"R",
"S",
"T",
"U",
"V",
"W",
"X",
"Y",
"Z",
" ",
"$",
"%",
"*",
"+",
"-",
".",
"/",
":"
];
function AlphanumericData(data2) {
this.mode = Mode.ALPHANUMERIC;
this.data = data2;
}
AlphanumericData.getBitsLength = function getBitsLength(length2) {
return 11 * Math.floor(length2 / 2) + 6 * (length2 % 2);
};
AlphanumericData.prototype.getLength = function getLength() {
return this.data.length;
};
AlphanumericData.prototype.getBitsLength = function getBitsLength() {
return AlphanumericData.getBitsLength(this.data.length);
};
AlphanumericData.prototype.write = function write(bitBuffer) {
let i;
for (i = 0; i + 2 <= this.data.length; i += 2) {
let value2 = ALPHA_NUM_CHARS.indexOf(this.data[i]) * 45;
value2 += ALPHA_NUM_CHARS.indexOf(this.data[i + 1]);
bitBuffer.put(value2, 11);
}
if (this.data.length % 2) {
bitBuffer.put(ALPHA_NUM_CHARS.indexOf(this.data[i]), 6);
}
};
module2.exports = AlphanumericData;
}
});
// node_modules/encode-utf8/index.js
var require_encode_utf8 = __commonJS({
"node_modules/encode-utf8/index.js"(exports2, module2) {
"use strict";
module2.exports = function encodeUtf8(input2) {
var result = [];
var size = input2.length;
for (var index2 = 0; index2 < size; index2++) {
var point = input2.charCodeAt(index2);
if (point >= 55296 && point <= 56319 && size > index2 + 1) {
var second = input2.charCodeAt(index2 + 1);
if (second >= 56320 && second <= 57343) {
point = (point - 55296) * 1024 + second - 56320 + 65536;
index2 += 1;
}
}
if (point < 128) {
result.push(point);
continue;
}
if (point < 2048) {
result.push(point >> 6 | 192);
result.push(point & 63 | 128);
continue;
}
if (point < 55296 || point >= 57344 && point < 65536) {
result.push(point >> 12 | 224);
result.push(point >> 6 & 63 | 128);
result.push(point & 63 | 128);
continue;
}
if (point >= 65536 && point <= 1114111) {
result.push(point >> 18 | 240);
result.push(point >> 12 & 63 | 128);
result.push(point >> 6 & 63 | 128);
result.push(point & 63 | 128);
continue;
}
result.push(239, 191, 189);
}
return new Uint8Array(result).buffer;
};
}
});
// node_modules/qrcode/lib/core/byte-data.js
var require_byte_data = __commonJS({
"node_modules/qrcode/lib/core/byte-data.js"(exports2, module2) {
"use strict";
var encodeUtf8 = require_encode_utf8();
var Mode = require_mode();
function ByteData(data2) {
this.mode = Mode.BYTE;
if (typeof data2 === "string") {
data2 = encodeUtf8(data2);
}
this.data = new Uint8Array(data2);
}
ByteData.getBitsLength = function getBitsLength(length2) {
return length2 * 8;
};
ByteData.prototype.getLength = function getLength() {
return this.data.length;
};
ByteData.prototype.getBitsLength = function getBitsLength() {
return ByteData.getBitsLength(this.data.length);
};
ByteData.prototype.write = function(bitBuffer) {
for (let i = 0, l = this.data.length; i < l; i++) {
bitBuffer.put(this.data[i], 8);
}
};
module2.exports = ByteData;
}
});
// node_modules/qrcode/lib/core/kanji-data.js
var require_kanji_data = __commonJS({
"node_modules/qrcode/lib/core/kanji-data.js"(exports2, module2) {
"use strict";
var Mode = require_mode();
var Utils = require_utils();
function KanjiData(data2) {
this.mode = Mode.KANJI;
this.data = data2;
}
KanjiData.getBitsLength = function getBitsLength(length2) {
return length2 * 13;
};
KanjiData.prototype.getLength = function getLength() {
return this.data.length;
};
KanjiData.prototype.getBitsLength = function getBitsLength() {
return KanjiData.getBitsLength(this.data.length);
};
KanjiData.prototype.write = function(bitBuffer) {
let i;
for (i = 0; i < this.data.length; i++) {
let value2 = Utils.toSJIS(this.data[i]);
if (value2 >= 33088 && value2 <= 40956) {
value2 -= 33088;
} else if (value2 >= 57408 && value2 <= 60351) {
value2 -= 49472;
} else {
throw new Error(
"Invalid SJIS character: " + this.data[i] + "\nMake sure your charset is UTF-8"
);
}
value2 = (value2 >>> 8 & 255) * 192 + (value2 & 255);
bitBuffer.put(value2, 13);
}
};
module2.exports = KanjiData;
}
});
// node_modules/dijkstrajs/dijkstra.js
var require_dijkstra = __commonJS({
"node_modules/dijkstrajs/dijkstra.js"(exports2, module2) {
"use strict";
var dijkstra = {
single_source_shortest_paths: function(graph, s, d) {
var predecessors = {};
var costs = {};
costs[s] = 0;
var open = dijkstra.PriorityQueue.make();
open.push(s, 0);
var closest, u2, v, cost_of_s_to_u, adjacent_nodes, cost_of_e, cost_of_s_to_u_plus_cost_of_e, cost_of_s_to_v, first_visit;
while (!open.empty()) {
closest = open.pop();
u2 = closest.value;
cost_of_s_to_u = closest.cost;
adjacent_nodes = graph[u2] || {};
for (v in adjacent_nodes) {
if (adjacent_nodes.hasOwnProperty(v)) {
cost_of_e = adjacent_nodes[v];
cost_of_s_to_u_plus_cost_of_e = cost_of_s_to_u + cost_of_e;
cost_of_s_to_v = costs[v];
first_visit = typeof costs[v] === "undefined";
if (first_visit || cost_of_s_to_v > cost_of_s_to_u_plus_cost_of_e) {
costs[v] = cost_of_s_to_u_plus_cost_of_e;
open.push(v, cost_of_s_to_u_plus_cost_of_e);
predecessors[v] = u2;
}
}
}
}
if (typeof d !== "undefined" && typeof costs[d] === "undefined") {
var msg = ["Could not find a path from ", s, " to ", d, "."].join("");
throw new Error(msg);
}
return predecessors;
},
extract_shortest_path_from_predecessor_list: function(predecessors, d) {
var nodes = [];
var u2 = d;
var predecessor;
while (u2) {
nodes.push(u2);
predecessor = predecessors[u2];
u2 = predecessors[u2];
}
nodes.reverse();
return nodes;
},
find_path: function(graph, s, d) {
var predecessors = dijkstra.single_source_shortest_paths(graph, s, d);
return dijkstra.extract_shortest_path_from_predecessor_list(
predecessors,
d
);
},
/**
* A very naive priority queue implementation.
*/
PriorityQueue: {
make: function(opts) {
var T = dijkstra.PriorityQueue, t = {}, key2;
opts = opts || {};
for (key2 in T) {
if (T.hasOwnProperty(key2)) {
t[key2] = T[key2];
}
}
t.queue = [];
t.sorter = opts.sorter || T.default_sorter;
return t;
},
default_sorter: function(a, b) {
return a.cost - b.cost;
},
/**
* Add a new item to the queue and ensure the highest priority element
* is at the front of the queue.
*/
push: function(value2, cost) {
var item = { value: value2, cost };
this.queue.push(item);
this.queue.sort(this.sorter);
},
/**
* Return the highest priority element in the queue.
*/
pop: function() {
return this.queue.shift();
},
empty: function() {
return this.queue.length === 0;
}
}
};
if (typeof module2 !== "undefined") {
module2.exports = dijkstra;
}
}
});
// node_modules/qrcode/lib/core/segments.js
var require_segments = __commonJS({
"node_modules/qrcode/lib/core/segments.js"(exports2) {
"use strict";
var Mode = require_mode();
var NumericData = require_numeric_data();
var AlphanumericData = require_alphanumeric_data();
var ByteData = require_byte_data();
var KanjiData = require_kanji_data();
var Regex = require_regex();
var Utils = require_utils();
var dijkstra = require_dijkstra();
function getStringByteLength(str) {
return unescape(encodeURIComponent(str)).length;
}
function getSegments(regex, mode, str) {
const segments = [];
let result;
while ((result = regex.exec(str)) !== null) {
segments.push({
data: result[0],
index: result.index,
mode,
length: result[0].length
});
}
return segments;
}
function getSegmentsFromString(dataStr) {
const numSegs = getSegments(Regex.NUMERIC, Mode.NUMERIC, dataStr);
const alphaNumSegs = getSegments(Regex.ALPHANUMERIC, Mode.ALPHANUMERIC, dataStr);
let byteSegs;
let kanjiSegs;
if (Utils.isKanjiModeEnabled()) {
byteSegs = getSegments(Regex.BYTE, Mode.BYTE, dataStr);
kanjiSegs = getSegments(Regex.KANJI, Mode.KANJI, dataStr);
} else {
byteSegs = getSegments(Regex.BYTE_KANJI, Mode.BYTE, dataStr);
kanjiSegs = [];
}
const segs = numSegs.concat(alphaNumSegs, byteSegs, kanjiSegs);
return segs.sort(function(s1, s2) {
return s1.index - s2.index;
}).map(function(obj) {
return {
data: obj.data,
mode: obj.mode,
length: obj.length
};
});
}
function getSegmentBitsLength(length2, mode) {
switch (mode) {
case Mode.NUMERIC:
return NumericData.getBitsLength(length2);
case Mode.ALPHANUMERIC:
return AlphanumericData.getBitsLength(length2);
case Mode.KANJI:
return KanjiData.getBitsLength(length2);
case Mode.BYTE:
return ByteData.getBitsLength(length2);
}
}
function mergeSegments(segs) {
return segs.reduce(function(acc, curr) {
const prevSeg = acc.length - 1 >= 0 ? acc[acc.length - 1] : null;
if (prevSeg && prevSeg.mode === curr.mode) {
acc[acc.length - 1].data += curr.data;
return acc;
}
acc.push(curr);
return acc;
}, []);
}
function buildNodes(segs) {
const nodes = [];
for (let i = 0; i < segs.length; i++) {
const seg = segs[i];
switch (seg.mode) {
case Mode.NUMERIC:
nodes.push([
seg,
{ data: seg.data, mode: Mode.ALPHANUMERIC, length: seg.length },
{ data: seg.data, mode: Mode.BYTE, length: seg.length }
]);
break;
case Mode.ALPHANUMERIC:
nodes.push([
seg,
{ data: seg.data, mode: Mode.BYTE, length: seg.length }
]);
break;
case Mode.KANJI:
nodes.push([
seg,
{ data: seg.data, mode: Mode.BYTE, length: getStringByteLength(seg.data) }
]);
break;
case Mode.BYTE:
nodes.push([
{ data: seg.data, mode: Mode.BYTE, length: getStringByteLength(seg.data) }
]);
}
}
return nodes;
}
function buildGraph(nodes, version) {
const table = {};
const graph = { start: {} };
let prevNodeIds = ["start"];
for (let i = 0; i < nodes.length; i++) {
const nodeGroup = nodes[i];
const currentNodeIds = [];
for (let j = 0; j < nodeGroup.length; j++) {
const node = nodeGroup[j];
const key2 = "" + i + j;
currentNodeIds.push(key2);
table[key2] = { node, lastCount: 0 };
graph[key2] = {};
for (let n = 0; n < prevNodeIds.length; n++) {
const prevNodeId = prevNodeIds[n];
if (table[prevNodeId] && table[prevNodeId].node.mode === node.mode) {
graph[prevNodeId][key2] = getSegmentBitsLength(table[prevNodeId].lastCount + node.length, node.mode) - getSegmentBitsLength(table[prevNodeId].lastCount, node.mode);
table[prevNodeId].lastCount += node.length;
} else {
if (table[prevNodeId])
table[prevNodeId].lastCount = node.length;
graph[prevNodeId][key2] = getSegmentBitsLength(node.length, node.mode) + 4 + Mode.getCharCountIndicator(node.mode, version);
}
}
}
prevNodeIds = currentNodeIds;
}
for (let n = 0; n < prevNodeIds.length; n++) {
graph[prevNodeIds[n]].end = 0;
}
return { map: graph, table };
}
function buildSingleSegment(data2, modesHint) {
let mode;
const bestMode = Mode.getBestModeForData(data2);
mode = Mode.from(modesHint, bestMode);
if (mode !== Mode.BYTE && mode.bit < bestMode.bit) {
throw new Error('"' + data2 + '" cannot be encoded with mode ' + Mode.toString(mode) + ".\n Suggested mode is: " + Mode.toString(bestMode));
}
if (mode === Mode.KANJI && !Utils.isKanjiModeEnabled()) {
mode = Mode.BYTE;
}
switch (mode) {
case Mode.NUMERIC:
return new NumericData(data2);
case Mode.ALPHANUMERIC:
return new AlphanumericData(data2);
case Mode.KANJI:
return new KanjiData(data2);
case Mode.BYTE:
return new ByteData(data2);
}
}
exports2.fromArray = function fromArray(array) {
return array.reduce(function(acc, seg) {
if (typeof seg === "string") {
acc.push(buildSingleSegment(seg, null));
} else if (seg.data) {
acc.push(buildSingleSegment(seg.data, seg.mode));
}
return acc;
}, []);
};
exports2.fromString = function fromString(data2, version) {
const segs = getSegmentsFromString(data2, Utils.isKanjiModeEnabled());
const nodes = buildNodes(segs);
const graph = buildGraph(nodes, version);
const path = dijkstra.find_path(graph.map, "start", "end");
const optimizedSegs = [];
for (let i = 1; i < path.length - 1; i++) {
optimizedSegs.push(graph.table[path[i]].node);
}
return exports2.fromArray(mergeSegments(optimizedSegs));
};
exports2.rawSplit = function rawSplit(data2) {
return exports2.fromArray(
getSegmentsFromString(data2, Utils.isKanjiModeEnabled())
);
};
}
});
// node_modules/qrcode/lib/core/qrcode.js
var require_qrcode = __commonJS({
"node_modules/qrcode/lib/core/qrcode.js"(exports2) {
"use strict";
var Utils = require_utils();
var ECLevel = require_error_correction_level();
var BitBuffer = require_bit_buffer();
var BitMatrix = require_bit_matrix();
var AlignmentPattern = require_alignment_pattern();
var FinderPattern = require_finder_pattern();
var MaskPattern = require_mask_pattern();
var ECCode = require_error_correction_code();
var ReedSolomonEncoder = require_reed_solomon_encoder();
var Version2 = require_version();
var FormatInfo = require_format_info();
var Mode = require_mode();
var Segments = require_segments();
function setupFinderPattern(matrix, version) {
const size = matrix.size;
const pos = FinderPattern.getPositions(version);
for (let i = 0; i < pos.length; i++) {
const row = pos[i][0];
const col = pos[i][1];
for (let r = -1; r <= 7; r++) {
if (row + r <= -1 || size <= row + r)
continue;
for (let c = -1; c <= 7; c++) {
if (col + c <= -1 || size <= col + c)
continue;
if (r >= 0 && r <= 6 && (c === 0 || c === 6) || c >= 0 && c <= 6 && (r === 0 || r === 6) || r >= 2 && r <= 4 && c >= 2 && c <= 4) {
matrix.set(row + r, col + c, true, true);
} else {
matrix.set(row + r, col + c, false, true);
}
}
}
}
}
function setupTimingPattern(matrix) {
const size = matrix.size;
for (let r = 8; r < size - 8; r++) {
const value2 = r % 2 === 0;
matrix.set(r, 6, value2, true);
matrix.set(6, r, value2, true);
}
}
function setupAlignmentPattern(matrix, version) {
const pos = AlignmentPattern.getPositions(version);
for (let i = 0; i < pos.length; i++) {
const row = pos[i][0];
const col = pos[i][1];
for (let r = -2; r <= 2; r++) {
for (let c = -2; c <= 2; c++) {
if (r === -2 || r === 2 || c === -2 || c === 2 || r === 0 && c === 0) {
matrix.set(row + r, col + c, true, true);
} else {
matrix.set(row + r, col + c, false, true);
}
}
}
}
}
function setupVersionInfo(matrix, version) {
const size = matrix.size;
const bits = Version2.getEncodedBits(version);
let row, col, mod2;
for (let i = 0; i < 18; i++) {
row = Math.floor(i / 3);
col = i % 3 + size - 8 - 3;
mod2 = (bits >> i & 1) === 1;
matrix.set(row, col, mod2, true);
matrix.set(col, row, mod2, true);
}
}
function setupFormatInfo(matrix, errorCorrectionLevel, maskPattern) {
const size = matrix.size;
const bits = FormatInfo.getEncodedBits(errorCorrectionLevel, maskPattern);
let i, mod2;
for (i = 0; i < 15; i++) {
mod2 = (bits >> i & 1) === 1;
if (i < 6) {
matrix.set(i, 8, mod2, true);
} else if (i < 8) {
matrix.set(i + 1, 8, mod2, true);
} else {
matrix.set(size - 15 + i, 8, mod2, true);
}
if (i < 8) {
matrix.set(8, size - i - 1, mod2, true);
} else if (i < 9) {
matrix.set(8, 15 - i - 1 + 1, mod2, true);
} else {
matrix.set(8, 15 - i - 1, mod2, true);
}
}
matrix.set(size - 8, 8, 1, true);
}
function setupData(matrix, data2) {
const size = matrix.size;
let inc = -1;
let row = size - 1;
let bitIndex = 7;
let byteIndex = 0;
for (let col = size - 1; col > 0; col -= 2) {
if (col === 6)
col--;
while (true) {
for (let c = 0; c < 2; c++) {
if (!matrix.isReserved(row, col - c)) {
let dark = false;
if (byteIndex < data2.length) {
dark = (data2[byteIndex] >>> bitIndex & 1) === 1;
}
matrix.set(row, col - c, dark);
bitIndex--;
if (bitIndex === -1) {
byteIndex++;
bitIndex = 7;
}
}
}
row += inc;
if (row < 0 || size <= row) {
row -= inc;
inc = -inc;
break;
}
}
}
}
function createData(version, errorCorrectionLevel, segments) {
const buffer = new BitBuffer();
segments.forEach(function(data2) {
buffer.put(data2.mode.bit, 4);
buffer.put(data2.getLength(), Mode.getCharCountIndicator(data2.mode, version));
data2.write(buffer);
});
const totalCodewords = Utils.getSymbolTotalCodewords(version);
const ecTotalCodewords = ECCode.getTotalCodewordsCount(version, errorCorrectionLevel);
const dataTotalCodewordsBits = (totalCodewords - ecTotalCodewords) * 8;
if (buffer.getLengthInBits() + 4 <= dataTotalCodewordsBits) {
buffer.put(0, 4);
}
while (buffer.getLengthInBits() % 8 !== 0) {
buffer.putBit(0);
}
const remainingByte = (dataTotalCodewordsBits - buffer.getLengthInBits()) / 8;
for (let i = 0; i < remainingByte; i++) {
buffer.put(i % 2 ? 17 : 236, 8);
}
return createCodewords(buffer, version, errorCorrectionLevel);
}
function createCodewords(bitBuffer, version, errorCorrectionLevel) {
const totalCodewords = Utils.getSymbolTotalCodewords(version);
const ecTotalCodewords = ECCode.getTotalCodewordsCount(version, errorCorrectionLevel);
const dataTotalCodewords = totalCodewords - ecTotalCodewords;
const ecTotalBlocks = ECCode.getBlocksCount(version, errorCorrectionLevel);
const blocksInGroup2 = totalCodewords % ecTotalBlocks;
const blocksInGroup1 = ecTotalBlocks - blocksInGroup2;
const totalCodewordsInGroup1 = Math.floor(totalCodewords / ecTotalBlocks);
const dataCodewordsInGroup1 = Math.floor(dataTotalCodewords / ecTotalBlocks);
const dataCodewordsInGroup2 = dataCodewordsInGroup1 + 1;
const ecCount = totalCodewordsInGroup1 - dataCodewordsInGroup1;
const rs = new ReedSolomonEncoder(ecCount);
let offset = 0;
const dcData = new Array(ecTotalBlocks);
const ecData = new Array(ecTotalBlocks);
let maxDataSize = 0;
const buffer = new Uint8Array(bitBuffer.buffer);
for (let b = 0; b < ecTotalBlocks; b++) {
const dataSize = b < blocksInGroup1 ? dataCodewordsInGroup1 : dataCodewordsInGroup2;
dcData[b] = buffer.slice(offset, offset + dataSize);
ecData[b] = rs.encode(dcData[b]);
offset += dataSize;
maxDataSize = Math.max(maxDataSize, dataSize);
}
const data2 = new Uint8Array(totalCodewords);
let index2 = 0;
let i, r;
for (i = 0; i < maxDataSize; i++) {
for (r = 0; r < ecTotalBlocks; r++) {
if (i < dcData[r].length) {
data2[index2++] = dcData[r][i];
}
}
}
for (i = 0; i < ecCount; i++) {
for (r = 0; r < ecTotalBlocks; r++) {
data2[index2++] = ecData[r][i];
}
}
return data2;
}
function createSymbol(data2, version, errorCorrectionLevel, maskPattern) {
let segments;
if (Array.isArray(data2)) {
segments = Segments.fromArray(data2);
} else if (typeof data2 === "string") {
let estimatedVersion = version;
if (!estimatedVersion) {
const rawSegments = Segments.rawSplit(data2);
estimatedVersion = Version2.getBestVersionForData(rawSegments, errorCorrectionLevel);
}
segments = Segments.fromString(data2, estimatedVersion || 40);
} else {
throw new Error("Invalid data");
}
const bestVersion = Version2.getBestVersionForData(segments, errorCorrectionLevel);
if (!bestVersion) {
throw new Error("The amount of data is too big to be stored in a QR Code");
}
if (!version) {
version = bestVersion;
} else if (version < bestVersion) {
throw new Error(
"\nThe chosen QR Code version cannot contain this amount of data.\nMinimum version required to store current data is: " + bestVersion + ".\n"
);
}
const dataBits = createData(version, errorCorrectionLevel, segments);
const moduleCount = Utils.getSymbolSize(version);
const modules2 = new BitMatrix(moduleCount);
setupFinderPattern(modules2, version);
setupTimingPattern(modules2);
setupAlignmentPattern(modules2, version);
setupFormatInfo(modules2, errorCorrectionLevel, 0);
if (version >= 7) {
setupVersionInfo(modules2, version);
}
setupData(modules2, dataBits);
if (isNaN(maskPattern)) {
maskPattern = MaskPattern.getBestMask(
modules2,
setupFormatInfo.bind(null, modules2, errorCorrectionLevel)
);
}
MaskPattern.applyMask(maskPattern, modules2);
setupFormatInfo(modules2, errorCorrectionLevel, maskPattern);
return {
modules: modules2,
version,
errorCorrectionLevel,
maskPattern,
segments
};
}
exports2.create = function create(data2, options) {
if (typeof data2 === "undefined" || data2 === "") {
throw new Error("No input text");
}
let errorCorrectionLevel = ECLevel.M;
let version;
let mask2;
if (typeof options !== "undefined") {
errorCorrectionLevel = ECLevel.from(options.errorCorrectionLevel, ECLevel.M);
version = Version2.from(options.version);
mask2 = MaskPattern.from(options.maskPattern);
if (options.toSJISFunc) {
Utils.setToSJISFunction(options.toSJISFunc);
}
}
return createSymbol(data2, version, errorCorrectionLevel, mask2);
};
}
});
// node_modules/qrcode/lib/renderer/utils.js
var require_utils2 = __commonJS({
"node_modules/qrcode/lib/renderer/utils.js"(exports2) {
"use strict";
function hex2rgba(hex) {
if (typeof hex === "number") {
hex = hex.toString();
}
if (typeof hex !== "string") {
throw new Error("Color should be defined as hex string");
}
let hexCode = hex.slice().replace("#", "").split("");
if (hexCode.length < 3 || hexCode.length === 5 || hexCode.length > 8) {
throw new Error("Invalid hex color: " + hex);
}
if (hexCode.length === 3 || hexCode.length === 4) {
hexCode = Array.prototype.concat.apply([], hexCode.map(function(c) {
return [c, c];
}));
}
if (hexCode.length === 6)
hexCode.push("F", "F");
const hexValue = parseInt(hexCode.join(""), 16);
return {
r: hexValue >> 24 & 255,
g: hexValue >> 16 & 255,
b: hexValue >> 8 & 255,
a: hexValue & 255,
hex: "#" + hexCode.slice(0, 6).join("")
};
}
exports2.getOptions = function getOptions(options) {
if (!options)
options = {};
if (!options.color)
options.color = {};
const margin = typeof options.margin === "undefined" || options.margin === null || options.margin < 0 ? 4 : options.margin;
const width2 = options.width && options.width >= 21 ? options.width : void 0;
const scale2 = options.scale || 4;
return {
width: width2,
scale: width2 ? 4 : scale2,
margin,
color: {
dark: hex2rgba(options.color.dark || "#000000ff"),
light: hex2rgba(options.color.light || "#ffffffff")
},
type: options.type,
rendererOpts: options.rendererOpts || {}
};
};
exports2.getScale = function getScale(qrSize, opts) {
return opts.width && opts.width >= qrSize + opts.margin * 2 ? opts.width / (qrSize + opts.margin * 2) : opts.scale;
};
exports2.getImageWidth = function getImageWidth(qrSize, opts) {
const scale2 = exports2.getScale(qrSize, opts);
return Math.floor((qrSize + opts.margin * 2) * scale2);
};
exports2.qrToImageData = function qrToImageData(imgData, qr, opts) {
const size = qr.modules.size;
const data2 = qr.modules.data;
const scale2 = exports2.getScale(size, opts);
const symbolSize = Math.floor((size + opts.margin * 2) * scale2);
const scaledMargin = opts.margin * scale2;
const palette = [opts.color.light, opts.color.dark];
for (let i = 0; i < symbolSize; i++) {
for (let j = 0; j < symbolSize; j++) {
let posDst = (i * symbolSize + j) * 4;
let pxColor = opts.color.light;
if (i >= scaledMargin && j >= scaledMargin && i < symbolSize - scaledMargin && j < symbolSize - scaledMargin) {
const iSrc = Math.floor((i - scaledMargin) / scale2);
const jSrc = Math.floor((j - scaledMargin) / scale2);
pxColor = palette[data2[iSrc * size + jSrc] ? 1 : 0];
}
imgData[posDst++] = pxColor.r;
imgData[posDst++] = pxColor.g;
imgData[posDst++] = pxColor.b;
imgData[posDst] = pxColor.a;
}
}
};
}
});
// node_modules/qrcode/lib/renderer/canvas.js
var require_canvas = __commonJS({
"node_modules/qrcode/lib/renderer/canvas.js"(exports2) {
"use strict";
var Utils = require_utils2();
function clearCanvas(ctx, canvas, size) {
ctx.clearRect(0, 0, canvas.width, canvas.height);
if (!canvas.style)
canvas.style = {};
canvas.height = size;
canvas.width = size;
canvas.style.height = size + "px";
canvas.style.width = size + "px";
}
function getCanvasElement() {
try {
return document.createElement("canvas");
} catch (e) {
throw new Error("You need to specify a canvas element");
}
}
exports2.render = function render(qrData, canvas, options) {
let opts = options;
let canvasEl = canvas;
if (typeof opts === "undefined" && (!canvas || !canvas.getContext)) {
opts = canvas;
canvas = void 0;
}
if (!canvas) {
canvasEl = getCanvasElement();
}
opts = Utils.getOptions(opts);
const size = Utils.getImageWidth(qrData.modules.size, opts);
const ctx = canvasEl.getContext("2d");
const image = ctx.createImageData(size, size);
Utils.qrToImageData(image.data, qrData, opts);
clearCanvas(ctx, canvasEl, size);
ctx.putImageData(image, 0, 0);
return canvasEl;
};
exports2.renderToDataURL = function renderToDataURL(qrData, canvas, options) {
let opts = options;
if (typeof opts === "undefined" && (!canvas || !canvas.getContext)) {
opts = canvas;
canvas = void 0;
}
if (!opts)
opts = {};
const canvasEl = exports2.render(qrData, canvas, opts);
const type = opts.type || "image/png";
const rendererOpts = opts.rendererOpts || {};
return canvasEl.toDataURL(type, rendererOpts.quality);
};
}
});
// node_modules/qrcode/lib/renderer/svg-tag.js
var require_svg_tag = __commonJS({
"node_modules/qrcode/lib/renderer/svg-tag.js"(exports2) {
"use strict";
var Utils = require_utils2();
function getColorAttrib(color, attrib) {
const alpha = color.a / 255;
const str = attrib + '="' + color.hex + '"';
return alpha < 1 ? str + " " + attrib + '-opacity="' + alpha.toFixed(2).slice(1) + '"' : str;
}
function svgCmd(cmd, x, y) {
let str = cmd + x;
if (typeof y !== "undefined")
str += " " + y;
return str;
}
function qrToPath(data2, size, margin) {
let path = "";
let moveBy = 0;
let newRow = false;
let lineLength = 0;
for (let i = 0; i < data2.length; i++) {
const col = Math.floor(i % size);
const row = Math.floor(i / size);
if (!col && !newRow)
newRow = true;
if (data2[i]) {
lineLength++;
if (!(i > 0 && col > 0 && data2[i - 1])) {
path += newRow ? svgCmd("M", col + margin, 0.5 + row + margin) : svgCmd("m", moveBy, 0);
moveBy = 0;
newRow = false;
}
if (!(col + 1 < size && data2[i + 1])) {
path += svgCmd("h", lineLength);
lineLength = 0;
}
} else {
moveBy++;
}
}
return path;
}
exports2.render = function render(qrData, options, cb) {
const opts = Utils.getOptions(options);
const size = qrData.modules.size;
const data2 = qrData.modules.data;
const qrcodesize = size + opts.margin * 2;
const bg = !opts.color.light.a ? "" : "<path " + getColorAttrib(opts.color.light, "fill") + ' d="M0 0h' + qrcodesize + "v" + qrcodesize + 'H0z"/>';
const path = "<path " + getColorAttrib(opts.color.dark, "stroke") + ' d="' + qrToPath(data2, size, opts.margin) + '"/>';
const viewBox = 'viewBox="0 0 ' + qrcodesize + " " + qrcodesize + '"';
const width2 = !opts.width ? "" : 'width="' + opts.width + '" height="' + opts.width + '" ';
const svgTag = '<svg xmlns="http://www.w3.org/2000/svg" ' + width2 + viewBox + ' shape-rendering="crispEdges">' + bg + path + "</svg>\n";
if (typeof cb === "function") {
cb(null, svgTag);
}
return svgTag;
};
}
});
// node_modules/qrcode/lib/browser.js
var require_browser = __commonJS({
"node_modules/qrcode/lib/browser.js"(exports2) {
"use strict";
var canPromise = require_can_promise();
var QRCode = require_qrcode();
var CanvasRenderer2 = require_canvas();
var SvgRenderer = require_svg_tag();
function renderCanvas(renderFunc, canvas, text2, opts, cb) {
const args = [].slice.call(arguments, 1);
const argsNum = args.length;
const isLastArgCb = typeof args[argsNum - 1] === "function";
if (!isLastArgCb && !canPromise()) {
throw new Error("Callback required as last argument");
}
if (isLastArgCb) {
if (argsNum < 2) {
throw new Error("Too few arguments provided");
}
if (argsNum === 2) {
cb = text2;
text2 = canvas;
canvas = opts = void 0;
} else if (argsNum === 3) {
if (canvas.getContext && typeof cb === "undefined") {
cb = opts;
opts = void 0;
} else {
cb = opts;
opts = text2;
text2 = canvas;
canvas = void 0;
}
}
} else {
if (argsNum < 1) {
throw new Error("Too few arguments provided");
}
if (argsNum === 1) {
text2 = canvas;
canvas = opts = void 0;
} else if (argsNum === 2 && !canvas.getContext) {
opts = text2;
text2 = canvas;
canvas = void 0;
}
return new Promise(function(resolve, reject) {
try {
const data2 = QRCode.create(text2, opts);
resolve(renderFunc(data2, canvas, opts));
} catch (e) {
reject(e);
}
});
}
try {
const data2 = QRCode.create(text2, opts);
cb(null, renderFunc(data2, canvas, opts));
} catch (e) {
cb(e);
}
}
exports2.create = QRCode.create;
exports2.toCanvas = renderCanvas.bind(null, CanvasRenderer2.render);
exports2.toDataURL = renderCanvas.bind(null, CanvasRenderer2.renderToDataURL);
exports2.toString = renderCanvas.bind(null, function(data2, _, opts) {
return SvgRenderer.render(data2, opts);
});
}
});
// node_modules/pusher-js/dist/web/pusher.js
var require_pusher = __commonJS({
"node_modules/pusher-js/dist/web/pusher.js"(exports2, module2) {
"use strict";
(function webpackUniversalModuleDefinition(root, factory) {
if (typeof exports2 === "object" && typeof module2 === "object")
module2.exports = factory();
else if (typeof define === "function" && define.amd)
define([], factory);
else if (typeof exports2 === "object")
exports2["Pusher"] = factory();
else
root["Pusher"] = factory();
})(window, function() {
return (
/******/
function(modules2) {
var installedModules = {};
function __webpack_require__(moduleId) {
if (installedModules[moduleId]) {
return installedModules[moduleId].exports;
}
var module3 = installedModules[moduleId] = {
/******/
i: moduleId,
/******/
l: false,
/******/
exports: {}
/******/
};
modules2[moduleId].call(module3.exports, module3, module3.exports, __webpack_require__);
module3.l = true;
return module3.exports;
}
__webpack_require__.m = modules2;
__webpack_require__.c = installedModules;
__webpack_require__.d = function(exports3, name2, getter) {
if (!__webpack_require__.o(exports3, name2)) {
Object.defineProperty(exports3, name2, { enumerable: true, get: getter });
}
};
__webpack_require__.r = function(exports3) {
if (typeof Symbol !== "undefined" && Symbol.toStringTag) {
Object.defineProperty(exports3, Symbol.toStringTag, { value: "Module" });
}
Object.defineProperty(exports3, "__esModule", { value: true });
};
__webpack_require__.t = function(value2, mode) {
if (mode & 1)
value2 = __webpack_require__(value2);
if (mode & 8)
return value2;
if (mode & 4 && typeof value2 === "object" && value2 && value2.__esModule)
return value2;
var ns = /* @__PURE__ */ Object.create(null);
__webpack_require__.r(ns);
Object.defineProperty(ns, "default", { enumerable: true, value: value2 });
if (mode & 2 && typeof value2 != "string")
for (var key2 in value2)
__webpack_require__.d(ns, key2, (function(key3) {
return value2[key3];
}).bind(null, key2));
return ns;
};
__webpack_require__.n = function(module3) {
var getter = module3 && module3.__esModule ? (
/******/
function getDefault() {
return module3["default"];
}
) : (
/******/
function getModuleExports() {
return module3;
}
);
__webpack_require__.d(getter, "a", getter);
return getter;
};
__webpack_require__.o = function(object, property2) {
return Object.prototype.hasOwnProperty.call(object, property2);
};
__webpack_require__.p = "";
return __webpack_require__(__webpack_require__.s = 2);
}([
/* 0 */
/***/
function(module3, exports3, __webpack_require__) {
"use strict";
var __extends = this && this.__extends || /* @__PURE__ */ function() {
var 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 (b2.hasOwnProperty(p))
d2[p] = b2[p];
};
return extendStatics(d, b);
};
return function(d, b) {
extendStatics(d, b);
function __() {
this.constructor = d;
}
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
}();
Object.defineProperty(exports3, "__esModule", { value: true });
var INVALID_BYTE = 256;
var Coder = (
/** @class */
function() {
function Coder2(_paddingCharacter) {
if (_paddingCharacter === void 0) {
_paddingCharacter = "=";
}
this._paddingCharacter = _paddingCharacter;
}
Coder2.prototype.encodedLength = function(length2) {
if (!this._paddingCharacter) {
return (length2 * 8 + 5) / 6 | 0;
}
return (length2 + 2) / 3 * 4 | 0;
};
Coder2.prototype.encode = function(data2) {
var out = "";
var i = 0;
for (; i < data2.length - 2; i += 3) {
var c = data2[i] << 16 | data2[i + 1] << 8 | data2[i + 2];
out += this._encodeByte(c >>> 3 * 6 & 63);
out += this._encodeByte(c >>> 2 * 6 & 63);
out += this._encodeByte(c >>> 1 * 6 & 63);
out += this._encodeByte(c >>> 0 * 6 & 63);
}
var left = data2.length - i;
if (left > 0) {
var c = data2[i] << 16 | (left === 2 ? data2[i + 1] << 8 : 0);
out += this._encodeByte(c >>> 3 * 6 & 63);
out += this._encodeByte(c >>> 2 * 6 & 63);
if (left === 2) {
out += this._encodeByte(c >>> 1 * 6 & 63);
} else {
out += this._paddingCharacter || "";
}
out += this._paddingCharacter || "";
}
return out;
};
Coder2.prototype.maxDecodedLength = function(length2) {
if (!this._paddingCharacter) {
return (length2 * 6 + 7) / 8 | 0;
}
return length2 / 4 * 3 | 0;
};
Coder2.prototype.decodedLength = function(s) {
return this.maxDecodedLength(s.length - this._getPaddingLength(s));
};
Coder2.prototype.decode = function(s) {
if (s.length === 0) {
return new Uint8Array(0);
}
var paddingLength = this._getPaddingLength(s);
var length2 = s.length - paddingLength;
var out = new Uint8Array(this.maxDecodedLength(length2));
var op = 0;
var i = 0;
var haveBad = 0;
var v0 = 0, v1 = 0, v2 = 0, v3 = 0;
for (; i < length2 - 4; i += 4) {
v0 = this._decodeChar(s.charCodeAt(i + 0));
v1 = this._decodeChar(s.charCodeAt(i + 1));
v2 = this._decodeChar(s.charCodeAt(i + 2));
v3 = this._decodeChar(s.charCodeAt(i + 3));
out[op++] = v0 << 2 | v1 >>> 4;
out[op++] = v1 << 4 | v2 >>> 2;
out[op++] = v2 << 6 | v3;
haveBad |= v0 & INVALID_BYTE;
haveBad |= v1 & INVALID_BYTE;
haveBad |= v2 & INVALID_BYTE;
haveBad |= v3 & INVALID_BYTE;
}
if (i < length2 - 1) {
v0 = this._decodeChar(s.charCodeAt(i));
v1 = this._decodeChar(s.charCodeAt(i + 1));
out[op++] = v0 << 2 | v1 >>> 4;
haveBad |= v0 & INVALID_BYTE;
haveBad |= v1 & INVALID_BYTE;
}
if (i < length2 - 2) {
v2 = this._decodeChar(s.charCodeAt(i + 2));
out[op++] = v1 << 4 | v2 >>> 2;
haveBad |= v2 & INVALID_BYTE;
}
if (i < length2 - 3) {
v3 = this._decodeChar(s.charCodeAt(i + 3));
out[op++] = v2 << 6 | v3;
haveBad |= v3 & INVALID_BYTE;
}
if (haveBad !== 0) {
throw new Error("Base64Coder: incorrect characters for decoding");
}
return out;
};
Coder2.prototype._encodeByte = function(b) {
var result = b;
result += 65;
result += 25 - b >>> 8 & 0 - 65 - 26 + 97;
result += 51 - b >>> 8 & 26 - 97 - 52 + 48;
result += 61 - b >>> 8 & 52 - 48 - 62 + 43;
result += 62 - b >>> 8 & 62 - 43 - 63 + 47;
return String.fromCharCode(result);
};
Coder2.prototype._decodeChar = function(c) {
var result = INVALID_BYTE;
result += (42 - c & c - 44) >>> 8 & -INVALID_BYTE + c - 43 + 62;
result += (46 - c & c - 48) >>> 8 & -INVALID_BYTE + c - 47 + 63;
result += (47 - c & c - 58) >>> 8 & -INVALID_BYTE + c - 48 + 52;
result += (64 - c & c - 91) >>> 8 & -INVALID_BYTE + c - 65 + 0;
result += (96 - c & c - 123) >>> 8 & -INVALID_BYTE + c - 97 + 26;
return result;
};
Coder2.prototype._getPaddingLength = function(s) {
var paddingLength = 0;
if (this._paddingCharacter) {
for (var i = s.length - 1; i >= 0; i--) {
if (s[i] !== this._paddingCharacter) {
break;
}
paddingLength++;
}
if (s.length < 4 || paddingLength > 2) {
throw new Error("Base64Coder: incorrect padding");
}
}
return paddingLength;
};
return Coder2;
}()
);
exports3.Coder = Coder;
var stdCoder = new Coder();
function encode(data2) {
return stdCoder.encode(data2);
}
exports3.encode = encode;
function decode2(s) {
return stdCoder.decode(s);
}
exports3.decode = decode2;
var URLSafeCoder = (
/** @class */
function(_super) {
__extends(URLSafeCoder2, _super);
function URLSafeCoder2() {
return _super !== null && _super.apply(this, arguments) || this;
}
URLSafeCoder2.prototype._encodeByte = function(b) {
var result = b;
result += 65;
result += 25 - b >>> 8 & 0 - 65 - 26 + 97;
result += 51 - b >>> 8 & 26 - 97 - 52 + 48;
result += 61 - b >>> 8 & 52 - 48 - 62 + 45;
result += 62 - b >>> 8 & 62 - 45 - 63 + 95;
return String.fromCharCode(result);
};
URLSafeCoder2.prototype._decodeChar = function(c) {
var result = INVALID_BYTE;
result += (44 - c & c - 46) >>> 8 & -INVALID_BYTE + c - 45 + 62;
result += (94 - c & c - 96) >>> 8 & -INVALID_BYTE + c - 95 + 63;
result += (47 - c & c - 58) >>> 8 & -INVALID_BYTE + c - 48 + 52;
result += (64 - c & c - 91) >>> 8 & -INVALID_BYTE + c - 65 + 0;
result += (96 - c & c - 123) >>> 8 & -INVALID_BYTE + c - 97 + 26;
return result;
};
return URLSafeCoder2;
}(Coder)
);
exports3.URLSafeCoder = URLSafeCoder;
var urlSafeCoder = new URLSafeCoder();
function encodeURLSafe(data2) {
return urlSafeCoder.encode(data2);
}
exports3.encodeURLSafe = encodeURLSafe;
function decodeURLSafe(s) {
return urlSafeCoder.decode(s);
}
exports3.decodeURLSafe = decodeURLSafe;
exports3.encodedLength = function(length2) {
return stdCoder.encodedLength(length2);
};
exports3.maxDecodedLength = function(length2) {
return stdCoder.maxDecodedLength(length2);
};
exports3.decodedLength = function(s) {
return stdCoder.decodedLength(s);
};
},
/* 1 */
/***/
function(module3, exports3, __webpack_require__) {
"use strict";
Object.defineProperty(exports3, "__esModule", { value: true });
var INVALID_UTF16 = "utf8: invalid string";
var INVALID_UTF8 = "utf8: invalid source encoding";
function encode(s) {
var arr = new Uint8Array(encodedLength(s));
var pos = 0;
for (var i = 0; i < s.length; i++) {
var c = s.charCodeAt(i);
if (c < 128) {
arr[pos++] = c;
} else if (c < 2048) {
arr[pos++] = 192 | c >> 6;
arr[pos++] = 128 | c & 63;
} else if (c < 55296) {
arr[pos++] = 224 | c >> 12;
arr[pos++] = 128 | c >> 6 & 63;
arr[pos++] = 128 | c & 63;
} else {
i++;
c = (c & 1023) << 10;
c |= s.charCodeAt(i) & 1023;
c += 65536;
arr[pos++] = 240 | c >> 18;
arr[pos++] = 128 | c >> 12 & 63;
arr[pos++] = 128 | c >> 6 & 63;
arr[pos++] = 128 | c & 63;
}
}
return arr;
}
exports3.encode = encode;
function encodedLength(s) {
var result = 0;
for (var i = 0; i < s.length; i++) {
var c = s.charCodeAt(i);
if (c < 128) {
result += 1;
} else if (c < 2048) {
result += 2;
} else if (c < 55296) {
result += 3;
} else if (c <= 57343) {
if (i >= s.length - 1) {
throw new Error(INVALID_UTF16);
}
i++;
result += 4;
} else {
throw new Error(INVALID_UTF16);
}
}
return result;
}
exports3.encodedLength = encodedLength;
function decode2(arr) {
var chars = [];
for (var i = 0; i < arr.length; i++) {
var b = arr[i];
if (b & 128) {
var min = void 0;
if (b < 224) {
if (i >= arr.length) {
throw new Error(INVALID_UTF8);
}
var n1 = arr[++i];
if ((n1 & 192) !== 128) {
throw new Error(INVALID_UTF8);
}
b = (b & 31) << 6 | n1 & 63;
min = 128;
} else if (b < 240) {
if (i >= arr.length - 1) {
throw new Error(INVALID_UTF8);
}
var n1 = arr[++i];
var n2 = arr[++i];
if ((n1 & 192) !== 128 || (n2 & 192) !== 128) {
throw new Error(INVALID_UTF8);
}
b = (b & 15) << 12 | (n1 & 63) << 6 | n2 & 63;
min = 2048;
} else if (b < 248) {
if (i >= arr.length - 2) {
throw new Error(INVALID_UTF8);
}
var n1 = arr[++i];
var n2 = arr[++i];
var n3 = arr[++i];
if ((n1 & 192) !== 128 || (n2 & 192) !== 128 || (n3 & 192) !== 128) {
throw new Error(INVALID_UTF8);
}
b = (b & 15) << 18 | (n1 & 63) << 12 | (n2 & 63) << 6 | n3 & 63;
min = 65536;
} else {
throw new Error(INVALID_UTF8);
}
if (b < min || b >= 55296 && b <= 57343) {
throw new Error(INVALID_UTF8);
}
if (b >= 65536) {
if (b > 1114111) {
throw new Error(INVALID_UTF8);
}
b -= 65536;
chars.push(String.fromCharCode(55296 | b >> 10));
b = 56320 | b & 1023;
}
}
chars.push(String.fromCharCode(b));
}
return chars.join("");
}
exports3.decode = decode2;
},
/* 2 */
/***/
function(module3, exports3, __webpack_require__) {
module3.exports = __webpack_require__(3).default;
},
/* 3 */
/***/
function(module3, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
class ScriptReceiverFactory {
constructor(prefix2, name2) {
this.lastId = 0;
this.prefix = prefix2;
this.name = name2;
}
create(callback) {
this.lastId++;
var number = this.lastId;
var id = this.prefix + number;
var name2 = this.name + "[" + number + "]";
var called = false;
var callbackWrapper = function() {
if (!called) {
callback.apply(null, arguments);
called = true;
}
};
this[number] = callbackWrapper;
return { number, id, name: name2, callback: callbackWrapper };
}
remove(receiver) {
delete this[receiver.number];
}
}
var ScriptReceivers = new ScriptReceiverFactory("_pusher_script_", "Pusher.ScriptReceivers");
var Defaults = {
VERSION: "8.4.0",
PROTOCOL: 7,
wsPort: 80,
wssPort: 443,
wsPath: "",
httpHost: "sockjs.pusher.com",
httpPort: 80,
httpsPort: 443,
httpPath: "/pusher",
stats_host: "stats.pusher.com",
authEndpoint: "/pusher/auth",
authTransport: "ajax",
activityTimeout: 12e4,
pongTimeout: 3e4,
unavailableTimeout: 1e4,
userAuthentication: {
endpoint: "/pusher/user-auth",
transport: "ajax"
},
channelAuthorization: {
endpoint: "/pusher/auth",
transport: "ajax"
},
cdn_http: "http://js.pusher.com",
cdn_https: "https://js.pusher.com",
dependency_suffix: ""
};
var defaults = Defaults;
class dependency_loader_DependencyLoader {
constructor(options) {
this.options = options;
this.receivers = options.receivers || ScriptReceivers;
this.loading = {};
}
load(name2, options, callback) {
var self2 = this;
if (self2.loading[name2] && self2.loading[name2].length > 0) {
self2.loading[name2].push(callback);
} else {
self2.loading[name2] = [callback];
var request = runtime.createScriptRequest(self2.getPath(name2, options));
var receiver = self2.receivers.create(function(error) {
self2.receivers.remove(receiver);
if (self2.loading[name2]) {
var callbacks = self2.loading[name2];
delete self2.loading[name2];
var successCallback = function(wasSuccessful) {
if (!wasSuccessful) {
request.cleanup();
}
};
for (var i = 0; i < callbacks.length; i++) {
callbacks[i](error, successCallback);
}
}
});
request.send(receiver);
}
}
getRoot(options) {
var cdn;
var protocol = runtime.getDocument().location.protocol;
if (options && options.useTLS || protocol === "https:") {
cdn = this.options.cdn_https;
} else {
cdn = this.options.cdn_http;
}
return cdn.replace(/\/*$/, "") + "/" + this.options.version;
}
getPath(name2, options) {
return this.getRoot(options) + "/" + name2 + this.options.suffix + ".js";
}
}
var DependenciesReceivers = new ScriptReceiverFactory("_pusher_dependencies", "Pusher.DependenciesReceivers");
var Dependencies = new dependency_loader_DependencyLoader({
cdn_http: defaults.cdn_http,
cdn_https: defaults.cdn_https,
version: defaults.VERSION,
suffix: defaults.dependency_suffix,
receivers: DependenciesReceivers
});
const urlStore = {
baseUrl: "https://pusher.com",
urls: {
authenticationEndpoint: {
path: "/docs/channels/server_api/authenticating_users"
},
authorizationEndpoint: {
path: "/docs/channels/server_api/authorizing-users/"
},
javascriptQuickStart: {
path: "/docs/javascript_quick_start"
},
triggeringClientEvents: {
path: "/docs/client_api_guide/client_events#trigger-events"
},
encryptedChannelSupport: {
fullUrl: "https://github.com/pusher/pusher-js/tree/cc491015371a4bde5743d1c87a0fbac0feb53195#encrypted-channel-support"
}
}
};
const buildLogSuffix = function(key2) {
const urlPrefix = "See:";
const urlObj = urlStore.urls[key2];
if (!urlObj)
return "";
let url;
if (urlObj.fullUrl) {
url = urlObj.fullUrl;
} else if (urlObj.path) {
url = urlStore.baseUrl + urlObj.path;
}
if (!url)
return "";
return `${urlPrefix} ${url}`;
};
var url_store = { buildLogSuffix };
var AuthRequestType;
(function(AuthRequestType2) {
AuthRequestType2["UserAuthentication"] = "user-authentication";
AuthRequestType2["ChannelAuthorization"] = "channel-authorization";
})(AuthRequestType || (AuthRequestType = {}));
class BadEventName extends Error {
constructor(msg) {
super(msg);
Object.setPrototypeOf(this, new.target.prototype);
}
}
class BadChannelName extends Error {
constructor(msg) {
super(msg);
Object.setPrototypeOf(this, new.target.prototype);
}
}
class RequestTimedOut extends Error {
constructor(msg) {
super(msg);
Object.setPrototypeOf(this, new.target.prototype);
}
}
class TransportPriorityTooLow extends Error {
constructor(msg) {
super(msg);
Object.setPrototypeOf(this, new.target.prototype);
}
}
class TransportClosed extends Error {
constructor(msg) {
super(msg);
Object.setPrototypeOf(this, new.target.prototype);
}
}
class UnsupportedFeature extends Error {
constructor(msg) {
super(msg);
Object.setPrototypeOf(this, new.target.prototype);
}
}
class UnsupportedTransport extends Error {
constructor(msg) {
super(msg);
Object.setPrototypeOf(this, new.target.prototype);
}
}
class UnsupportedStrategy extends Error {
constructor(msg) {
super(msg);
Object.setPrototypeOf(this, new.target.prototype);
}
}
class HTTPAuthError extends Error {
constructor(status, msg) {
super(msg);
this.status = status;
Object.setPrototypeOf(this, new.target.prototype);
}
}
const ajax = function(context2, query, authOptions, authRequestType, callback) {
const xhr = runtime.createXHR();
xhr.open("POST", authOptions.endpoint, true);
xhr.setRequestHeader("Content-Type", "application/x-www-form-urlencoded");
for (var headerName in authOptions.headers) {
xhr.setRequestHeader(headerName, authOptions.headers[headerName]);
}
if (authOptions.headersProvider != null) {
let dynamicHeaders = authOptions.headersProvider();
for (var headerName in dynamicHeaders) {
xhr.setRequestHeader(headerName, dynamicHeaders[headerName]);
}
}
xhr.onreadystatechange = function() {
if (xhr.readyState === 4) {
if (xhr.status === 200) {
let data2;
let parsed = false;
try {
data2 = JSON.parse(xhr.responseText);
parsed = true;
} catch (e) {
callback(new HTTPAuthError(200, `JSON returned from ${authRequestType.toString()} endpoint was invalid, yet status code was 200. Data was: ${xhr.responseText}`), null);
}
if (parsed) {
callback(null, data2);
}
} else {
let suffix = "";
switch (authRequestType) {
case AuthRequestType.UserAuthentication:
suffix = url_store.buildLogSuffix("authenticationEndpoint");
break;
case AuthRequestType.ChannelAuthorization:
suffix = `Clients must be authorized to join private or presence channels. ${url_store.buildLogSuffix("authorizationEndpoint")}`;
break;
}
callback(new HTTPAuthError(xhr.status, `Unable to retrieve auth string from ${authRequestType.toString()} endpoint - received status: ${xhr.status} from ${authOptions.endpoint}. ${suffix}`), null);
}
}
};
xhr.send(query);
return xhr;
};
var xhr_auth = ajax;
function encode(s) {
return btoa(utob(s));
}
var fromCharCode = String.fromCharCode;
var b64chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
var b64tab = {};
for (var base64_i = 0, l = b64chars.length; base64_i < l; base64_i++) {
b64tab[b64chars.charAt(base64_i)] = base64_i;
}
var cb_utob = function(c) {
var cc = c.charCodeAt(0);
return cc < 128 ? c : cc < 2048 ? fromCharCode(192 | cc >>> 6) + fromCharCode(128 | cc & 63) : fromCharCode(224 | cc >>> 12 & 15) + fromCharCode(128 | cc >>> 6 & 63) + fromCharCode(128 | cc & 63);
};
var utob = function(u2) {
return u2.replace(/[^\x00-\x7F]/g, cb_utob);
};
var cb_encode = function(ccc) {
var padlen = [0, 2, 1][ccc.length % 3];
var ord = ccc.charCodeAt(0) << 16 | (ccc.length > 1 ? ccc.charCodeAt(1) : 0) << 8 | (ccc.length > 2 ? ccc.charCodeAt(2) : 0);
var chars = [
b64chars.charAt(ord >>> 18),
b64chars.charAt(ord >>> 12 & 63),
padlen >= 2 ? "=" : b64chars.charAt(ord >>> 6 & 63),
padlen >= 1 ? "=" : b64chars.charAt(ord & 63)
];
return chars.join("");
};
var btoa = window.btoa || function(b) {
return b.replace(/[\s\S]{1,3}/g, cb_encode);
};
class Timer {
constructor(set, clear, delay, callback) {
this.clear = clear;
this.timer = set(() => {
if (this.timer) {
this.timer = callback(this.timer);
}
}, delay);
}
isRunning() {
return this.timer !== null;
}
ensureAborted() {
if (this.timer) {
this.clear(this.timer);
this.timer = null;
}
}
}
var abstract_timer = Timer;
function timers_clearTimeout(timer2) {
window.clearTimeout(timer2);
}
function timers_clearInterval(timer2) {
window.clearInterval(timer2);
}
class timers_OneOffTimer extends abstract_timer {
constructor(delay, callback) {
super(setTimeout, timers_clearTimeout, delay, function(timer2) {
callback();
return null;
});
}
}
class timers_PeriodicTimer extends abstract_timer {
constructor(delay, callback) {
super(setInterval, timers_clearInterval, delay, function(timer2) {
callback();
return timer2;
});
}
}
var Util = {
now() {
if (Date.now) {
return Date.now();
} else {
return (/* @__PURE__ */ new Date()).valueOf();
}
},
defer(callback) {
return new timers_OneOffTimer(0, callback);
},
method(name2, ...args) {
var boundArguments = Array.prototype.slice.call(arguments, 1);
return function(object) {
return object[name2].apply(object, boundArguments.concat(arguments));
};
}
};
var util2 = Util;
function extend(target, ...sources) {
for (var i = 0; i < sources.length; i++) {
var extensions = sources[i];
for (var property2 in extensions) {
if (extensions[property2] && extensions[property2].constructor && extensions[property2].constructor === Object) {
target[property2] = extend(target[property2] || {}, extensions[property2]);
} else {
target[property2] = extensions[property2];
}
}
}
return target;
}
function stringify3() {
var m = ["Pusher"];
for (var i = 0; i < arguments.length; i++) {
if (typeof arguments[i] === "string") {
m.push(arguments[i]);
} else {
m.push(safeJSONStringify(arguments[i]));
}
}
return m.join(" : ");
}
function arrayIndexOf(array, item) {
var nativeIndexOf = Array.prototype.indexOf;
if (array === null) {
return -1;
}
if (nativeIndexOf && array.indexOf === nativeIndexOf) {
return array.indexOf(item);
}
for (var i = 0, l2 = array.length; i < l2; i++) {
if (array[i] === item) {
return i;
}
}
return -1;
}
function objectApply(object, f) {
for (var key2 in object) {
if (Object.prototype.hasOwnProperty.call(object, key2)) {
f(object[key2], key2, object);
}
}
}
function keys(object) {
var keys2 = [];
objectApply(object, function(_, key2) {
keys2.push(key2);
});
return keys2;
}
function values(object) {
var values2 = [];
objectApply(object, function(value2) {
values2.push(value2);
});
return values2;
}
function apply(array, f, context2) {
for (var i = 0; i < array.length; i++) {
f.call(context2 || window, array[i], i, array);
}
}
function map2(array, f) {
var result = [];
for (var i = 0; i < array.length; i++) {
result.push(f(array[i], i, array, result));
}
return result;
}
function mapObject(object, f) {
var result = {};
objectApply(object, function(value2, key2) {
result[key2] = f(value2);
});
return result;
}
function filter2(array, test) {
test = test || function(value2) {
return !!value2;
};
var result = [];
for (var i = 0; i < array.length; i++) {
if (test(array[i], i, array, result)) {
result.push(array[i]);
}
}
return result;
}
function filterObject(object, test) {
var result = {};
objectApply(object, function(value2, key2) {
if (test && test(value2, key2, object, result) || Boolean(value2)) {
result[key2] = value2;
}
});
return result;
}
function flatten2(object) {
var result = [];
objectApply(object, function(value2, key2) {
result.push([key2, value2]);
});
return result;
}
function any(array, test) {
for (var i = 0; i < array.length; i++) {
if (test(array[i], i, array)) {
return true;
}
}
return false;
}
function collections_all(array, test) {
for (var i = 0; i < array.length; i++) {
if (!test(array[i], i, array)) {
return false;
}
}
return true;
}
function encodeParamsObject(data2) {
return mapObject(data2, function(value2) {
if (typeof value2 === "object") {
value2 = safeJSONStringify(value2);
}
return encodeURIComponent(encode(value2.toString()));
});
}
function buildQueryString(data2) {
var params = filterObject(data2, function(value2) {
return value2 !== void 0;
});
var query = map2(flatten2(encodeParamsObject(params)), util2.method("join", "=")).join("&");
return query;
}
function decycleObject(object) {
var objects = [], paths = [];
return function derez(value2, path) {
var i, name2, nu;
switch (typeof value2) {
case "object":
if (!value2) {
return null;
}
for (i = 0; i < objects.length; i += 1) {
if (objects[i] === value2) {
return { $ref: paths[i] };
}
}
objects.push(value2);
paths.push(path);
if (Object.prototype.toString.apply(value2) === "[object Array]") {
nu = [];
for (i = 0; i < value2.length; i += 1) {
nu[i] = derez(value2[i], path + "[" + i + "]");
}
} else {
nu = {};
for (name2 in value2) {
if (Object.prototype.hasOwnProperty.call(value2, name2)) {
nu[name2] = derez(value2[name2], path + "[" + JSON.stringify(name2) + "]");
}
}
}
return nu;
case "number":
case "string":
case "boolean":
return value2;
}
}(object, "$");
}
function safeJSONStringify(source) {
try {
return JSON.stringify(source);
} catch (e) {
return JSON.stringify(decycleObject(source));
}
}
class logger_Logger {
constructor() {
this.globalLog = (message) => {
if (window.console && window.console.log) {
window.console.log(message);
}
};
}
debug(...args) {
this.log(this.globalLog, args);
}
warn(...args) {
this.log(this.globalLogWarn, args);
}
error(...args) {
this.log(this.globalLogError, args);
}
globalLogWarn(message) {
if (window.console && window.console.warn) {
window.console.warn(message);
} else {
this.globalLog(message);
}
}
globalLogError(message) {
if (window.console && window.console.error) {
window.console.error(message);
} else {
this.globalLogWarn(message);
}
}
log(defaultLoggingFunction, ...args) {
var message = stringify3.apply(this, arguments);
if (core_pusher.log) {
core_pusher.log(message);
} else if (core_pusher.logToConsole) {
const log = defaultLoggingFunction.bind(this);
log(message);
}
}
}
var logger = new logger_Logger();
var jsonp = function(context2, query, authOptions, authRequestType, callback) {
if (authOptions.headers !== void 0 || authOptions.headersProvider != null) {
logger.warn(`To send headers with the ${authRequestType.toString()} request, you must use AJAX, rather than JSONP.`);
}
var callbackName = context2.nextAuthCallbackID.toString();
context2.nextAuthCallbackID++;
var document2 = context2.getDocument();
var script = document2.createElement("script");
context2.auth_callbacks[callbackName] = function(data2) {
callback(null, data2);
};
var callback_name = "Pusher.auth_callbacks['" + callbackName + "']";
script.src = authOptions.endpoint + "?callback=" + encodeURIComponent(callback_name) + "&" + query;
var head = document2.getElementsByTagName("head")[0] || document2.documentElement;
head.insertBefore(script, head.firstChild);
};
var jsonp_auth = jsonp;
class ScriptRequest {
constructor(src) {
this.src = src;
}
send(receiver) {
var self2 = this;
var errorString = "Error loading " + self2.src;
self2.script = document.createElement("script");
self2.script.id = receiver.id;
self2.script.src = self2.src;
self2.script.type = "text/javascript";
self2.script.charset = "UTF-8";
if (self2.script.addEventListener) {
self2.script.onerror = function() {
receiver.callback(errorString);
};
self2.script.onload = function() {
receiver.callback(null);
};
} else {
self2.script.onreadystatechange = function() {
if (self2.script.readyState === "loaded" || self2.script.readyState === "complete") {
receiver.callback(null);
}
};
}
if (self2.script.async === void 0 && document.attachEvent && /opera/i.test(navigator.userAgent)) {
self2.errorScript = document.createElement("script");
self2.errorScript.id = receiver.id + "_error";
self2.errorScript.text = receiver.name + "('" + errorString + "');";
self2.script.async = self2.errorScript.async = false;
} else {
self2.script.async = true;
}
var head = document.getElementsByTagName("head")[0];
head.insertBefore(self2.script, head.firstChild);
if (self2.errorScript) {
head.insertBefore(self2.errorScript, self2.script.nextSibling);
}
}
cleanup() {
if (this.script) {
this.script.onload = this.script.onerror = null;
this.script.onreadystatechange = null;
}
if (this.script && this.script.parentNode) {
this.script.parentNode.removeChild(this.script);
}
if (this.errorScript && this.errorScript.parentNode) {
this.errorScript.parentNode.removeChild(this.errorScript);
}
this.script = null;
this.errorScript = null;
}
}
class jsonp_request_JSONPRequest {
constructor(url, data2) {
this.url = url;
this.data = data2;
}
send(receiver) {
if (this.request) {
return;
}
var query = buildQueryString(this.data);
var url = this.url + "/" + receiver.number + "?" + query;
this.request = runtime.createScriptRequest(url);
this.request.send(receiver);
}
cleanup() {
if (this.request) {
this.request.cleanup();
}
}
}
var getAgent = function(sender, useTLS) {
return function(data2, callback) {
var scheme = "http" + (useTLS ? "s" : "") + "://";
var url = scheme + (sender.host || sender.options.host) + sender.options.path;
var request = runtime.createJSONPRequest(url, data2);
var receiver = runtime.ScriptReceivers.create(function(error, result) {
ScriptReceivers.remove(receiver);
request.cleanup();
if (result && result.host) {
sender.host = result.host;
}
if (callback) {
callback(error, result);
}
});
request.send(receiver);
};
};
var jsonp_timeline_jsonp = {
name: "jsonp",
getAgent
};
var jsonp_timeline = jsonp_timeline_jsonp;
function getGenericURL(baseScheme, params, path) {
var scheme = baseScheme + (params.useTLS ? "s" : "");
var host = params.useTLS ? params.hostTLS : params.hostNonTLS;
return scheme + "://" + host + path;
}
function getGenericPath(key2, queryString2) {
var path = "/app/" + key2;
var query = "?protocol=" + defaults.PROTOCOL + "&client=js&version=" + defaults.VERSION + (queryString2 ? "&" + queryString2 : "");
return path + query;
}
var ws = {
getInitial: function(key2, params) {
var path = (params.httpPath || "") + getGenericPath(key2, "flash=false");
return getGenericURL("ws", params, path);
}
};
var http = {
getInitial: function(key2, params) {
var path = (params.httpPath || "/pusher") + getGenericPath(key2);
return getGenericURL("http", params, path);
}
};
var sockjs = {
getInitial: function(key2, params) {
return getGenericURL("http", params, params.httpPath || "/pusher");
},
getPath: function(key2, params) {
return getGenericPath(key2);
}
};
class callback_registry_CallbackRegistry {
constructor() {
this._callbacks = {};
}
get(name2) {
return this._callbacks[prefix(name2)];
}
add(name2, callback, context2) {
var prefixedEventName = prefix(name2);
this._callbacks[prefixedEventName] = this._callbacks[prefixedEventName] || [];
this._callbacks[prefixedEventName].push({
fn: callback,
context: context2
});
}
remove(name2, callback, context2) {
if (!name2 && !callback && !context2) {
this._callbacks = {};
return;
}
var names = name2 ? [prefix(name2)] : keys(this._callbacks);
if (callback || context2) {
this.removeCallback(names, callback, context2);
} else {
this.removeAllCallbacks(names);
}
}
removeCallback(names, callback, context2) {
apply(names, function(name2) {
this._callbacks[name2] = filter2(this._callbacks[name2] || [], function(binding) {
return callback && callback !== binding.fn || context2 && context2 !== binding.context;
});
if (this._callbacks[name2].length === 0) {
delete this._callbacks[name2];
}
}, this);
}
removeAllCallbacks(names) {
apply(names, function(name2) {
delete this._callbacks[name2];
}, this);
}
}
function prefix(name2) {
return "_" + name2;
}
class dispatcher_Dispatcher {
constructor(failThrough) {
this.callbacks = new callback_registry_CallbackRegistry();
this.global_callbacks = [];
this.failThrough = failThrough;
}
bind(eventName, callback, context2) {
this.callbacks.add(eventName, callback, context2);
return this;
}
bind_global(callback) {
this.global_callbacks.push(callback);
return this;
}
unbind(eventName, callback, context2) {
this.callbacks.remove(eventName, callback, context2);
return this;
}
unbind_global(callback) {
if (!callback) {
this.global_callbacks = [];
return this;
}
this.global_callbacks = filter2(this.global_callbacks || [], (c) => c !== callback);
return this;
}
unbind_all() {
this.unbind();
this.unbind_global();
return this;
}
emit(eventName, data2, metadata) {
for (var i = 0; i < this.global_callbacks.length; i++) {
this.global_callbacks[i](eventName, data2);
}
var callbacks = this.callbacks.get(eventName);
var args = [];
if (metadata) {
args.push(data2, metadata);
} else if (data2) {
args.push(data2);
}
if (callbacks && callbacks.length > 0) {
for (var i = 0; i < callbacks.length; i++) {
callbacks[i].fn.apply(callbacks[i].context || window, args);
}
} else if (this.failThrough) {
this.failThrough(eventName, data2);
}
return this;
}
}
class transport_connection_TransportConnection extends dispatcher_Dispatcher {
constructor(hooks, name2, priority, key2, options) {
super();
this.initialize = runtime.transportConnectionInitializer;
this.hooks = hooks;
this.name = name2;
this.priority = priority;
this.key = key2;
this.options = options;
this.state = "new";
this.timeline = options.timeline;
this.activityTimeout = options.activityTimeout;
this.id = this.timeline.generateUniqueID();
}
handlesActivityChecks() {
return Boolean(this.hooks.handlesActivityChecks);
}
supportsPing() {
return Boolean(this.hooks.supportsPing);
}
connect() {
if (this.socket || this.state !== "initialized") {
return false;
}
var url = this.hooks.urls.getInitial(this.key, this.options);
try {
this.socket = this.hooks.getSocket(url, this.options);
} catch (e) {
util2.defer(() => {
this.onError(e);
this.changeState("closed");
});
return false;
}
this.bindListeners();
logger.debug("Connecting", { transport: this.name, url });
this.changeState("connecting");
return true;
}
close() {
if (this.socket) {
this.socket.close();
return true;
} else {
return false;
}
}
send(data2) {
if (this.state === "open") {
util2.defer(() => {
if (this.socket) {
this.socket.send(data2);
}
});
return true;
} else {
return false;
}
}
ping() {
if (this.state === "open" && this.supportsPing()) {
this.socket.ping();
}
}
onOpen() {
if (this.hooks.beforeOpen) {
this.hooks.beforeOpen(this.socket, this.hooks.urls.getPath(this.key, this.options));
}
this.changeState("open");
this.socket.onopen = void 0;
}
onError(error) {
this.emit("error", { type: "WebSocketError", error });
this.timeline.error(this.buildTimelineMessage({ error: error.toString() }));
}
onClose(closeEvent) {
if (closeEvent) {
this.changeState("closed", {
code: closeEvent.code,
reason: closeEvent.reason,
wasClean: closeEvent.wasClean
});
} else {
this.changeState("closed");
}
this.unbindListeners();
this.socket = void 0;
}
onMessage(message) {
this.emit("message", message);
}
onActivity() {
this.emit("activity");
}
bindListeners() {
this.socket.onopen = () => {
this.onOpen();
};
this.socket.onerror = (error) => {
this.onError(error);
};
this.socket.onclose = (closeEvent) => {
this.onClose(closeEvent);
};
this.socket.onmessage = (message) => {
this.onMessage(message);
};
if (this.supportsPing()) {
this.socket.onactivity = () => {
this.onActivity();
};
}
}
unbindListeners() {
if (this.socket) {
this.socket.onopen = void 0;
this.socket.onerror = void 0;
this.socket.onclose = void 0;
this.socket.onmessage = void 0;
if (this.supportsPing()) {
this.socket.onactivity = void 0;
}
}
}
changeState(state2, params) {
this.state = state2;
this.timeline.info(this.buildTimelineMessage({
state: state2,
params
}));
this.emit(state2, params);
}
buildTimelineMessage(message) {
return extend({ cid: this.id }, message);
}
}
class transport_Transport {
constructor(hooks) {
this.hooks = hooks;
}
isSupported(environment2) {
return this.hooks.isSupported(environment2);
}
createConnection(name2, priority, key2, options) {
return new transport_connection_TransportConnection(this.hooks, name2, priority, key2, options);
}
}
var WSTransport = new transport_Transport({
urls: ws,
handlesActivityChecks: false,
supportsPing: false,
isInitialized: function() {
return Boolean(runtime.getWebSocketAPI());
},
isSupported: function() {
return Boolean(runtime.getWebSocketAPI());
},
getSocket: function(url) {
return runtime.createWebSocket(url);
}
});
var httpConfiguration = {
urls: http,
handlesActivityChecks: false,
supportsPing: true,
isInitialized: function() {
return true;
}
};
var streamingConfiguration = extend({
getSocket: function(url) {
return runtime.HTTPFactory.createStreamingSocket(url);
}
}, httpConfiguration);
var pollingConfiguration = extend({
getSocket: function(url) {
return runtime.HTTPFactory.createPollingSocket(url);
}
}, httpConfiguration);
var xhrConfiguration = {
isSupported: function() {
return runtime.isXHRSupported();
}
};
var XHRStreamingTransport = new transport_Transport(extend({}, streamingConfiguration, xhrConfiguration));
var XHRPollingTransport = new transport_Transport(extend({}, pollingConfiguration, xhrConfiguration));
var Transports = {
ws: WSTransport,
xhr_streaming: XHRStreamingTransport,
xhr_polling: XHRPollingTransport
};
var transports = Transports;
var SockJSTransport = new transport_Transport({
file: "sockjs",
urls: sockjs,
handlesActivityChecks: true,
supportsPing: false,
isSupported: function() {
return true;
},
isInitialized: function() {
return window.SockJS !== void 0;
},
getSocket: function(url, options) {
return new window.SockJS(url, null, {
js_path: Dependencies.getPath("sockjs", {
useTLS: options.useTLS
}),
ignore_null_origin: options.ignoreNullOrigin
});
},
beforeOpen: function(socket, path) {
socket.send(JSON.stringify({
path
}));
}
});
var xdrConfiguration = {
isSupported: function(environment2) {
var yes = runtime.isXDRSupported(environment2.useTLS);
return yes;
}
};
var XDRStreamingTransport = new transport_Transport(extend({}, streamingConfiguration, xdrConfiguration));
var XDRPollingTransport = new transport_Transport(extend({}, pollingConfiguration, xdrConfiguration));
transports.xdr_streaming = XDRStreamingTransport;
transports.xdr_polling = XDRPollingTransport;
transports.sockjs = SockJSTransport;
var transports_transports = transports;
class net_info_NetInfo extends dispatcher_Dispatcher {
constructor() {
super();
var self2 = this;
if (window.addEventListener !== void 0) {
window.addEventListener("online", function() {
self2.emit("online");
}, false);
window.addEventListener("offline", function() {
self2.emit("offline");
}, false);
}
}
isOnline() {
if (window.navigator.onLine === void 0) {
return true;
} else {
return window.navigator.onLine;
}
}
}
var net_info_Network = new net_info_NetInfo();
class assistant_to_the_transport_manager_AssistantToTheTransportManager {
constructor(manager, transport, options) {
this.manager = manager;
this.transport = transport;
this.minPingDelay = options.minPingDelay;
this.maxPingDelay = options.maxPingDelay;
this.pingDelay = void 0;
}
createConnection(name2, priority, key2, options) {
options = extend({}, options, {
activityTimeout: this.pingDelay
});
var connection = this.transport.createConnection(name2, priority, key2, options);
var openTimestamp = null;
var onOpen = function() {
connection.unbind("open", onOpen);
connection.bind("closed", onClosed);
openTimestamp = util2.now();
};
var onClosed = (closeEvent) => {
connection.unbind("closed", onClosed);
if (closeEvent.code === 1002 || closeEvent.code === 1003) {
this.manager.reportDeath();
} else if (!closeEvent.wasClean && openTimestamp) {
var lifespan = util2.now() - openTimestamp;
if (lifespan < 2 * this.maxPingDelay) {
this.manager.reportDeath();
this.pingDelay = Math.max(lifespan / 2, this.minPingDelay);
}
}
};
connection.bind("open", onOpen);
return connection;
}
isSupported(environment2) {
return this.manager.isAlive() && this.transport.isSupported(environment2);
}
}
const Protocol = {
decodeMessage: function(messageEvent) {
try {
var messageData = JSON.parse(messageEvent.data);
var pusherEventData = messageData.data;
if (typeof pusherEventData === "string") {
try {
pusherEventData = JSON.parse(messageData.data);
} catch (e) {
}
}
var pusherEvent = {
event: messageData.event,
channel: messageData.channel,
data: pusherEventData
};
if (messageData.user_id) {
pusherEvent.user_id = messageData.user_id;
}
return pusherEvent;
} catch (e) {
throw { type: "MessageParseError", error: e, data: messageEvent.data };
}
},
encodeMessage: function(event) {
return JSON.stringify(event);
},
processHandshake: function(messageEvent) {
var message = Protocol.decodeMessage(messageEvent);
if (message.event === "pusher:connection_established") {
if (!message.data.activity_timeout) {
throw "No activity timeout specified in handshake";
}
return {
action: "connected",
id: message.data.socket_id,
activityTimeout: message.data.activity_timeout * 1e3
};
} else if (message.event === "pusher:error") {
return {
action: this.getCloseAction(message.data),
error: this.getCloseError(message.data)
};
} else {
throw "Invalid handshake";
}
},
getCloseAction: function(closeEvent) {
if (closeEvent.code < 4e3) {
if (closeEvent.code >= 1002 && closeEvent.code <= 1004) {
return "backoff";
} else {
return null;
}
} else if (closeEvent.code === 4e3) {
return "tls_only";
} else if (closeEvent.code < 4100) {
return "refused";
} else if (closeEvent.code < 4200) {
return "backoff";
} else if (closeEvent.code < 4300) {
return "retry";
} else {
return "refused";
}
},
getCloseError: function(closeEvent) {
if (closeEvent.code !== 1e3 && closeEvent.code !== 1001) {
return {
type: "PusherError",
data: {
code: closeEvent.code,
message: closeEvent.reason || closeEvent.message
}
};
} else {
return null;
}
}
};
var protocol_protocol = Protocol;
class connection_Connection extends dispatcher_Dispatcher {
constructor(id, transport) {
super();
this.id = id;
this.transport = transport;
this.activityTimeout = transport.activityTimeout;
this.bindListeners();
}
handlesActivityChecks() {
return this.transport.handlesActivityChecks();
}
send(data2) {
return this.transport.send(data2);
}
send_event(name2, data2, channel) {
var event = { event: name2, data: data2 };
if (channel) {
event.channel = channel;
}
logger.debug("Event sent", event);
return this.send(protocol_protocol.encodeMessage(event));
}
ping() {
if (this.transport.supportsPing()) {
this.transport.ping();
} else {
this.send_event("pusher:ping", {});
}
}
close() {
this.transport.close();
}
bindListeners() {
var listeners = {
message: (messageEvent) => {
var pusherEvent;
try {
pusherEvent = protocol_protocol.decodeMessage(messageEvent);
} catch (e) {
this.emit("error", {
type: "MessageParseError",
error: e,
data: messageEvent.data
});
}
if (pusherEvent !== void 0) {
logger.debug("Event recd", pusherEvent);
switch (pusherEvent.event) {
case "pusher:error":
this.emit("error", {
type: "PusherError",
data: pusherEvent.data
});
break;
case "pusher:ping":
this.emit("ping");
break;
case "pusher:pong":
this.emit("pong");
break;
}
this.emit("message", pusherEvent);
}
},
activity: () => {
this.emit("activity");
},
error: (error) => {
this.emit("error", error);
},
closed: (closeEvent) => {
unbindListeners();
if (closeEvent && closeEvent.code) {
this.handleCloseEvent(closeEvent);
}
this.transport = null;
this.emit("closed");
}
};
var unbindListeners = () => {
objectApply(listeners, (listener, event) => {
this.transport.unbind(event, listener);
});
};
objectApply(listeners, (listener, event) => {
this.transport.bind(event, listener);
});
}
handleCloseEvent(closeEvent) {
var action = protocol_protocol.getCloseAction(closeEvent);
var error = protocol_protocol.getCloseError(closeEvent);
if (error) {
this.emit("error", error);
}
if (action) {
this.emit(action, { action, error });
}
}
}
class handshake_Handshake {
constructor(transport, callback) {
this.transport = transport;
this.callback = callback;
this.bindListeners();
}
close() {
this.unbindListeners();
this.transport.close();
}
bindListeners() {
this.onMessage = (m) => {
this.unbindListeners();
var result;
try {
result = protocol_protocol.processHandshake(m);
} catch (e) {
this.finish("error", { error: e });
this.transport.close();
return;
}
if (result.action === "connected") {
this.finish("connected", {
connection: new connection_Connection(result.id, this.transport),
activityTimeout: result.activityTimeout
});
} else {
this.finish(result.action, { error: result.error });
this.transport.close();
}
};
this.onClosed = (closeEvent) => {
this.unbindListeners();
var action = protocol_protocol.getCloseAction(closeEvent) || "backoff";
var error = protocol_protocol.getCloseError(closeEvent);
this.finish(action, { error });
};
this.transport.bind("message", this.onMessage);
this.transport.bind("closed", this.onClosed);
}
unbindListeners() {
this.transport.unbind("message", this.onMessage);
this.transport.unbind("closed", this.onClosed);
}
finish(action, params) {
this.callback(extend({ transport: this.transport, action }, params));
}
}
class timeline_sender_TimelineSender {
constructor(timeline, options) {
this.timeline = timeline;
this.options = options || {};
}
send(useTLS, callback) {
if (this.timeline.isEmpty()) {
return;
}
this.timeline.send(runtime.TimelineTransport.getAgent(this, useTLS), callback);
}
}
class channel_Channel extends dispatcher_Dispatcher {
constructor(name2, pusher) {
super(function(event, data2) {
logger.debug("No callbacks on " + name2 + " for " + event);
});
this.name = name2;
this.pusher = pusher;
this.subscribed = false;
this.subscriptionPending = false;
this.subscriptionCancelled = false;
}
authorize(socketId, callback) {
return callback(null, { auth: "" });
}
trigger(event, data2) {
if (event.indexOf("client-") !== 0) {
throw new BadEventName("Event '" + event + "' does not start with 'client-'");
}
if (!this.subscribed) {
var suffix = url_store.buildLogSuffix("triggeringClientEvents");
logger.warn(`Client event triggered before channel 'subscription_succeeded' event . ${suffix}`);
}
return this.pusher.send_event(event, data2, this.name);
}
disconnect() {
this.subscribed = false;
this.subscriptionPending = false;
}
handleEvent(event) {
var eventName = event.event;
var data2 = event.data;
if (eventName === "pusher_internal:subscription_succeeded") {
this.handleSubscriptionSucceededEvent(event);
} else if (eventName === "pusher_internal:subscription_count") {
this.handleSubscriptionCountEvent(event);
} else if (eventName.indexOf("pusher_internal:") !== 0) {
var metadata = {};
this.emit(eventName, data2, metadata);
}
}
handleSubscriptionSucceededEvent(event) {
this.subscriptionPending = false;
this.subscribed = true;
if (this.subscriptionCancelled) {
this.pusher.unsubscribe(this.name);
} else {
this.emit("pusher:subscription_succeeded", event.data);
}
}
handleSubscriptionCountEvent(event) {
if (event.data.subscription_count) {
this.subscriptionCount = event.data.subscription_count;
}
this.emit("pusher:subscription_count", event.data);
}
subscribe() {
if (this.subscribed) {
return;
}
this.subscriptionPending = true;
this.subscriptionCancelled = false;
this.authorize(this.pusher.connection.socket_id, (error, data2) => {
if (error) {
this.subscriptionPending = false;
logger.error(error.toString());
this.emit("pusher:subscription_error", Object.assign({}, {
type: "AuthError",
error: error.message
}, error instanceof HTTPAuthError ? { status: error.status } : {}));
} else {
this.pusher.send_event("pusher:subscribe", {
auth: data2.auth,
channel_data: data2.channel_data,
channel: this.name
});
}
});
}
unsubscribe() {
this.subscribed = false;
this.pusher.send_event("pusher:unsubscribe", {
channel: this.name
});
}
cancelSubscription() {
this.subscriptionCancelled = true;
}
reinstateSubscription() {
this.subscriptionCancelled = false;
}
}
class private_channel_PrivateChannel extends channel_Channel {
authorize(socketId, callback) {
return this.pusher.config.channelAuthorizer({
channelName: this.name,
socketId
}, callback);
}
}
class members_Members {
constructor() {
this.reset();
}
get(id) {
if (Object.prototype.hasOwnProperty.call(this.members, id)) {
return {
id,
info: this.members[id]
};
} else {
return null;
}
}
each(callback) {
objectApply(this.members, (member, id) => {
callback(this.get(id));
});
}
setMyID(id) {
this.myID = id;
}
onSubscription(subscriptionData) {
this.members = subscriptionData.presence.hash;
this.count = subscriptionData.presence.count;
this.me = this.get(this.myID);
}
addMember(memberData) {
if (this.get(memberData.user_id) === null) {
this.count++;
}
this.members[memberData.user_id] = memberData.user_info;
return this.get(memberData.user_id);
}
removeMember(memberData) {
var member = this.get(memberData.user_id);
if (member) {
delete this.members[memberData.user_id];
this.count--;
}
return member;
}
reset() {
this.members = {};
this.count = 0;
this.myID = null;
this.me = null;
}
}
var __awaiter2 = function(thisArg, _arguments, P, generator) {
function adopt(value2) {
return value2 instanceof P ? value2 : new P(function(resolve) {
resolve(value2);
});
}
return new (P || (P = Promise))(function(resolve, reject) {
function fulfilled(value2) {
try {
step(generator.next(value2));
} catch (e) {
reject(e);
}
}
function rejected(value2) {
try {
step(generator["throw"](value2));
} 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());
});
};
class presence_channel_PresenceChannel extends private_channel_PrivateChannel {
constructor(name2, pusher) {
super(name2, pusher);
this.members = new members_Members();
}
authorize(socketId, callback) {
super.authorize(socketId, (error, authData) => __awaiter2(this, void 0, void 0, function* () {
if (!error) {
authData = authData;
if (authData.channel_data != null) {
var channelData = JSON.parse(authData.channel_data);
this.members.setMyID(channelData.user_id);
} else {
yield this.pusher.user.signinDonePromise;
if (this.pusher.user.user_data != null) {
this.members.setMyID(this.pusher.user.user_data.id);
} else {
let suffix = url_store.buildLogSuffix("authorizationEndpoint");
logger.error(`Invalid auth response for channel '${this.name}', expected 'channel_data' field. ${suffix}, or the user should be signed in.`);
callback("Invalid auth response");
return;
}
}
}
callback(error, authData);
}));
}
handleEvent(event) {
var eventName = event.event;
if (eventName.indexOf("pusher_internal:") === 0) {
this.handleInternalEvent(event);
} else {
var data2 = event.data;
var metadata = {};
if (event.user_id) {
metadata.user_id = event.user_id;
}
this.emit(eventName, data2, metadata);
}
}
handleInternalEvent(event) {
var eventName = event.event;
var data2 = event.data;
switch (eventName) {
case "pusher_internal:subscription_succeeded":
this.handleSubscriptionSucceededEvent(event);
break;
case "pusher_internal:subscription_count":
this.handleSubscriptionCountEvent(event);
break;
case "pusher_internal:member_added":
var addedMember = this.members.addMember(data2);
this.emit("pusher:member_added", addedMember);
break;
case "pusher_internal:member_removed":
var removedMember = this.members.removeMember(data2);
if (removedMember) {
this.emit("pusher:member_removed", removedMember);
}
break;
}
}
handleSubscriptionSucceededEvent(event) {
this.subscriptionPending = false;
this.subscribed = true;
if (this.subscriptionCancelled) {
this.pusher.unsubscribe(this.name);
} else {
this.members.onSubscription(event.data);
this.emit("pusher:subscription_succeeded", this.members);
}
}
disconnect() {
this.members.reset();
super.disconnect();
}
}
var utf8 = __webpack_require__(1);
var base64 = __webpack_require__(0);
class encrypted_channel_EncryptedChannel extends private_channel_PrivateChannel {
constructor(name2, pusher, nacl) {
super(name2, pusher);
this.key = null;
this.nacl = nacl;
}
authorize(socketId, callback) {
super.authorize(socketId, (error, authData) => {
if (error) {
callback(error, authData);
return;
}
let sharedSecret = authData["shared_secret"];
if (!sharedSecret) {
callback(new Error(`No shared_secret key in auth payload for encrypted channel: ${this.name}`), null);
return;
}
this.key = Object(base64["decode"])(sharedSecret);
delete authData["shared_secret"];
callback(null, authData);
});
}
trigger(event, data2) {
throw new UnsupportedFeature("Client events are not currently supported for encrypted channels");
}
handleEvent(event) {
var eventName = event.event;
var data2 = event.data;
if (eventName.indexOf("pusher_internal:") === 0 || eventName.indexOf("pusher:") === 0) {
super.handleEvent(event);
return;
}
this.handleEncryptedEvent(eventName, data2);
}
handleEncryptedEvent(event, data2) {
if (!this.key) {
logger.debug("Received encrypted event before key has been retrieved from the authEndpoint");
return;
}
if (!data2.ciphertext || !data2.nonce) {
logger.error("Unexpected format for encrypted event, expected object with `ciphertext` and `nonce` fields, got: " + data2);
return;
}
let cipherText = Object(base64["decode"])(data2.ciphertext);
if (cipherText.length < this.nacl.secretbox.overheadLength) {
logger.error(`Expected encrypted event ciphertext length to be ${this.nacl.secretbox.overheadLength}, got: ${cipherText.length}`);
return;
}
let nonce = Object(base64["decode"])(data2.nonce);
if (nonce.length < this.nacl.secretbox.nonceLength) {
logger.error(`Expected encrypted event nonce length to be ${this.nacl.secretbox.nonceLength}, got: ${nonce.length}`);
return;
}
let bytes = this.nacl.secretbox.open(cipherText, nonce, this.key);
if (bytes === null) {
logger.debug("Failed to decrypt an event, probably because it was encrypted with a different key. Fetching a new key from the authEndpoint...");
this.authorize(this.pusher.connection.socket_id, (error, authData) => {
if (error) {
logger.error(`Failed to make a request to the authEndpoint: ${authData}. Unable to fetch new key, so dropping encrypted event`);
return;
}
bytes = this.nacl.secretbox.open(cipherText, nonce, this.key);
if (bytes === null) {
logger.error(`Failed to decrypt event with new key. Dropping encrypted event`);
return;
}
this.emit(event, this.getDataToEmit(bytes));
return;
});
return;
}
this.emit(event, this.getDataToEmit(bytes));
}
getDataToEmit(bytes) {
let raw = Object(utf8["decode"])(bytes);
try {
return JSON.parse(raw);
} catch (_a) {
return raw;
}
}
}
class connection_manager_ConnectionManager extends dispatcher_Dispatcher {
constructor(key2, options) {
super();
this.state = "initialized";
this.connection = null;
this.key = key2;
this.options = options;
this.timeline = this.options.timeline;
this.usingTLS = this.options.useTLS;
this.errorCallbacks = this.buildErrorCallbacks();
this.connectionCallbacks = this.buildConnectionCallbacks(this.errorCallbacks);
this.handshakeCallbacks = this.buildHandshakeCallbacks(this.errorCallbacks);
var Network = runtime.getNetwork();
Network.bind("online", () => {
this.timeline.info({ netinfo: "online" });
if (this.state === "connecting" || this.state === "unavailable") {
this.retryIn(0);
}
});
Network.bind("offline", () => {
this.timeline.info({ netinfo: "offline" });
if (this.connection) {
this.sendActivityCheck();
}
});
this.updateStrategy();
}
connect() {
if (this.connection || this.runner) {
return;
}
if (!this.strategy.isSupported()) {
this.updateState("failed");
return;
}
this.updateState("connecting");
this.startConnecting();
this.setUnavailableTimer();
}
send(data2) {
if (this.connection) {
return this.connection.send(data2);
} else {
return false;
}
}
send_event(name2, data2, channel) {
if (this.connection) {
return this.connection.send_event(name2, data2, channel);
} else {
return false;
}
}
disconnect() {
this.disconnectInternally();
this.updateState("disconnected");
}
isUsingTLS() {
return this.usingTLS;
}
startConnecting() {
var callback = (error, handshake) => {
if (error) {
this.runner = this.strategy.connect(0, callback);
} else {
if (handshake.action === "error") {
this.emit("error", {
type: "HandshakeError",
error: handshake.error
});
this.timeline.error({ handshakeError: handshake.error });
} else {
this.abortConnecting();
this.handshakeCallbacks[handshake.action](handshake);
}
}
};
this.runner = this.strategy.connect(0, callback);
}
abortConnecting() {
if (this.runner) {
this.runner.abort();
this.runner = null;
}
}
disconnectInternally() {
this.abortConnecting();
this.clearRetryTimer();
this.clearUnavailableTimer();
if (this.connection) {
var connection = this.abandonConnection();
connection.close();
}
}
updateStrategy() {
this.strategy = this.options.getStrategy({
key: this.key,
timeline: this.timeline,
useTLS: this.usingTLS
});
}
retryIn(delay) {
this.timeline.info({ action: "retry", delay });
if (delay > 0) {
this.emit("connecting_in", Math.round(delay / 1e3));
}
this.retryTimer = new timers_OneOffTimer(delay || 0, () => {
this.disconnectInternally();
this.connect();
});
}
clearRetryTimer() {
if (this.retryTimer) {
this.retryTimer.ensureAborted();
this.retryTimer = null;
}
}
setUnavailableTimer() {
this.unavailableTimer = new timers_OneOffTimer(this.options.unavailableTimeout, () => {
this.updateState("unavailable");
});
}
clearUnavailableTimer() {
if (this.unavailableTimer) {
this.unavailableTimer.ensureAborted();
}
}
sendActivityCheck() {
this.stopActivityCheck();
this.connection.ping();
this.activityTimer = new timers_OneOffTimer(this.options.pongTimeout, () => {
this.timeline.error({ pong_timed_out: this.options.pongTimeout });
this.retryIn(0);
});
}
resetActivityCheck() {
this.stopActivityCheck();
if (this.connection && !this.connection.handlesActivityChecks()) {
this.activityTimer = new timers_OneOffTimer(this.activityTimeout, () => {
this.sendActivityCheck();
});
}
}
stopActivityCheck() {
if (this.activityTimer) {
this.activityTimer.ensureAborted();
}
}
buildConnectionCallbacks(errorCallbacks) {
return extend({}, errorCallbacks, {
message: (message) => {
this.resetActivityCheck();
this.emit("message", message);
},
ping: () => {
this.send_event("pusher:pong", {});
},
activity: () => {
this.resetActivityCheck();
},
error: (error) => {
this.emit("error", error);
},
closed: () => {
this.abandonConnection();
if (this.shouldRetry()) {
this.retryIn(1e3);
}
}
});
}
buildHandshakeCallbacks(errorCallbacks) {
return extend({}, errorCallbacks, {
connected: (handshake) => {
this.activityTimeout = Math.min(this.options.activityTimeout, handshake.activityTimeout, handshake.connection.activityTimeout || Infinity);
this.clearUnavailableTimer();
this.setConnection(handshake.connection);
this.socket_id = this.connection.id;
this.updateState("connected", { socket_id: this.socket_id });
}
});
}
buildErrorCallbacks() {
let withErrorEmitted = (callback) => {
return (result) => {
if (result.error) {
this.emit("error", { type: "WebSocketError", error: result.error });
}
callback(result);
};
};
return {
tls_only: withErrorEmitted(() => {
this.usingTLS = true;
this.updateStrategy();
this.retryIn(0);
}),
refused: withErrorEmitted(() => {
this.disconnect();
}),
backoff: withErrorEmitted(() => {
this.retryIn(1e3);
}),
retry: withErrorEmitted(() => {
this.retryIn(0);
})
};
}
setConnection(connection) {
this.connection = connection;
for (var event in this.connectionCallbacks) {
this.connection.bind(event, this.connectionCallbacks[event]);
}
this.resetActivityCheck();
}
abandonConnection() {
if (!this.connection) {
return;
}
this.stopActivityCheck();
for (var event in this.connectionCallbacks) {
this.connection.unbind(event, this.connectionCallbacks[event]);
}
var connection = this.connection;
this.connection = null;
return connection;
}
updateState(newState, data2) {
var previousState = this.state;
this.state = newState;
if (previousState !== newState) {
var newStateDescription = newState;
if (newStateDescription === "connected") {
newStateDescription += " with new socket ID " + data2.socket_id;
}
logger.debug("State changed", previousState + " -> " + newStateDescription);
this.timeline.info({ state: newState, params: data2 });
this.emit("state_change", { previous: previousState, current: newState });
this.emit(newState, data2);
}
}
shouldRetry() {
return this.state === "connecting" || this.state === "connected";
}
}
class channels_Channels {
constructor() {
this.channels = {};
}
add(name2, pusher) {
if (!this.channels[name2]) {
this.channels[name2] = createChannel(name2, pusher);
}
return this.channels[name2];
}
all() {
return values(this.channels);
}
find(name2) {
return this.channels[name2];
}
remove(name2) {
var channel = this.channels[name2];
delete this.channels[name2];
return channel;
}
disconnect() {
objectApply(this.channels, function(channel) {
channel.disconnect();
});
}
}
function createChannel(name2, pusher) {
if (name2.indexOf("private-encrypted-") === 0) {
if (pusher.config.nacl) {
return factory.createEncryptedChannel(name2, pusher, pusher.config.nacl);
}
let errMsg = "Tried to subscribe to a private-encrypted- channel but no nacl implementation available";
let suffix = url_store.buildLogSuffix("encryptedChannelSupport");
throw new UnsupportedFeature(`${errMsg}. ${suffix}`);
} else if (name2.indexOf("private-") === 0) {
return factory.createPrivateChannel(name2, pusher);
} else if (name2.indexOf("presence-") === 0) {
return factory.createPresenceChannel(name2, pusher);
} else if (name2.indexOf("#") === 0) {
throw new BadChannelName('Cannot create a channel with name "' + name2 + '".');
} else {
return factory.createChannel(name2, pusher);
}
}
var Factory = {
createChannels() {
return new channels_Channels();
},
createConnectionManager(key2, options) {
return new connection_manager_ConnectionManager(key2, options);
},
createChannel(name2, pusher) {
return new channel_Channel(name2, pusher);
},
createPrivateChannel(name2, pusher) {
return new private_channel_PrivateChannel(name2, pusher);
},
createPresenceChannel(name2, pusher) {
return new presence_channel_PresenceChannel(name2, pusher);
},
createEncryptedChannel(name2, pusher, nacl) {
return new encrypted_channel_EncryptedChannel(name2, pusher, nacl);
},
createTimelineSender(timeline, options) {
return new timeline_sender_TimelineSender(timeline, options);
},
createHandshake(transport, callback) {
return new handshake_Handshake(transport, callback);
},
createAssistantToTheTransportManager(manager, transport, options) {
return new assistant_to_the_transport_manager_AssistantToTheTransportManager(manager, transport, options);
}
};
var factory = Factory;
class transport_manager_TransportManager {
constructor(options) {
this.options = options || {};
this.livesLeft = this.options.lives || Infinity;
}
getAssistant(transport) {
return factory.createAssistantToTheTransportManager(this, transport, {
minPingDelay: this.options.minPingDelay,
maxPingDelay: this.options.maxPingDelay
});
}
isAlive() {
return this.livesLeft > 0;
}
reportDeath() {
this.livesLeft -= 1;
}
}
class sequential_strategy_SequentialStrategy {
constructor(strategies, options) {
this.strategies = strategies;
this.loop = Boolean(options.loop);
this.failFast = Boolean(options.failFast);
this.timeout = options.timeout;
this.timeoutLimit = options.timeoutLimit;
}
isSupported() {
return any(this.strategies, util2.method("isSupported"));
}
connect(minPriority, callback) {
var strategies = this.strategies;
var current = 0;
var timeout = this.timeout;
var runner = null;
var tryNextStrategy = (error, handshake) => {
if (handshake) {
callback(null, handshake);
} else {
current = current + 1;
if (this.loop) {
current = current % strategies.length;
}
if (current < strategies.length) {
if (timeout) {
timeout = timeout * 2;
if (this.timeoutLimit) {
timeout = Math.min(timeout, this.timeoutLimit);
}
}
runner = this.tryStrategy(strategies[current], minPriority, { timeout, failFast: this.failFast }, tryNextStrategy);
} else {
callback(true);
}
}
};
runner = this.tryStrategy(strategies[current], minPriority, { timeout, failFast: this.failFast }, tryNextStrategy);
return {
abort: function() {
runner.abort();
},
forceMinPriority: function(p) {
minPriority = p;
if (runner) {
runner.forceMinPriority(p);
}
}
};
}
tryStrategy(strategy, minPriority, options, callback) {
var timer2 = null;
var runner = null;
if (options.timeout > 0) {
timer2 = new timers_OneOffTimer(options.timeout, function() {
runner.abort();
callback(true);
});
}
runner = strategy.connect(minPriority, function(error, handshake) {
if (error && timer2 && timer2.isRunning() && !options.failFast) {
return;
}
if (timer2) {
timer2.ensureAborted();
}
callback(error, handshake);
});
return {
abort: function() {
if (timer2) {
timer2.ensureAborted();
}
runner.abort();
},
forceMinPriority: function(p) {
runner.forceMinPriority(p);
}
};
}
}
class best_connected_ever_strategy_BestConnectedEverStrategy {
constructor(strategies) {
this.strategies = strategies;
}
isSupported() {
return any(this.strategies, util2.method("isSupported"));
}
connect(minPriority, callback) {
return connect(this.strategies, minPriority, function(i, runners) {
return function(error, handshake) {
runners[i].error = error;
if (error) {
if (allRunnersFailed(runners)) {
callback(true);
}
return;
}
apply(runners, function(runner) {
runner.forceMinPriority(handshake.transport.priority);
});
callback(null, handshake);
};
});
}
}
function connect(strategies, minPriority, callbackBuilder) {
var runners = map2(strategies, function(strategy, i, _, rs) {
return strategy.connect(minPriority, callbackBuilder(i, rs));
});
return {
abort: function() {
apply(runners, abortRunner);
},
forceMinPriority: function(p) {
apply(runners, function(runner) {
runner.forceMinPriority(p);
});
}
};
}
function allRunnersFailed(runners) {
return collections_all(runners, function(runner) {
return Boolean(runner.error);
});
}
function abortRunner(runner) {
if (!runner.error && !runner.aborted) {
runner.abort();
runner.aborted = true;
}
}
class websocket_prioritized_cached_strategy_WebSocketPrioritizedCachedStrategy {
constructor(strategy, transports2, options) {
this.strategy = strategy;
this.transports = transports2;
this.ttl = options.ttl || 1800 * 1e3;
this.usingTLS = options.useTLS;
this.timeline = options.timeline;
}
isSupported() {
return this.strategy.isSupported();
}
connect(minPriority, callback) {
var usingTLS = this.usingTLS;
var info = fetchTransportCache(usingTLS);
var cacheSkipCount = info && info.cacheSkipCount ? info.cacheSkipCount : 0;
var strategies = [this.strategy];
if (info && info.timestamp + this.ttl >= util2.now()) {
var transport = this.transports[info.transport];
if (transport) {
if (["ws", "wss"].includes(info.transport) || cacheSkipCount > 3) {
this.timeline.info({
cached: true,
transport: info.transport,
latency: info.latency
});
strategies.push(new sequential_strategy_SequentialStrategy([transport], {
timeout: info.latency * 2 + 1e3,
failFast: true
}));
} else {
cacheSkipCount++;
}
}
}
var startTimestamp = util2.now();
var runner = strategies.pop().connect(minPriority, function cb(error, handshake) {
if (error) {
flushTransportCache(usingTLS);
if (strategies.length > 0) {
startTimestamp = util2.now();
runner = strategies.pop().connect(minPriority, cb);
} else {
callback(error);
}
} else {
storeTransportCache(usingTLS, handshake.transport.name, util2.now() - startTimestamp, cacheSkipCount);
callback(null, handshake);
}
});
return {
abort: function() {
runner.abort();
},
forceMinPriority: function(p) {
minPriority = p;
if (runner) {
runner.forceMinPriority(p);
}
}
};
}
}
function getTransportCacheKey(usingTLS) {
return "pusherTransport" + (usingTLS ? "TLS" : "NonTLS");
}
function fetchTransportCache(usingTLS) {
var storage = runtime.getLocalStorage();
if (storage) {
try {
var serializedCache = storage[getTransportCacheKey(usingTLS)];
if (serializedCache) {
return JSON.parse(serializedCache);
}
} catch (e) {
flushTransportCache(usingTLS);
}
}
return null;
}
function storeTransportCache(usingTLS, transport, latency, cacheSkipCount) {
var storage = runtime.getLocalStorage();
if (storage) {
try {
storage[getTransportCacheKey(usingTLS)] = safeJSONStringify({
timestamp: util2.now(),
transport,
latency,
cacheSkipCount
});
} catch (e) {
}
}
}
function flushTransportCache(usingTLS) {
var storage = runtime.getLocalStorage();
if (storage) {
try {
delete storage[getTransportCacheKey(usingTLS)];
} catch (e) {
}
}
}
class delayed_strategy_DelayedStrategy {
constructor(strategy, { delay: number }) {
this.strategy = strategy;
this.options = { delay: number };
}
isSupported() {
return this.strategy.isSupported();
}
connect(minPriority, callback) {
var strategy = this.strategy;
var runner;
var timer2 = new timers_OneOffTimer(this.options.delay, function() {
runner = strategy.connect(minPriority, callback);
});
return {
abort: function() {
timer2.ensureAborted();
if (runner) {
runner.abort();
}
},
forceMinPriority: function(p) {
minPriority = p;
if (runner) {
runner.forceMinPriority(p);
}
}
};
}
}
class IfStrategy {
constructor(test, trueBranch, falseBranch) {
this.test = test;
this.trueBranch = trueBranch;
this.falseBranch = falseBranch;
}
isSupported() {
var branch = this.test() ? this.trueBranch : this.falseBranch;
return branch.isSupported();
}
connect(minPriority, callback) {
var branch = this.test() ? this.trueBranch : this.falseBranch;
return branch.connect(minPriority, callback);
}
}
class FirstConnectedStrategy {
constructor(strategy) {
this.strategy = strategy;
}
isSupported() {
return this.strategy.isSupported();
}
connect(minPriority, callback) {
var runner = this.strategy.connect(minPriority, function(error, handshake) {
if (handshake) {
runner.abort();
}
callback(error, handshake);
});
return runner;
}
}
function testSupportsStrategy(strategy) {
return function() {
return strategy.isSupported();
};
}
var getDefaultStrategy = function(config2, baseOptions, defineTransport) {
var definedTransports = {};
function defineTransportStrategy(name2, type, priority, options, manager) {
var transport = defineTransport(config2, name2, type, priority, options, manager);
definedTransports[name2] = transport;
return transport;
}
var ws_options = Object.assign({}, baseOptions, {
hostNonTLS: config2.wsHost + ":" + config2.wsPort,
hostTLS: config2.wsHost + ":" + config2.wssPort,
httpPath: config2.wsPath
});
var wss_options = Object.assign({}, ws_options, {
useTLS: true
});
var sockjs_options = Object.assign({}, baseOptions, {
hostNonTLS: config2.httpHost + ":" + config2.httpPort,
hostTLS: config2.httpHost + ":" + config2.httpsPort,
httpPath: config2.httpPath
});
var timeouts = {
loop: true,
timeout: 15e3,
timeoutLimit: 6e4
};
var ws_manager = new transport_manager_TransportManager({
minPingDelay: 1e4,
maxPingDelay: config2.activityTimeout
});
var streaming_manager = new transport_manager_TransportManager({
lives: 2,
minPingDelay: 1e4,
maxPingDelay: config2.activityTimeout
});
var ws_transport = defineTransportStrategy("ws", "ws", 3, ws_options, ws_manager);
var wss_transport = defineTransportStrategy("wss", "ws", 3, wss_options, ws_manager);
var sockjs_transport = defineTransportStrategy("sockjs", "sockjs", 1, sockjs_options);
var xhr_streaming_transport = defineTransportStrategy("xhr_streaming", "xhr_streaming", 1, sockjs_options, streaming_manager);
var xdr_streaming_transport = defineTransportStrategy("xdr_streaming", "xdr_streaming", 1, sockjs_options, streaming_manager);
var xhr_polling_transport = defineTransportStrategy("xhr_polling", "xhr_polling", 1, sockjs_options);
var xdr_polling_transport = defineTransportStrategy("xdr_polling", "xdr_polling", 1, sockjs_options);
var ws_loop = new sequential_strategy_SequentialStrategy([ws_transport], timeouts);
var wss_loop = new sequential_strategy_SequentialStrategy([wss_transport], timeouts);
var sockjs_loop = new sequential_strategy_SequentialStrategy([sockjs_transport], timeouts);
var streaming_loop = new sequential_strategy_SequentialStrategy([
new IfStrategy(testSupportsStrategy(xhr_streaming_transport), xhr_streaming_transport, xdr_streaming_transport)
], timeouts);
var polling_loop = new sequential_strategy_SequentialStrategy([
new IfStrategy(testSupportsStrategy(xhr_polling_transport), xhr_polling_transport, xdr_polling_transport)
], timeouts);
var http_loop = new sequential_strategy_SequentialStrategy([
new IfStrategy(testSupportsStrategy(streaming_loop), new best_connected_ever_strategy_BestConnectedEverStrategy([
streaming_loop,
new delayed_strategy_DelayedStrategy(polling_loop, { delay: 4e3 })
]), polling_loop)
], timeouts);
var http_fallback_loop = new IfStrategy(testSupportsStrategy(http_loop), http_loop, sockjs_loop);
var wsStrategy;
if (baseOptions.useTLS) {
wsStrategy = new best_connected_ever_strategy_BestConnectedEverStrategy([
ws_loop,
new delayed_strategy_DelayedStrategy(http_fallback_loop, { delay: 2e3 })
]);
} else {
wsStrategy = new best_connected_ever_strategy_BestConnectedEverStrategy([
ws_loop,
new delayed_strategy_DelayedStrategy(wss_loop, { delay: 2e3 }),
new delayed_strategy_DelayedStrategy(http_fallback_loop, { delay: 5e3 })
]);
}
return new websocket_prioritized_cached_strategy_WebSocketPrioritizedCachedStrategy(new FirstConnectedStrategy(new IfStrategy(testSupportsStrategy(ws_transport), wsStrategy, http_fallback_loop)), definedTransports, {
ttl: 18e5,
timeline: baseOptions.timeline,
useTLS: baseOptions.useTLS
});
};
var default_strategy = getDefaultStrategy;
var transport_connection_initializer = function() {
var self2 = this;
self2.timeline.info(self2.buildTimelineMessage({
transport: self2.name + (self2.options.useTLS ? "s" : "")
}));
if (self2.hooks.isInitialized()) {
self2.changeState("initialized");
} else if (self2.hooks.file) {
self2.changeState("initializing");
Dependencies.load(self2.hooks.file, { useTLS: self2.options.useTLS }, function(error, callback) {
if (self2.hooks.isInitialized()) {
self2.changeState("initialized");
callback(true);
} else {
if (error) {
self2.onError(error);
}
self2.onClose();
callback(false);
}
});
} else {
self2.onClose();
}
};
var http_xdomain_request_hooks = {
getRequest: function(socket) {
var xdr = new window.XDomainRequest();
xdr.ontimeout = function() {
socket.emit("error", new RequestTimedOut());
socket.close();
};
xdr.onerror = function(e) {
socket.emit("error", e);
socket.close();
};
xdr.onprogress = function() {
if (xdr.responseText && xdr.responseText.length > 0) {
socket.onChunk(200, xdr.responseText);
}
};
xdr.onload = function() {
if (xdr.responseText && xdr.responseText.length > 0) {
socket.onChunk(200, xdr.responseText);
}
socket.emit("finished", 200);
socket.close();
};
return xdr;
},
abortRequest: function(xdr) {
xdr.ontimeout = xdr.onerror = xdr.onprogress = xdr.onload = null;
xdr.abort();
}
};
var http_xdomain_request = http_xdomain_request_hooks;
const MAX_BUFFER_LENGTH = 256 * 1024;
class http_request_HTTPRequest extends dispatcher_Dispatcher {
constructor(hooks, method, url) {
super();
this.hooks = hooks;
this.method = method;
this.url = url;
}
start(payload) {
this.position = 0;
this.xhr = this.hooks.getRequest(this);
this.unloader = () => {
this.close();
};
runtime.addUnloadListener(this.unloader);
this.xhr.open(this.method, this.url, true);
if (this.xhr.setRequestHeader) {
this.xhr.setRequestHeader("Content-Type", "application/json");
}
this.xhr.send(payload);
}
close() {
if (this.unloader) {
runtime.removeUnloadListener(this.unloader);
this.unloader = null;
}
if (this.xhr) {
this.hooks.abortRequest(this.xhr);
this.xhr = null;
}
}
onChunk(status, data2) {
while (true) {
var chunk = this.advanceBuffer(data2);
if (chunk) {
this.emit("chunk", { status, data: chunk });
} else {
break;
}
}
if (this.isBufferTooLong(data2)) {
this.emit("buffer_too_long");
}
}
advanceBuffer(buffer) {
var unreadData = buffer.slice(this.position);
var endOfLinePosition = unreadData.indexOf("\n");
if (endOfLinePosition !== -1) {
this.position += endOfLinePosition + 1;
return unreadData.slice(0, endOfLinePosition);
} else {
return null;
}
}
isBufferTooLong(buffer) {
return this.position === buffer.length && buffer.length > MAX_BUFFER_LENGTH;
}
}
var State;
(function(State2) {
State2[State2["CONNECTING"] = 0] = "CONNECTING";
State2[State2["OPEN"] = 1] = "OPEN";
State2[State2["CLOSED"] = 3] = "CLOSED";
})(State || (State = {}));
var state = State;
var autoIncrement = 1;
class http_socket_HTTPSocket {
constructor(hooks, url) {
this.hooks = hooks;
this.session = randomNumber(1e3) + "/" + randomString(8);
this.location = getLocation(url);
this.readyState = state.CONNECTING;
this.openStream();
}
send(payload) {
return this.sendRaw(JSON.stringify([payload]));
}
ping() {
this.hooks.sendHeartbeat(this);
}
close(code, reason) {
this.onClose(code, reason, true);
}
sendRaw(payload) {
if (this.readyState === state.OPEN) {
try {
runtime.createSocketRequest("POST", getUniqueURL(getSendURL(this.location, this.session))).start(payload);
return true;
} catch (e) {
return false;
}
} else {
return false;
}
}
reconnect() {
this.closeStream();
this.openStream();
}
onClose(code, reason, wasClean) {
this.closeStream();
this.readyState = state.CLOSED;
if (this.onclose) {
this.onclose({
code,
reason,
wasClean
});
}
}
onChunk(chunk) {
if (chunk.status !== 200) {
return;
}
if (this.readyState === state.OPEN) {
this.onActivity();
}
var payload;
var type = chunk.data.slice(0, 1);
switch (type) {
case "o":
payload = JSON.parse(chunk.data.slice(1) || "{}");
this.onOpen(payload);
break;
case "a":
payload = JSON.parse(chunk.data.slice(1) || "[]");
for (var i = 0; i < payload.length; i++) {
this.onEvent(payload[i]);
}
break;
case "m":
payload = JSON.parse(chunk.data.slice(1) || "null");
this.onEvent(payload);
break;
case "h":
this.hooks.onHeartbeat(this);
break;
case "c":
payload = JSON.parse(chunk.data.slice(1) || "[]");
this.onClose(payload[0], payload[1], true);
break;
}
}
onOpen(options) {
if (this.readyState === state.CONNECTING) {
if (options && options.hostname) {
this.location.base = replaceHost(this.location.base, options.hostname);
}
this.readyState = state.OPEN;
if (this.onopen) {
this.onopen();
}
} else {
this.onClose(1006, "Server lost session", true);
}
}
onEvent(event) {
if (this.readyState === state.OPEN && this.onmessage) {
this.onmessage({ data: event });
}
}
onActivity() {
if (this.onactivity) {
this.onactivity();
}
}
onError(error) {
if (this.onerror) {
this.onerror(error);
}
}
openStream() {
this.stream = runtime.createSocketRequest("POST", getUniqueURL(this.hooks.getReceiveURL(this.location, this.session)));
this.stream.bind("chunk", (chunk) => {
this.onChunk(chunk);
});
this.stream.bind("finished", (status) => {
this.hooks.onFinished(this, status);
});
this.stream.bind("buffer_too_long", () => {
this.reconnect();
});
try {
this.stream.start();
} catch (error) {
util2.defer(() => {
this.onError(error);
this.onClose(1006, "Could not start streaming", false);
});
}
}
closeStream() {
if (this.stream) {
this.stream.unbind_all();
this.stream.close();
this.stream = null;
}
}
}
function getLocation(url) {
var parts = /([^\?]*)\/*(\??.*)/.exec(url);
return {
base: parts[1],
queryString: parts[2]
};
}
function getSendURL(url, session) {
return url.base + "/" + session + "/xhr_send";
}
function getUniqueURL(url) {
var separator = url.indexOf("?") === -1 ? "?" : "&";
return url + separator + "t=" + +/* @__PURE__ */ new Date() + "&n=" + autoIncrement++;
}
function replaceHost(url, hostname) {
var urlParts = /(https?:\/\/)([^\/:]+)((\/|:)?.*)/.exec(url);
return urlParts[1] + hostname + urlParts[3];
}
function randomNumber(max) {
return runtime.randomInt(max);
}
function randomString(length2) {
var result = [];
for (var i = 0; i < length2; i++) {
result.push(randomNumber(32).toString(32));
}
return result.join("");
}
var http_socket = http_socket_HTTPSocket;
var http_streaming_socket_hooks = {
getReceiveURL: function(url, session) {
return url.base + "/" + session + "/xhr_streaming" + url.queryString;
},
onHeartbeat: function(socket) {
socket.sendRaw("[]");
},
sendHeartbeat: function(socket) {
socket.sendRaw("[]");
},
onFinished: function(socket, status) {
socket.onClose(1006, "Connection interrupted (" + status + ")", false);
}
};
var http_streaming_socket = http_streaming_socket_hooks;
var http_polling_socket_hooks = {
getReceiveURL: function(url, session) {
return url.base + "/" + session + "/xhr" + url.queryString;
},
onHeartbeat: function() {
},
sendHeartbeat: function(socket) {
socket.sendRaw("[]");
},
onFinished: function(socket, status) {
if (status === 200) {
socket.reconnect();
} else {
socket.onClose(1006, "Connection interrupted (" + status + ")", false);
}
}
};
var http_polling_socket = http_polling_socket_hooks;
var http_xhr_request_hooks = {
getRequest: function(socket) {
var Constructor = runtime.getXHRAPI();
var xhr = new Constructor();
xhr.onreadystatechange = xhr.onprogress = function() {
switch (xhr.readyState) {
case 3:
if (xhr.responseText && xhr.responseText.length > 0) {
socket.onChunk(xhr.status, xhr.responseText);
}
break;
case 4:
if (xhr.responseText && xhr.responseText.length > 0) {
socket.onChunk(xhr.status, xhr.responseText);
}
socket.emit("finished", xhr.status);
socket.close();
break;
}
};
return xhr;
},
abortRequest: function(xhr) {
xhr.onreadystatechange = null;
xhr.abort();
}
};
var http_xhr_request = http_xhr_request_hooks;
var HTTP = {
createStreamingSocket(url) {
return this.createSocket(http_streaming_socket, url);
},
createPollingSocket(url) {
return this.createSocket(http_polling_socket, url);
},
createSocket(hooks, url) {
return new http_socket(hooks, url);
},
createXHR(method, url) {
return this.createRequest(http_xhr_request, method, url);
},
createRequest(hooks, method, url) {
return new http_request_HTTPRequest(hooks, method, url);
}
};
var http_http = HTTP;
http_http.createXDR = function(method, url) {
return this.createRequest(http_xdomain_request, method, url);
};
var web_http_http = http_http;
var Runtime = {
nextAuthCallbackID: 1,
auth_callbacks: {},
ScriptReceivers,
DependenciesReceivers,
getDefaultStrategy: default_strategy,
Transports: transports_transports,
transportConnectionInitializer: transport_connection_initializer,
HTTPFactory: web_http_http,
TimelineTransport: jsonp_timeline,
getXHRAPI() {
return window.XMLHttpRequest;
},
getWebSocketAPI() {
return window.WebSocket || window.MozWebSocket;
},
setup(PusherClass) {
window.Pusher = PusherClass;
var initializeOnDocumentBody = () => {
this.onDocumentBody(PusherClass.ready);
};
if (!window.JSON) {
Dependencies.load("json2", {}, initializeOnDocumentBody);
} else {
initializeOnDocumentBody();
}
},
getDocument() {
return document;
},
getProtocol() {
return this.getDocument().location.protocol;
},
getAuthorizers() {
return { ajax: xhr_auth, jsonp: jsonp_auth };
},
onDocumentBody(callback) {
if (document.body) {
callback();
} else {
setTimeout(() => {
this.onDocumentBody(callback);
}, 0);
}
},
createJSONPRequest(url, data2) {
return new jsonp_request_JSONPRequest(url, data2);
},
createScriptRequest(src) {
return new ScriptRequest(src);
},
getLocalStorage() {
try {
return window.localStorage;
} catch (e) {
return void 0;
}
},
createXHR() {
if (this.getXHRAPI()) {
return this.createXMLHttpRequest();
} else {
return this.createMicrosoftXHR();
}
},
createXMLHttpRequest() {
var Constructor = this.getXHRAPI();
return new Constructor();
},
createMicrosoftXHR() {
return new ActiveXObject("Microsoft.XMLHTTP");
},
getNetwork() {
return net_info_Network;
},
createWebSocket(url) {
var Constructor = this.getWebSocketAPI();
return new Constructor(url);
},
createSocketRequest(method, url) {
if (this.isXHRSupported()) {
return this.HTTPFactory.createXHR(method, url);
} else if (this.isXDRSupported(url.indexOf("https:") === 0)) {
return this.HTTPFactory.createXDR(method, url);
} else {
throw "Cross-origin HTTP requests are not supported";
}
},
isXHRSupported() {
var Constructor = this.getXHRAPI();
return Boolean(Constructor) && new Constructor().withCredentials !== void 0;
},
isXDRSupported(useTLS) {
var protocol = useTLS ? "https:" : "http:";
var documentProtocol = this.getProtocol();
return Boolean(window["XDomainRequest"]) && documentProtocol === protocol;
},
addUnloadListener(listener) {
if (window.addEventListener !== void 0) {
window.addEventListener("unload", listener, false);
} else if (window.attachEvent !== void 0) {
window.attachEvent("onunload", listener);
}
},
removeUnloadListener(listener) {
if (window.addEventListener !== void 0) {
window.removeEventListener("unload", listener, false);
} else if (window.detachEvent !== void 0) {
window.detachEvent("onunload", listener);
}
},
randomInt(max) {
const random2 = function() {
const crypto2 = window.crypto || window["msCrypto"];
const random3 = crypto2.getRandomValues(new Uint32Array(1))[0];
return random3 / Math.pow(2, 32);
};
return Math.floor(random2() * max);
}
};
var runtime = Runtime;
var TimelineLevel;
(function(TimelineLevel2) {
TimelineLevel2[TimelineLevel2["ERROR"] = 3] = "ERROR";
TimelineLevel2[TimelineLevel2["INFO"] = 6] = "INFO";
TimelineLevel2[TimelineLevel2["DEBUG"] = 7] = "DEBUG";
})(TimelineLevel || (TimelineLevel = {}));
var timeline_level = TimelineLevel;
class timeline_Timeline {
constructor(key2, session, options) {
this.key = key2;
this.session = session;
this.events = [];
this.options = options || {};
this.sent = 0;
this.uniqueID = 0;
}
log(level, event) {
if (level <= this.options.level) {
this.events.push(extend({}, event, { timestamp: util2.now() }));
if (this.options.limit && this.events.length > this.options.limit) {
this.events.shift();
}
}
}
error(event) {
this.log(timeline_level.ERROR, event);
}
info(event) {
this.log(timeline_level.INFO, event);
}
debug(event) {
this.log(timeline_level.DEBUG, event);
}
isEmpty() {
return this.events.length === 0;
}
send(sendfn, callback) {
var data2 = extend({
session: this.session,
bundle: this.sent + 1,
key: this.key,
lib: "js",
version: this.options.version,
cluster: this.options.cluster,
features: this.options.features,
timeline: this.events
}, this.options.params);
this.events = [];
sendfn(data2, (error, result) => {
if (!error) {
this.sent++;
}
if (callback) {
callback(error, result);
}
});
return true;
}
generateUniqueID() {
this.uniqueID++;
return this.uniqueID;
}
}
class transport_strategy_TransportStrategy {
constructor(name2, priority, transport, options) {
this.name = name2;
this.priority = priority;
this.transport = transport;
this.options = options || {};
}
isSupported() {
return this.transport.isSupported({
useTLS: this.options.useTLS
});
}
connect(minPriority, callback) {
if (!this.isSupported()) {
return failAttempt(new UnsupportedStrategy(), callback);
} else if (this.priority < minPriority) {
return failAttempt(new TransportPriorityTooLow(), callback);
}
var connected = false;
var transport = this.transport.createConnection(this.name, this.priority, this.options.key, this.options);
var handshake = null;
var onInitialized = function() {
transport.unbind("initialized", onInitialized);
transport.connect();
};
var onOpen = function() {
handshake = factory.createHandshake(transport, function(result) {
connected = true;
unbindListeners();
callback(null, result);
});
};
var onError = function(error) {
unbindListeners();
callback(error);
};
var onClosed = function() {
unbindListeners();
var serializedTransport;
serializedTransport = safeJSONStringify(transport);
callback(new TransportClosed(serializedTransport));
};
var unbindListeners = function() {
transport.unbind("initialized", onInitialized);
transport.unbind("open", onOpen);
transport.unbind("error", onError);
transport.unbind("closed", onClosed);
};
transport.bind("initialized", onInitialized);
transport.bind("open", onOpen);
transport.bind("error", onError);
transport.bind("closed", onClosed);
transport.initialize();
return {
abort: () => {
if (connected) {
return;
}
unbindListeners();
if (handshake) {
handshake.close();
} else {
transport.close();
}
},
forceMinPriority: (p) => {
if (connected) {
return;
}
if (this.priority < p) {
if (handshake) {
handshake.close();
} else {
transport.close();
}
}
}
};
}
}
function failAttempt(error, callback) {
util2.defer(function() {
callback(error);
});
return {
abort: function() {
},
forceMinPriority: function() {
}
};
}
const { Transports: strategy_builder_Transports } = runtime;
var strategy_builder_defineTransport = function(config2, name2, type, priority, options, manager) {
var transportClass = strategy_builder_Transports[type];
if (!transportClass) {
throw new UnsupportedTransport(type);
}
var enabled = (!config2.enabledTransports || arrayIndexOf(config2.enabledTransports, name2) !== -1) && (!config2.disabledTransports || arrayIndexOf(config2.disabledTransports, name2) === -1);
var transport;
if (enabled) {
options = Object.assign({ ignoreNullOrigin: config2.ignoreNullOrigin }, options);
transport = new transport_strategy_TransportStrategy(name2, priority, manager ? manager.getAssistant(transportClass) : transportClass, options);
} else {
transport = strategy_builder_UnsupportedStrategy;
}
return transport;
};
var strategy_builder_UnsupportedStrategy = {
isSupported: function() {
return false;
},
connect: function(_, callback) {
var deferred = util2.defer(function() {
callback(new UnsupportedStrategy());
});
return {
abort: function() {
deferred.ensureAborted();
},
forceMinPriority: function() {
}
};
}
};
function validateOptions(options) {
if (options == null) {
throw "You must pass an options object";
}
if (options.cluster == null) {
throw "Options object must provide a cluster";
}
if ("disableStats" in options) {
logger.warn("The disableStats option is deprecated in favor of enableStats");
}
}
const composeChannelQuery = (params, authOptions) => {
var query = "socket_id=" + encodeURIComponent(params.socketId);
for (var key2 in authOptions.params) {
query += "&" + encodeURIComponent(key2) + "=" + encodeURIComponent(authOptions.params[key2]);
}
if (authOptions.paramsProvider != null) {
let dynamicParams = authOptions.paramsProvider();
for (var key2 in dynamicParams) {
query += "&" + encodeURIComponent(key2) + "=" + encodeURIComponent(dynamicParams[key2]);
}
}
return query;
};
const UserAuthenticator = (authOptions) => {
if (typeof runtime.getAuthorizers()[authOptions.transport] === "undefined") {
throw `'${authOptions.transport}' is not a recognized auth transport`;
}
return (params, callback) => {
const query = composeChannelQuery(params, authOptions);
runtime.getAuthorizers()[authOptions.transport](runtime, query, authOptions, AuthRequestType.UserAuthentication, callback);
};
};
var user_authenticator = UserAuthenticator;
const channel_authorizer_composeChannelQuery = (params, authOptions) => {
var query = "socket_id=" + encodeURIComponent(params.socketId);
query += "&channel_name=" + encodeURIComponent(params.channelName);
for (var key2 in authOptions.params) {
query += "&" + encodeURIComponent(key2) + "=" + encodeURIComponent(authOptions.params[key2]);
}
if (authOptions.paramsProvider != null) {
let dynamicParams = authOptions.paramsProvider();
for (var key2 in dynamicParams) {
query += "&" + encodeURIComponent(key2) + "=" + encodeURIComponent(dynamicParams[key2]);
}
}
return query;
};
const ChannelAuthorizer = (authOptions) => {
if (typeof runtime.getAuthorizers()[authOptions.transport] === "undefined") {
throw `'${authOptions.transport}' is not a recognized auth transport`;
}
return (params, callback) => {
const query = channel_authorizer_composeChannelQuery(params, authOptions);
runtime.getAuthorizers()[authOptions.transport](runtime, query, authOptions, AuthRequestType.ChannelAuthorization, callback);
};
};
var channel_authorizer = ChannelAuthorizer;
const ChannelAuthorizerProxy = (pusher, authOptions, channelAuthorizerGenerator) => {
const deprecatedAuthorizerOptions = {
authTransport: authOptions.transport,
authEndpoint: authOptions.endpoint,
auth: {
params: authOptions.params,
headers: authOptions.headers
}
};
return (params, callback) => {
const channel = pusher.channel(params.channelName);
const channelAuthorizer = channelAuthorizerGenerator(channel, deprecatedAuthorizerOptions);
channelAuthorizer.authorize(params.socketId, callback);
};
};
function getConfig(opts, pusher) {
let config2 = {
activityTimeout: opts.activityTimeout || defaults.activityTimeout,
cluster: opts.cluster,
httpPath: opts.httpPath || defaults.httpPath,
httpPort: opts.httpPort || defaults.httpPort,
httpsPort: opts.httpsPort || defaults.httpsPort,
pongTimeout: opts.pongTimeout || defaults.pongTimeout,
statsHost: opts.statsHost || defaults.stats_host,
unavailableTimeout: opts.unavailableTimeout || defaults.unavailableTimeout,
wsPath: opts.wsPath || defaults.wsPath,
wsPort: opts.wsPort || defaults.wsPort,
wssPort: opts.wssPort || defaults.wssPort,
enableStats: getEnableStatsConfig(opts),
httpHost: getHttpHost(opts),
useTLS: shouldUseTLS(opts),
wsHost: getWebsocketHost(opts),
userAuthenticator: buildUserAuthenticator(opts),
channelAuthorizer: buildChannelAuthorizer(opts, pusher)
};
if ("disabledTransports" in opts)
config2.disabledTransports = opts.disabledTransports;
if ("enabledTransports" in opts)
config2.enabledTransports = opts.enabledTransports;
if ("ignoreNullOrigin" in opts)
config2.ignoreNullOrigin = opts.ignoreNullOrigin;
if ("timelineParams" in opts)
config2.timelineParams = opts.timelineParams;
if ("nacl" in opts) {
config2.nacl = opts.nacl;
}
return config2;
}
function getHttpHost(opts) {
if (opts.httpHost) {
return opts.httpHost;
}
if (opts.cluster) {
return `sockjs-${opts.cluster}.pusher.com`;
}
return defaults.httpHost;
}
function getWebsocketHost(opts) {
if (opts.wsHost) {
return opts.wsHost;
}
return getWebsocketHostFromCluster(opts.cluster);
}
function getWebsocketHostFromCluster(cluster) {
return `ws-${cluster}.pusher.com`;
}
function shouldUseTLS(opts) {
if (runtime.getProtocol() === "https:") {
return true;
} else if (opts.forceTLS === false) {
return false;
}
return true;
}
function getEnableStatsConfig(opts) {
if ("enableStats" in opts) {
return opts.enableStats;
}
if ("disableStats" in opts) {
return !opts.disableStats;
}
return false;
}
function buildUserAuthenticator(opts) {
const userAuthentication = Object.assign(Object.assign({}, defaults.userAuthentication), opts.userAuthentication);
if ("customHandler" in userAuthentication && userAuthentication["customHandler"] != null) {
return userAuthentication["customHandler"];
}
return user_authenticator(userAuthentication);
}
function buildChannelAuth(opts, pusher) {
let channelAuthorization;
if ("channelAuthorization" in opts) {
channelAuthorization = Object.assign(Object.assign({}, defaults.channelAuthorization), opts.channelAuthorization);
} else {
channelAuthorization = {
transport: opts.authTransport || defaults.authTransport,
endpoint: opts.authEndpoint || defaults.authEndpoint
};
if ("auth" in opts) {
if ("params" in opts.auth)
channelAuthorization.params = opts.auth.params;
if ("headers" in opts.auth)
channelAuthorization.headers = opts.auth.headers;
}
if ("authorizer" in opts)
channelAuthorization.customHandler = ChannelAuthorizerProxy(pusher, channelAuthorization, opts.authorizer);
}
return channelAuthorization;
}
function buildChannelAuthorizer(opts, pusher) {
const channelAuthorization = buildChannelAuth(opts, pusher);
if ("customHandler" in channelAuthorization && channelAuthorization["customHandler"] != null) {
return channelAuthorization["customHandler"];
}
return channel_authorizer(channelAuthorization);
}
class watchlist_WatchlistFacade extends dispatcher_Dispatcher {
constructor(pusher) {
super(function(eventName, data2) {
logger.debug(`No callbacks on watchlist events for ${eventName}`);
});
this.pusher = pusher;
this.bindWatchlistInternalEvent();
}
handleEvent(pusherEvent) {
pusherEvent.data.events.forEach((watchlistEvent) => {
this.emit(watchlistEvent.name, watchlistEvent);
});
}
bindWatchlistInternalEvent() {
this.pusher.connection.bind("message", (pusherEvent) => {
var eventName = pusherEvent.event;
if (eventName === "pusher_internal:watchlist_events") {
this.handleEvent(pusherEvent);
}
});
}
}
function flatPromise() {
let resolve, reject;
const promise = new Promise((res, rej) => {
resolve = res;
reject = rej;
});
return { promise, resolve, reject };
}
var flat_promise = flatPromise;
class user_UserFacade extends dispatcher_Dispatcher {
constructor(pusher) {
super(function(eventName, data2) {
logger.debug("No callbacks on user for " + eventName);
});
this.signin_requested = false;
this.user_data = null;
this.serverToUserChannel = null;
this.signinDonePromise = null;
this._signinDoneResolve = null;
this._onAuthorize = (err, authData) => {
if (err) {
logger.warn(`Error during signin: ${err}`);
this._cleanup();
return;
}
this.pusher.send_event("pusher:signin", {
auth: authData.auth,
user_data: authData.user_data
});
};
this.pusher = pusher;
this.pusher.connection.bind("state_change", ({ previous, current }) => {
if (previous !== "connected" && current === "connected") {
this._signin();
}
if (previous === "connected" && current !== "connected") {
this._cleanup();
this._newSigninPromiseIfNeeded();
}
});
this.watchlist = new watchlist_WatchlistFacade(pusher);
this.pusher.connection.bind("message", (event) => {
var eventName = event.event;
if (eventName === "pusher:signin_success") {
this._onSigninSuccess(event.data);
}
if (this.serverToUserChannel && this.serverToUserChannel.name === event.channel) {
this.serverToUserChannel.handleEvent(event);
}
});
}
signin() {
if (this.signin_requested) {
return;
}
this.signin_requested = true;
this._signin();
}
_signin() {
if (!this.signin_requested) {
return;
}
this._newSigninPromiseIfNeeded();
if (this.pusher.connection.state !== "connected") {
return;
}
this.pusher.config.userAuthenticator({
socketId: this.pusher.connection.socket_id
}, this._onAuthorize);
}
_onSigninSuccess(data2) {
try {
this.user_data = JSON.parse(data2.user_data);
} catch (e) {
logger.error(`Failed parsing user data after signin: ${data2.user_data}`);
this._cleanup();
return;
}
if (typeof this.user_data.id !== "string" || this.user_data.id === "") {
logger.error(`user_data doesn't contain an id. user_data: ${this.user_data}`);
this._cleanup();
return;
}
this._signinDoneResolve();
this._subscribeChannels();
}
_subscribeChannels() {
const ensure_subscribed = (channel) => {
if (channel.subscriptionPending && channel.subscriptionCancelled) {
channel.reinstateSubscription();
} else if (!channel.subscriptionPending && this.pusher.connection.state === "connected") {
channel.subscribe();
}
};
this.serverToUserChannel = new channel_Channel(`#server-to-user-${this.user_data.id}`, this.pusher);
this.serverToUserChannel.bind_global((eventName, data2) => {
if (eventName.indexOf("pusher_internal:") === 0 || eventName.indexOf("pusher:") === 0) {
return;
}
this.emit(eventName, data2);
});
ensure_subscribed(this.serverToUserChannel);
}
_cleanup() {
this.user_data = null;
if (this.serverToUserChannel) {
this.serverToUserChannel.unbind_all();
this.serverToUserChannel.disconnect();
this.serverToUserChannel = null;
}
if (this.signin_requested) {
this._signinDoneResolve();
}
}
_newSigninPromiseIfNeeded() {
if (!this.signin_requested) {
return;
}
if (this.signinDonePromise && !this.signinDonePromise.done) {
return;
}
const { promise, resolve, reject: _ } = flat_promise();
promise.done = false;
const setDone = () => {
promise.done = true;
};
promise.then(setDone).catch(setDone);
this.signinDonePromise = promise;
this._signinDoneResolve = resolve;
}
}
class pusher_Pusher {
static ready() {
pusher_Pusher.isReady = true;
for (var i = 0, l2 = pusher_Pusher.instances.length; i < l2; i++) {
pusher_Pusher.instances[i].connect();
}
}
static getClientFeatures() {
return keys(filterObject({ ws: runtime.Transports.ws }, function(t) {
return t.isSupported({});
}));
}
constructor(app_key, options) {
checkAppKey(app_key);
validateOptions(options);
this.key = app_key;
this.config = getConfig(options, this);
this.channels = factory.createChannels();
this.global_emitter = new dispatcher_Dispatcher();
this.sessionID = runtime.randomInt(1e9);
this.timeline = new timeline_Timeline(this.key, this.sessionID, {
cluster: this.config.cluster,
features: pusher_Pusher.getClientFeatures(),
params: this.config.timelineParams || {},
limit: 50,
level: timeline_level.INFO,
version: defaults.VERSION
});
if (this.config.enableStats) {
this.timelineSender = factory.createTimelineSender(this.timeline, {
host: this.config.statsHost,
path: "/timeline/v2/" + runtime.TimelineTransport.name
});
}
var getStrategy = (options2) => {
return runtime.getDefaultStrategy(this.config, options2, strategy_builder_defineTransport);
};
this.connection = factory.createConnectionManager(this.key, {
getStrategy,
timeline: this.timeline,
activityTimeout: this.config.activityTimeout,
pongTimeout: this.config.pongTimeout,
unavailableTimeout: this.config.unavailableTimeout,
useTLS: Boolean(this.config.useTLS)
});
this.connection.bind("connected", () => {
this.subscribeAll();
if (this.timelineSender) {
this.timelineSender.send(this.connection.isUsingTLS());
}
});
this.connection.bind("message", (event) => {
var eventName = event.event;
var internal = eventName.indexOf("pusher_internal:") === 0;
if (event.channel) {
var channel = this.channel(event.channel);
if (channel) {
channel.handleEvent(event);
}
}
if (!internal) {
this.global_emitter.emit(event.event, event.data);
}
});
this.connection.bind("connecting", () => {
this.channels.disconnect();
});
this.connection.bind("disconnected", () => {
this.channels.disconnect();
});
this.connection.bind("error", (err) => {
logger.warn(err);
});
pusher_Pusher.instances.push(this);
this.timeline.info({ instances: pusher_Pusher.instances.length });
this.user = new user_UserFacade(this);
if (pusher_Pusher.isReady) {
this.connect();
}
}
channel(name2) {
return this.channels.find(name2);
}
allChannels() {
return this.channels.all();
}
connect() {
this.connection.connect();
if (this.timelineSender) {
if (!this.timelineSenderTimer) {
var usingTLS = this.connection.isUsingTLS();
var timelineSender = this.timelineSender;
this.timelineSenderTimer = new timers_PeriodicTimer(6e4, function() {
timelineSender.send(usingTLS);
});
}
}
}
disconnect() {
this.connection.disconnect();
if (this.timelineSenderTimer) {
this.timelineSenderTimer.ensureAborted();
this.timelineSenderTimer = null;
}
}
bind(event_name, callback, context2) {
this.global_emitter.bind(event_name, callback, context2);
return this;
}
unbind(event_name, callback, context2) {
this.global_emitter.unbind(event_name, callback, context2);
return this;
}
bind_global(callback) {
this.global_emitter.bind_global(callback);
return this;
}
unbind_global(callback) {
this.global_emitter.unbind_global(callback);
return this;
}
unbind_all(callback) {
this.global_emitter.unbind_all();
return this;
}
subscribeAll() {
var channelName;
for (channelName in this.channels.channels) {
if (this.channels.channels.hasOwnProperty(channelName)) {
this.subscribe(channelName);
}
}
}
subscribe(channel_name) {
var channel = this.channels.add(channel_name, this);
if (channel.subscriptionPending && channel.subscriptionCancelled) {
channel.reinstateSubscription();
} else if (!channel.subscriptionPending && this.connection.state === "connected") {
channel.subscribe();
}
return channel;
}
unsubscribe(channel_name) {
var channel = this.channels.find(channel_name);
if (channel && channel.subscriptionPending) {
channel.cancelSubscription();
} else {
channel = this.channels.remove(channel_name);
if (channel && channel.subscribed) {
channel.unsubscribe();
}
}
}
send_event(event_name, data2, channel) {
return this.connection.send_event(event_name, data2, channel);
}
shouldUseTLS() {
return this.config.useTLS;
}
signin() {
this.user.signin();
}
}
pusher_Pusher.instances = [];
pusher_Pusher.isReady = false;
pusher_Pusher.logToConsole = false;
pusher_Pusher.Runtime = runtime;
pusher_Pusher.ScriptReceivers = runtime.ScriptReceivers;
pusher_Pusher.DependenciesReceivers = runtime.DependenciesReceivers;
pusher_Pusher.auth_callbacks = runtime.auth_callbacks;
var core_pusher = __webpack_exports__["default"] = pusher_Pusher;
function checkAppKey(key2) {
if (key2 === null || key2 === void 0) {
throw "You must pass your app key when you instantiate Pusher.";
}
}
runtime.setup(pusher_Pusher);
}
/******/
])
);
});
}
});
// node_modules/node-forge/lib/forge.js
var require_forge = __commonJS({
"node_modules/node-forge/lib/forge.js"(exports2, module2) {
"use strict";
module2.exports = {
// default options
options: {
usePureJavaScript: false
}
};
}
});
// node_modules/node-forge/lib/baseN.js
var require_baseN = __commonJS({
"node_modules/node-forge/lib/baseN.js"(exports2, module2) {
"use strict";
var api = {};
module2.exports = api;
var _reverseAlphabets = {};
api.encode = function(input2, alphabet, maxline) {
if (typeof alphabet !== "string") {
throw new TypeError('"alphabet" must be a string.');
}
if (maxline !== void 0 && typeof maxline !== "number") {
throw new TypeError('"maxline" must be a number.');
}
var output = "";
if (!(input2 instanceof Uint8Array)) {
output = _encodeWithByteBuffer(input2, alphabet);
} else {
var i = 0;
var base = alphabet.length;
var first2 = alphabet.charAt(0);
var digits = [0];
for (i = 0; i < input2.length; ++i) {
for (var j = 0, carry = input2[i]; j < digits.length; ++j) {
carry += digits[j] << 8;
digits[j] = carry % base;
carry = carry / base | 0;
}
while (carry > 0) {
digits.push(carry % base);
carry = carry / base | 0;
}
}
for (i = 0; input2[i] === 0 && i < input2.length - 1; ++i) {
output += first2;
}
for (i = digits.length - 1; i >= 0; --i) {
output += alphabet[digits[i]];
}
}
if (maxline) {
var regex = new RegExp(".{1," + maxline + "}", "g");
output = output.match(regex).join("\r\n");
}
return output;
};
api.decode = function(input2, alphabet) {
if (typeof input2 !== "string") {
throw new TypeError('"input" must be a string.');
}
if (typeof alphabet !== "string") {
throw new TypeError('"alphabet" must be a string.');
}
var table = _reverseAlphabets[alphabet];
if (!table) {
table = _reverseAlphabets[alphabet] = [];
for (var i = 0; i < alphabet.length; ++i) {
table[alphabet.charCodeAt(i)] = i;
}
}
input2 = input2.replace(/\s/g, "");
var base = alphabet.length;
var first2 = alphabet.charAt(0);
var bytes = [0];
for (var i = 0; i < input2.length; i++) {
var value2 = table[input2.charCodeAt(i)];
if (value2 === void 0) {
return;
}
for (var j = 0, carry = value2; j < bytes.length; ++j) {
carry += bytes[j] * base;
bytes[j] = carry & 255;
carry >>= 8;
}
while (carry > 0) {
bytes.push(carry & 255);
carry >>= 8;
}
}
for (var k = 0; input2[k] === first2 && k < input2.length - 1; ++k) {
bytes.push(0);
}
if (typeof Buffer !== "undefined") {
return Buffer.from(bytes.reverse());
}
return new Uint8Array(bytes.reverse());
};
function _encodeWithByteBuffer(input2, alphabet) {
var i = 0;
var base = alphabet.length;
var first2 = alphabet.charAt(0);
var digits = [0];
for (i = 0; i < input2.length(); ++i) {
for (var j = 0, carry = input2.at(i); j < digits.length; ++j) {
carry += digits[j] << 8;
digits[j] = carry % base;
carry = carry / base | 0;
}
while (carry > 0) {
digits.push(carry % base);
carry = carry / base | 0;
}
}
var output = "";
for (i = 0; input2.at(i) === 0 && i < input2.length() - 1; ++i) {
output += first2;
}
for (i = digits.length - 1; i >= 0; --i) {
output += alphabet[digits[i]];
}
return output;
}
}
});
// node_modules/node-forge/lib/util.js
var require_util = __commonJS({
"node_modules/node-forge/lib/util.js"(exports2, module2) {
"use strict";
var forge2 = require_forge();
var baseN = require_baseN();
var util2 = module2.exports = forge2.util = forge2.util || {};
(function() {
if (typeof process !== "undefined" && process.nextTick && !process.browser) {
util2.nextTick = process.nextTick;
if (typeof setImmediate === "function") {
util2.setImmediate = setImmediate;
} else {
util2.setImmediate = util2.nextTick;
}
return;
}
if (typeof setImmediate === "function") {
util2.setImmediate = function() {
return setImmediate.apply(void 0, arguments);
};
util2.nextTick = function(callback) {
return setImmediate(callback);
};
return;
}
util2.setImmediate = function(callback) {
setTimeout(callback, 0);
};
if (typeof window !== "undefined" && typeof window.postMessage === "function") {
let handler2 = function(event) {
if (event.source === window && event.data === msg) {
event.stopPropagation();
var copy = callbacks.slice();
callbacks.length = 0;
copy.forEach(function(callback) {
callback();
});
}
};
var handler = handler2;
var msg = "forge.setImmediate";
var callbacks = [];
util2.setImmediate = function(callback) {
callbacks.push(callback);
if (callbacks.length === 1) {
window.postMessage(msg, "*");
}
};
window.addEventListener("message", handler2, true);
}
if (typeof MutationObserver !== "undefined") {
var now = Date.now();
var attr = true;
var div2 = document.createElement("div");
var callbacks = [];
new MutationObserver(function() {
var copy = callbacks.slice();
callbacks.length = 0;
copy.forEach(function(callback) {
callback();
});
}).observe(div2, { attributes: true });
var oldSetImmediate = util2.setImmediate;
util2.setImmediate = function(callback) {
if (Date.now() - now > 15) {
now = Date.now();
oldSetImmediate(callback);
} else {
callbacks.push(callback);
if (callbacks.length === 1) {
div2.setAttribute("a", attr = !attr);
}
}
};
}
util2.nextTick = util2.setImmediate;
})();
util2.isNodejs = typeof process !== "undefined" && process.versions && process.versions.node;
util2.globalScope = function() {
if (util2.isNodejs) {
return global;
}
return typeof self === "undefined" ? window : self;
}();
util2.isArray = Array.isArray || function(x) {
return Object.prototype.toString.call(x) === "[object Array]";
};
util2.isArrayBuffer = function(x) {
return typeof ArrayBuffer !== "undefined" && x instanceof ArrayBuffer;
};
util2.isArrayBufferView = function(x) {
return x && util2.isArrayBuffer(x.buffer) && x.byteLength !== void 0;
};
function _checkBitsParam(n) {
if (!(n === 8 || n === 16 || n === 24 || n === 32)) {
throw new Error("Only 8, 16, 24, or 32 bits supported: " + n);
}
}
util2.ByteBuffer = ByteStringBuffer;
function ByteStringBuffer(b) {
this.data = "";
this.read = 0;
if (typeof b === "string") {
this.data = b;
} else if (util2.isArrayBuffer(b) || util2.isArrayBufferView(b)) {
if (typeof Buffer !== "undefined" && b instanceof Buffer) {
this.data = b.toString("binary");
} else {
var arr = new Uint8Array(b);
try {
this.data = String.fromCharCode.apply(null, arr);
} catch (e) {
for (var i = 0; i < arr.length; ++i) {
this.putByte(arr[i]);
}
}
}
} else if (b instanceof ByteStringBuffer || typeof b === "object" && typeof b.data === "string" && typeof b.read === "number") {
this.data = b.data;
this.read = b.read;
}
this._constructedStringLength = 0;
}
util2.ByteStringBuffer = ByteStringBuffer;
var _MAX_CONSTRUCTED_STRING_LENGTH = 4096;
util2.ByteStringBuffer.prototype._optimizeConstructedString = function(x) {
this._constructedStringLength += x;
if (this._constructedStringLength > _MAX_CONSTRUCTED_STRING_LENGTH) {
this.data.substr(0, 1);
this._constructedStringLength = 0;
}
};
util2.ByteStringBuffer.prototype.length = function() {
return this.data.length - this.read;
};
util2.ByteStringBuffer.prototype.isEmpty = function() {
return this.length() <= 0;
};
util2.ByteStringBuffer.prototype.putByte = function(b) {
return this.putBytes(String.fromCharCode(b));
};
util2.ByteStringBuffer.prototype.fillWithByte = function(b, n) {
b = String.fromCharCode(b);
var d = this.data;
while (n > 0) {
if (n & 1) {
d += b;
}
n >>>= 1;
if (n > 0) {
b += b;
}
}
this.data = d;
this._optimizeConstructedString(n);
return this;
};
util2.ByteStringBuffer.prototype.putBytes = function(bytes) {
this.data += bytes;
this._optimizeConstructedString(bytes.length);
return this;
};
util2.ByteStringBuffer.prototype.putString = function(str) {
return this.putBytes(util2.encodeUtf8(str));
};
util2.ByteStringBuffer.prototype.putInt16 = function(i) {
return this.putBytes(
String.fromCharCode(i >> 8 & 255) + String.fromCharCode(i & 255)
);
};
util2.ByteStringBuffer.prototype.putInt24 = function(i) {
return this.putBytes(
String.fromCharCode(i >> 16 & 255) + String.fromCharCode(i >> 8 & 255) + String.fromCharCode(i & 255)
);
};
util2.ByteStringBuffer.prototype.putInt32 = function(i) {
return this.putBytes(
String.fromCharCode(i >> 24 & 255) + String.fromCharCode(i >> 16 & 255) + String.fromCharCode(i >> 8 & 255) + String.fromCharCode(i & 255)
);
};
util2.ByteStringBuffer.prototype.putInt16Le = function(i) {
return this.putBytes(
String.fromCharCode(i & 255) + String.fromCharCode(i >> 8 & 255)
);
};
util2.ByteStringBuffer.prototype.putInt24Le = function(i) {
return this.putBytes(
String.fromCharCode(i & 255) + String.fromCharCode(i >> 8 & 255) + String.fromCharCode(i >> 16 & 255)
);
};
util2.ByteStringBuffer.prototype.putInt32Le = function(i) {
return this.putBytes(
String.fromCharCode(i & 255) + String.fromCharCode(i >> 8 & 255) + String.fromCharCode(i >> 16 & 255) + String.fromCharCode(i >> 24 & 255)
);
};
util2.ByteStringBuffer.prototype.putInt = function(i, n) {
_checkBitsParam(n);
var bytes = "";
do {
n -= 8;
bytes += String.fromCharCode(i >> n & 255);
} while (n > 0);
return this.putBytes(bytes);
};
util2.ByteStringBuffer.prototype.putSignedInt = function(i, n) {
if (i < 0) {
i += 2 << n - 1;
}
return this.putInt(i, n);
};
util2.ByteStringBuffer.prototype.putBuffer = function(buffer) {
return this.putBytes(buffer.getBytes());
};
util2.ByteStringBuffer.prototype.getByte = function() {
return this.data.charCodeAt(this.read++);
};
util2.ByteStringBuffer.prototype.getInt16 = function() {
var rval = this.data.charCodeAt(this.read) << 8 ^ this.data.charCodeAt(this.read + 1);
this.read += 2;
return rval;
};
util2.ByteStringBuffer.prototype.getInt24 = function() {
var rval = this.data.charCodeAt(this.read) << 16 ^ this.data.charCodeAt(this.read + 1) << 8 ^ this.data.charCodeAt(this.read + 2);
this.read += 3;
return rval;
};
util2.ByteStringBuffer.prototype.getInt32 = function() {
var rval = this.data.charCodeAt(this.read) << 24 ^ this.data.charCodeAt(this.read + 1) << 16 ^ this.data.charCodeAt(this.read + 2) << 8 ^ this.data.charCodeAt(this.read + 3);
this.read += 4;
return rval;
};
util2.ByteStringBuffer.prototype.getInt16Le = function() {
var rval = this.data.charCodeAt(this.read) ^ this.data.charCodeAt(this.read + 1) << 8;
this.read += 2;
return rval;
};
util2.ByteStringBuffer.prototype.getInt24Le = function() {
var rval = this.data.charCodeAt(this.read) ^ this.data.charCodeAt(this.read + 1) << 8 ^ this.data.charCodeAt(this.read + 2) << 16;
this.read += 3;
return rval;
};
util2.ByteStringBuffer.prototype.getInt32Le = function() {
var rval = this.data.charCodeAt(this.read) ^ this.data.charCodeAt(this.read + 1) << 8 ^ this.data.charCodeAt(this.read + 2) << 16 ^ this.data.charCodeAt(this.read + 3) << 24;
this.read += 4;
return rval;
};
util2.ByteStringBuffer.prototype.getInt = function(n) {
_checkBitsParam(n);
var rval = 0;
do {
rval = (rval << 8) + this.data.charCodeAt(this.read++);
n -= 8;
} while (n > 0);
return rval;
};
util2.ByteStringBuffer.prototype.getSignedInt = function(n) {
var x = this.getInt(n);
var max = 2 << n - 2;
if (x >= max) {
x -= max << 1;
}
return x;
};
util2.ByteStringBuffer.prototype.getBytes = function(count) {
var rval;
if (count) {
count = Math.min(this.length(), count);
rval = this.data.slice(this.read, this.read + count);
this.read += count;
} else if (count === 0) {
rval = "";
} else {
rval = this.read === 0 ? this.data : this.data.slice(this.read);
this.clear();
}
return rval;
};
util2.ByteStringBuffer.prototype.bytes = function(count) {
return typeof count === "undefined" ? this.data.slice(this.read) : this.data.slice(this.read, this.read + count);
};
util2.ByteStringBuffer.prototype.at = function(i) {
return this.data.charCodeAt(this.read + i);
};
util2.ByteStringBuffer.prototype.setAt = function(i, b) {
this.data = this.data.substr(0, this.read + i) + String.fromCharCode(b) + this.data.substr(this.read + i + 1);
return this;
};
util2.ByteStringBuffer.prototype.last = function() {
return this.data.charCodeAt(this.data.length - 1);
};
util2.ByteStringBuffer.prototype.copy = function() {
var c = util2.createBuffer(this.data);
c.read = this.read;
return c;
};
util2.ByteStringBuffer.prototype.compact = function() {
if (this.read > 0) {
this.data = this.data.slice(this.read);
this.read = 0;
}
return this;
};
util2.ByteStringBuffer.prototype.clear = function() {
this.data = "";
this.read = 0;
return this;
};
util2.ByteStringBuffer.prototype.truncate = function(count) {
var len = Math.max(0, this.length() - count);
this.data = this.data.substr(this.read, len);
this.read = 0;
return this;
};
util2.ByteStringBuffer.prototype.toHex = function() {
var rval = "";
for (var i = this.read; i < this.data.length; ++i) {
var b = this.data.charCodeAt(i);
if (b < 16) {
rval += "0";
}
rval += b.toString(16);
}
return rval;
};
util2.ByteStringBuffer.prototype.toString = function() {
return util2.decodeUtf8(this.bytes());
};
function DataBuffer(b, options) {
options = options || {};
this.read = options.readOffset || 0;
this.growSize = options.growSize || 1024;
var isArrayBuffer2 = util2.isArrayBuffer(b);
var isArrayBufferView = util2.isArrayBufferView(b);
if (isArrayBuffer2 || isArrayBufferView) {
if (isArrayBuffer2) {
this.data = new DataView(b);
} else {
this.data = new DataView(b.buffer, b.byteOffset, b.byteLength);
}
this.write = "writeOffset" in options ? options.writeOffset : this.data.byteLength;
return;
}
this.data = new DataView(new ArrayBuffer(0));
this.write = 0;
if (b !== null && b !== void 0) {
this.putBytes(b);
}
if ("writeOffset" in options) {
this.write = options.writeOffset;
}
}
util2.DataBuffer = DataBuffer;
util2.DataBuffer.prototype.length = function() {
return this.write - this.read;
};
util2.DataBuffer.prototype.isEmpty = function() {
return this.length() <= 0;
};
util2.DataBuffer.prototype.accommodate = function(amount, growSize) {
if (this.length() >= amount) {
return this;
}
growSize = Math.max(growSize || this.growSize, amount);
var src = new Uint8Array(
this.data.buffer,
this.data.byteOffset,
this.data.byteLength
);
var dst = new Uint8Array(this.length() + growSize);
dst.set(src);
this.data = new DataView(dst.buffer);
return this;
};
util2.DataBuffer.prototype.putByte = function(b) {
this.accommodate(1);
this.data.setUint8(this.write++, b);
return this;
};
util2.DataBuffer.prototype.fillWithByte = function(b, n) {
this.accommodate(n);
for (var i = 0; i < n; ++i) {
this.data.setUint8(b);
}
return this;
};
util2.DataBuffer.prototype.putBytes = function(bytes, encoding) {
if (util2.isArrayBufferView(bytes)) {
var src = new Uint8Array(bytes.buffer, bytes.byteOffset, bytes.byteLength);
var len = src.byteLength - src.byteOffset;
this.accommodate(len);
var dst = new Uint8Array(this.data.buffer, this.write);
dst.set(src);
this.write += len;
return this;
}
if (util2.isArrayBuffer(bytes)) {
var src = new Uint8Array(bytes);
this.accommodate(src.byteLength);
var dst = new Uint8Array(this.data.buffer);
dst.set(src, this.write);
this.write += src.byteLength;
return this;
}
if (bytes instanceof util2.DataBuffer || typeof bytes === "object" && typeof bytes.read === "number" && typeof bytes.write === "number" && util2.isArrayBufferView(bytes.data)) {
var src = new Uint8Array(bytes.data.byteLength, bytes.read, bytes.length());
this.accommodate(src.byteLength);
var dst = new Uint8Array(bytes.data.byteLength, this.write);
dst.set(src);
this.write += src.byteLength;
return this;
}
if (bytes instanceof util2.ByteStringBuffer) {
bytes = bytes.data;
encoding = "binary";
}
encoding = encoding || "binary";
if (typeof bytes === "string") {
var view;
if (encoding === "hex") {
this.accommodate(Math.ceil(bytes.length / 2));
view = new Uint8Array(this.data.buffer, this.write);
this.write += util2.binary.hex.decode(bytes, view, this.write);
return this;
}
if (encoding === "base64") {
this.accommodate(Math.ceil(bytes.length / 4) * 3);
view = new Uint8Array(this.data.buffer, this.write);
this.write += util2.binary.base64.decode(bytes, view, this.write);
return this;
}
if (encoding === "utf8") {
bytes = util2.encodeUtf8(bytes);
encoding = "binary";
}
if (encoding === "binary" || encoding === "raw") {
this.accommodate(bytes.length);
view = new Uint8Array(this.data.buffer, this.write);
this.write += util2.binary.raw.decode(view);
return this;
}
if (encoding === "utf16") {
this.accommodate(bytes.length * 2);
view = new Uint16Array(this.data.buffer, this.write);
this.write += util2.text.utf16.encode(view);
return this;
}
throw new Error("Invalid encoding: " + encoding);
}
throw Error("Invalid parameter: " + bytes);
};
util2.DataBuffer.prototype.putBuffer = function(buffer) {
this.putBytes(buffer);
buffer.clear();
return this;
};
util2.DataBuffer.prototype.putString = function(str) {
return this.putBytes(str, "utf16");
};
util2.DataBuffer.prototype.putInt16 = function(i) {
this.accommodate(2);
this.data.setInt16(this.write, i);
this.write += 2;
return this;
};
util2.DataBuffer.prototype.putInt24 = function(i) {
this.accommodate(3);
this.data.setInt16(this.write, i >> 8 & 65535);
this.data.setInt8(this.write, i >> 16 & 255);
this.write += 3;
return this;
};
util2.DataBuffer.prototype.putInt32 = function(i) {
this.accommodate(4);
this.data.setInt32(this.write, i);
this.write += 4;
return this;
};
util2.DataBuffer.prototype.putInt16Le = function(i) {
this.accommodate(2);
this.data.setInt16(this.write, i, true);
this.write += 2;
return this;
};
util2.DataBuffer.prototype.putInt24Le = function(i) {
this.accommodate(3);
this.data.setInt8(this.write, i >> 16 & 255);
this.data.setInt16(this.write, i >> 8 & 65535, true);
this.write += 3;
return this;
};
util2.DataBuffer.prototype.putInt32Le = function(i) {
this.accommodate(4);
this.data.setInt32(this.write, i, true);
this.write += 4;
return this;
};
util2.DataBuffer.prototype.putInt = function(i, n) {
_checkBitsParam(n);
this.accommodate(n / 8);
do {
n -= 8;
this.data.setInt8(this.write++, i >> n & 255);
} while (n > 0);
return this;
};
util2.DataBuffer.prototype.putSignedInt = function(i, n) {
_checkBitsParam(n);
this.accommodate(n / 8);
if (i < 0) {
i += 2 << n - 1;
}
return this.putInt(i, n);
};
util2.DataBuffer.prototype.getByte = function() {
return this.data.getInt8(this.read++);
};
util2.DataBuffer.prototype.getInt16 = function() {
var rval = this.data.getInt16(this.read);
this.read += 2;
return rval;
};
util2.DataBuffer.prototype.getInt24 = function() {
var rval = this.data.getInt16(this.read) << 8 ^ this.data.getInt8(this.read + 2);
this.read += 3;
return rval;
};
util2.DataBuffer.prototype.getInt32 = function() {
var rval = this.data.getInt32(this.read);
this.read += 4;
return rval;
};
util2.DataBuffer.prototype.getInt16Le = function() {
var rval = this.data.getInt16(this.read, true);
this.read += 2;
return rval;
};
util2.DataBuffer.prototype.getInt24Le = function() {
var rval = this.data.getInt8(this.read) ^ this.data.getInt16(this.read + 1, true) << 8;
this.read += 3;
return rval;
};
util2.DataBuffer.prototype.getInt32Le = function() {
var rval = this.data.getInt32(this.read, true);
this.read += 4;
return rval;
};
util2.DataBuffer.prototype.getInt = function(n) {
_checkBitsParam(n);
var rval = 0;
do {
rval = (rval << 8) + this.data.getInt8(this.read++);
n -= 8;
} while (n > 0);
return rval;
};
util2.DataBuffer.prototype.getSignedInt = function(n) {
var x = this.getInt(n);
var max = 2 << n - 2;
if (x >= max) {
x -= max << 1;
}
return x;
};
util2.DataBuffer.prototype.getBytes = function(count) {
var rval;
if (count) {
count = Math.min(this.length(), count);
rval = this.data.slice(this.read, this.read + count);
this.read += count;
} else if (count === 0) {
rval = "";
} else {
rval = this.read === 0 ? this.data : this.data.slice(this.read);
this.clear();
}
return rval;
};
util2.DataBuffer.prototype.bytes = function(count) {
return typeof count === "undefined" ? this.data.slice(this.read) : this.data.slice(this.read, this.read + count);
};
util2.DataBuffer.prototype.at = function(i) {
return this.data.getUint8(this.read + i);
};
util2.DataBuffer.prototype.setAt = function(i, b) {
this.data.setUint8(i, b);
return this;
};
util2.DataBuffer.prototype.last = function() {
return this.data.getUint8(this.write - 1);
};
util2.DataBuffer.prototype.copy = function() {
return new util2.DataBuffer(this);
};
util2.DataBuffer.prototype.compact = function() {
if (this.read > 0) {
var src = new Uint8Array(this.data.buffer, this.read);
var dst = new Uint8Array(src.byteLength);
dst.set(src);
this.data = new DataView(dst);
this.write -= this.read;
this.read = 0;
}
return this;
};
util2.DataBuffer.prototype.clear = function() {
this.data = new DataView(new ArrayBuffer(0));
this.read = this.write = 0;
return this;
};
util2.DataBuffer.prototype.truncate = function(count) {
this.write = Math.max(0, this.length() - count);
this.read = Math.min(this.read, this.write);
return this;
};
util2.DataBuffer.prototype.toHex = function() {
var rval = "";
for (var i = this.read; i < this.data.byteLength; ++i) {
var b = this.data.getUint8(i);
if (b < 16) {
rval += "0";
}
rval += b.toString(16);
}
return rval;
};
util2.DataBuffer.prototype.toString = function(encoding) {
var view = new Uint8Array(this.data, this.read, this.length());
encoding = encoding || "utf8";
if (encoding === "binary" || encoding === "raw") {
return util2.binary.raw.encode(view);
}
if (encoding === "hex") {
return util2.binary.hex.encode(view);
}
if (encoding === "base64") {
return util2.binary.base64.encode(view);
}
if (encoding === "utf8") {
return util2.text.utf8.decode(view);
}
if (encoding === "utf16") {
return util2.text.utf16.decode(view);
}
throw new Error("Invalid encoding: " + encoding);
};
util2.createBuffer = function(input2, encoding) {
encoding = encoding || "raw";
if (input2 !== void 0 && encoding === "utf8") {
input2 = util2.encodeUtf8(input2);
}
return new util2.ByteBuffer(input2);
};
util2.fillString = function(c, n) {
var s = "";
while (n > 0) {
if (n & 1) {
s += c;
}
n >>>= 1;
if (n > 0) {
c += c;
}
}
return s;
};
util2.xorBytes = function(s1, s2, n) {
var s3 = "";
var b = "";
var t = "";
var i = 0;
var c = 0;
for (; n > 0; --n, ++i) {
b = s1.charCodeAt(i) ^ s2.charCodeAt(i);
if (c >= 10) {
s3 += t;
t = "";
c = 0;
}
t += String.fromCharCode(b);
++c;
}
s3 += t;
return s3;
};
util2.hexToBytes = function(hex) {
var rval = "";
var i = 0;
if (hex.length & true) {
i = 1;
rval += String.fromCharCode(parseInt(hex[0], 16));
}
for (; i < hex.length; i += 2) {
rval += String.fromCharCode(parseInt(hex.substr(i, 2), 16));
}
return rval;
};
util2.bytesToHex = function(bytes) {
return util2.createBuffer(bytes).toHex();
};
util2.int32ToBytes = function(i) {
return String.fromCharCode(i >> 24 & 255) + String.fromCharCode(i >> 16 & 255) + String.fromCharCode(i >> 8 & 255) + String.fromCharCode(i & 255);
};
var _base64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
var _base64Idx = [
/*43 -43 = 0*/
/*'+', 1, 2, 3,'/' */
62,
-1,
-1,
-1,
63,
/*'0','1','2','3','4','5','6','7','8','9' */
52,
53,
54,
55,
56,
57,
58,
59,
60,
61,
/*15, 16, 17,'=', 19, 20, 21 */
-1,
-1,
-1,
64,
-1,
-1,
-1,
/*65 - 43 = 22*/
/*'A','B','C','D','E','F','G','H','I','J','K','L','M', */
0,
1,
2,
3,
4,
5,
6,
7,
8,
9,
10,
11,
12,
/*'N','O','P','Q','R','S','T','U','V','W','X','Y','Z' */
13,
14,
15,
16,
17,
18,
19,
20,
21,
22,
23,
24,
25,
/*91 - 43 = 48 */
/*48, 49, 50, 51, 52, 53 */
-1,
-1,
-1,
-1,
-1,
-1,
/*97 - 43 = 54*/
/*'a','b','c','d','e','f','g','h','i','j','k','l','m' */
26,
27,
28,
29,
30,
31,
32,
33,
34,
35,
36,
37,
38,
/*'n','o','p','q','r','s','t','u','v','w','x','y','z' */
39,
40,
41,
42,
43,
44,
45,
46,
47,
48,
49,
50,
51
];
var _base58 = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
util2.encode64 = function(input2, maxline) {
var line = "";
var output = "";
var chr1, chr2, chr3;
var i = 0;
while (i < input2.length) {
chr1 = input2.charCodeAt(i++);
chr2 = input2.charCodeAt(i++);
chr3 = input2.charCodeAt(i++);
line += _base64.charAt(chr1 >> 2);
line += _base64.charAt((chr1 & 3) << 4 | chr2 >> 4);
if (isNaN(chr2)) {
line += "==";
} else {
line += _base64.charAt((chr2 & 15) << 2 | chr3 >> 6);
line += isNaN(chr3) ? "=" : _base64.charAt(chr3 & 63);
}
if (maxline && line.length > maxline) {
output += line.substr(0, maxline) + "\r\n";
line = line.substr(maxline);
}
}
output += line;
return output;
};
util2.decode64 = function(input2) {
input2 = input2.replace(/[^A-Za-z0-9\+\/\=]/g, "");
var output = "";
var enc1, enc2, enc3, enc4;
var i = 0;
while (i < input2.length) {
enc1 = _base64Idx[input2.charCodeAt(i++) - 43];
enc2 = _base64Idx[input2.charCodeAt(i++) - 43];
enc3 = _base64Idx[input2.charCodeAt(i++) - 43];
enc4 = _base64Idx[input2.charCodeAt(i++) - 43];
output += String.fromCharCode(enc1 << 2 | enc2 >> 4);
if (enc3 !== 64) {
output += String.fromCharCode((enc2 & 15) << 4 | enc3 >> 2);
if (enc4 !== 64) {
output += String.fromCharCode((enc3 & 3) << 6 | enc4);
}
}
}
return output;
};
util2.encodeUtf8 = function(str) {
return unescape(encodeURIComponent(str));
};
util2.decodeUtf8 = function(str) {
return decodeURIComponent(escape(str));
};
util2.binary = {
raw: {},
hex: {},
base64: {},
base58: {},
baseN: {
encode: baseN.encode,
decode: baseN.decode
}
};
util2.binary.raw.encode = function(bytes) {
return String.fromCharCode.apply(null, bytes);
};
util2.binary.raw.decode = function(str, output, offset) {
var out = output;
if (!out) {
out = new Uint8Array(str.length);
}
offset = offset || 0;
var j = offset;
for (var i = 0; i < str.length; ++i) {
out[j++] = str.charCodeAt(i);
}
return output ? j - offset : out;
};
util2.binary.hex.encode = util2.bytesToHex;
util2.binary.hex.decode = function(hex, output, offset) {
var out = output;
if (!out) {
out = new Uint8Array(Math.ceil(hex.length / 2));
}
offset = offset || 0;
var i = 0, j = offset;
if (hex.length & 1) {
i = 1;
out[j++] = parseInt(hex[0], 16);
}
for (; i < hex.length; i += 2) {
out[j++] = parseInt(hex.substr(i, 2), 16);
}
return output ? j - offset : out;
};
util2.binary.base64.encode = function(input2, maxline) {
var line = "";
var output = "";
var chr1, chr2, chr3;
var i = 0;
while (i < input2.byteLength) {
chr1 = input2[i++];
chr2 = input2[i++];
chr3 = input2[i++];
line += _base64.charAt(chr1 >> 2);
line += _base64.charAt((chr1 & 3) << 4 | chr2 >> 4);
if (isNaN(chr2)) {
line += "==";
} else {
line += _base64.charAt((chr2 & 15) << 2 | chr3 >> 6);
line += isNaN(chr3) ? "=" : _base64.charAt(chr3 & 63);
}
if (maxline && line.length > maxline) {
output += line.substr(0, maxline) + "\r\n";
line = line.substr(maxline);
}
}
output += line;
return output;
};
util2.binary.base64.decode = function(input2, output, offset) {
var out = output;
if (!out) {
out = new Uint8Array(Math.ceil(input2.length / 4) * 3);
}
input2 = input2.replace(/[^A-Za-z0-9\+\/\=]/g, "");
offset = offset || 0;
var enc1, enc2, enc3, enc4;
var i = 0, j = offset;
while (i < input2.length) {
enc1 = _base64Idx[input2.charCodeAt(i++) - 43];
enc2 = _base64Idx[input2.charCodeAt(i++) - 43];
enc3 = _base64Idx[input2.charCodeAt(i++) - 43];
enc4 = _base64Idx[input2.charCodeAt(i++) - 43];
out[j++] = enc1 << 2 | enc2 >> 4;
if (enc3 !== 64) {
out[j++] = (enc2 & 15) << 4 | enc3 >> 2;
if (enc4 !== 64) {
out[j++] = (enc3 & 3) << 6 | enc4;
}
}
}
return output ? j - offset : out.subarray(0, j);
};
util2.binary.base58.encode = function(input2, maxline) {
return util2.binary.baseN.encode(input2, _base58, maxline);
};
util2.binary.base58.decode = function(input2, maxline) {
return util2.binary.baseN.decode(input2, _base58, maxline);
};
util2.text = {
utf8: {},
utf16: {}
};
util2.text.utf8.encode = function(str, output, offset) {
str = util2.encodeUtf8(str);
var out = output;
if (!out) {
out = new Uint8Array(str.length);
}
offset = offset || 0;
var j = offset;
for (var i = 0; i < str.length; ++i) {
out[j++] = str.charCodeAt(i);
}
return output ? j - offset : out;
};
util2.text.utf8.decode = function(bytes) {
return util2.decodeUtf8(String.fromCharCode.apply(null, bytes));
};
util2.text.utf16.encode = function(str, output, offset) {
var out = output;
if (!out) {
out = new Uint8Array(str.length * 2);
}
var view = new Uint16Array(out.buffer);
offset = offset || 0;
var j = offset;
var k = offset;
for (var i = 0; i < str.length; ++i) {
view[k++] = str.charCodeAt(i);
j += 2;
}
return output ? j - offset : out;
};
util2.text.utf16.decode = function(bytes) {
return String.fromCharCode.apply(null, new Uint16Array(bytes.buffer));
};
util2.deflate = function(api, bytes, raw) {
bytes = util2.decode64(api.deflate(util2.encode64(bytes)).rval);
if (raw) {
var start = 2;
var flg = bytes.charCodeAt(1);
if (flg & 32) {
start = 6;
}
bytes = bytes.substring(start, bytes.length - 4);
}
return bytes;
};
util2.inflate = function(api, bytes, raw) {
var rval = api.inflate(util2.encode64(bytes)).rval;
return rval === null ? null : util2.decode64(rval);
};
var _setStorageObject = function(api, id, obj) {
if (!api) {
throw new Error("WebStorage not available.");
}
var rval;
if (obj === null) {
rval = api.removeItem(id);
} else {
obj = util2.encode64(JSON.stringify(obj));
rval = api.setItem(id, obj);
}
if (typeof rval !== "undefined" && rval.rval !== true) {
var error = new Error(rval.error.message);
error.id = rval.error.id;
error.name = rval.error.name;
throw error;
}
};
var _getStorageObject = function(api, id) {
if (!api) {
throw new Error("WebStorage not available.");
}
var rval = api.getItem(id);
if (api.init) {
if (rval.rval === null) {
if (rval.error) {
var error = new Error(rval.error.message);
error.id = rval.error.id;
error.name = rval.error.name;
throw error;
}
rval = null;
} else {
rval = rval.rval;
}
}
if (rval !== null) {
rval = JSON.parse(util2.decode64(rval));
}
return rval;
};
var _setItem = function(api, id, key2, data2) {
var obj = _getStorageObject(api, id);
if (obj === null) {
obj = {};
}
obj[key2] = data2;
_setStorageObject(api, id, obj);
};
var _getItem = function(api, id, key2) {
var rval = _getStorageObject(api, id);
if (rval !== null) {
rval = key2 in rval ? rval[key2] : null;
}
return rval;
};
var _removeItem = function(api, id, key2) {
var obj = _getStorageObject(api, id);
if (obj !== null && key2 in obj) {
delete obj[key2];
var empty = true;
for (var prop in obj) {
empty = false;
break;
}
if (empty) {
obj = null;
}
_setStorageObject(api, id, obj);
}
};
var _clearItems = function(api, id) {
_setStorageObject(api, id, null);
};
var _callStorageFunction = function(func, args, location2) {
var rval = null;
if (typeof location2 === "undefined") {
location2 = ["web", "flash"];
}
var type;
var done = false;
var exception = null;
for (var idx in location2) {
type = location2[idx];
try {
if (type === "flash" || type === "both") {
if (args[0] === null) {
throw new Error("Flash local storage not available.");
}
rval = func.apply(this, args);
done = type === "flash";
}
if (type === "web" || type === "both") {
args[0] = localStorage;
rval = func.apply(this, args);
done = true;
}
} catch (ex) {
exception = ex;
}
if (done) {
break;
}
}
if (!done) {
throw exception;
}
return rval;
};
util2.setItem = function(api, id, key2, data2, location2) {
_callStorageFunction(_setItem, arguments, location2);
};
util2.getItem = function(api, id, key2, location2) {
return _callStorageFunction(_getItem, arguments, location2);
};
util2.removeItem = function(api, id, key2, location2) {
_callStorageFunction(_removeItem, arguments, location2);
};
util2.clearItems = function(api, id, location2) {
_callStorageFunction(_clearItems, arguments, location2);
};
util2.isEmpty = function(obj) {
for (var prop in obj) {
if (obj.hasOwnProperty(prop)) {
return false;
}
}
return true;
};
util2.format = function(format) {
var re = /%./g;
var match2;
var part;
var argi = 0;
var parts = [];
var last4 = 0;
while (match2 = re.exec(format)) {
part = format.substring(last4, re.lastIndex - 2);
if (part.length > 0) {
parts.push(part);
}
last4 = re.lastIndex;
var code = match2[0][1];
switch (code) {
case "s":
case "o":
if (argi < arguments.length) {
parts.push(arguments[argi++ + 1]);
} else {
parts.push("<?>");
}
break;
case "%":
parts.push("%");
break;
default:
parts.push("<%" + code + "?>");
}
}
parts.push(format.substring(last4));
return parts.join("");
};
util2.formatNumber = function(number, decimals, dec_point, thousands_sep) {
var n = number, c = isNaN(decimals = Math.abs(decimals)) ? 2 : decimals;
var d = dec_point === void 0 ? "," : dec_point;
var t = thousands_sep === void 0 ? "." : thousands_sep, s = n < 0 ? "-" : "";
var i = parseInt(n = Math.abs(+n || 0).toFixed(c), 10) + "";
var j = i.length > 3 ? i.length % 3 : 0;
return s + (j ? i.substr(0, j) + t : "") + i.substr(j).replace(/(\d{3})(?=\d)/g, "$1" + t) + (c ? d + Math.abs(n - i).toFixed(c).slice(2) : "");
};
util2.formatSize = function(size) {
if (size >= 1073741824) {
size = util2.formatNumber(size / 1073741824, 2, ".", "") + " GiB";
} else if (size >= 1048576) {
size = util2.formatNumber(size / 1048576, 2, ".", "") + " MiB";
} else if (size >= 1024) {
size = util2.formatNumber(size / 1024, 0) + " KiB";
} else {
size = util2.formatNumber(size, 0) + " bytes";
}
return size;
};
util2.bytesFromIP = function(ip) {
if (ip.indexOf(".") !== -1) {
return util2.bytesFromIPv4(ip);
}
if (ip.indexOf(":") !== -1) {
return util2.bytesFromIPv6(ip);
}
return null;
};
util2.bytesFromIPv4 = function(ip) {
ip = ip.split(".");
if (ip.length !== 4) {
return null;
}
var b = util2.createBuffer();
for (var i = 0; i < ip.length; ++i) {
var num = parseInt(ip[i], 10);
if (isNaN(num)) {
return null;
}
b.putByte(num);
}
return b.getBytes();
};
util2.bytesFromIPv6 = function(ip) {
var blanks = 0;
ip = ip.split(":").filter(function(e) {
if (e.length === 0)
++blanks;
return true;
});
var zeros = (8 - ip.length + blanks) * 2;
var b = util2.createBuffer();
for (var i = 0; i < 8; ++i) {
if (!ip[i] || ip[i].length === 0) {
b.fillWithByte(0, zeros);
zeros = 0;
continue;
}
var bytes = util2.hexToBytes(ip[i]);
if (bytes.length < 2) {
b.putByte(0);
}
b.putBytes(bytes);
}
return b.getBytes();
};
util2.bytesToIP = function(bytes) {
if (bytes.length === 4) {
return util2.bytesToIPv4(bytes);
}
if (bytes.length === 16) {
return util2.bytesToIPv6(bytes);
}
return null;
};
util2.bytesToIPv4 = function(bytes) {
if (bytes.length !== 4) {
return null;
}
var ip = [];
for (var i = 0; i < bytes.length; ++i) {
ip.push(bytes.charCodeAt(i));
}
return ip.join(".");
};
util2.bytesToIPv6 = function(bytes) {
if (bytes.length !== 16) {
return null;
}
var ip = [];
var zeroGroups = [];
var zeroMaxGroup = 0;
for (var i = 0; i < bytes.length; i += 2) {
var hex = util2.bytesToHex(bytes[i] + bytes[i + 1]);
while (hex[0] === "0" && hex !== "0") {
hex = hex.substr(1);
}
if (hex === "0") {
var last4 = zeroGroups[zeroGroups.length - 1];
var idx = ip.length;
if (!last4 || idx !== last4.end + 1) {
zeroGroups.push({ start: idx, end: idx });
} else {
last4.end = idx;
if (last4.end - last4.start > zeroGroups[zeroMaxGroup].end - zeroGroups[zeroMaxGroup].start) {
zeroMaxGroup = zeroGroups.length - 1;
}
}
}
ip.push(hex);
}
if (zeroGroups.length > 0) {
var group = zeroGroups[zeroMaxGroup];
if (group.end - group.start > 0) {
ip.splice(group.start, group.end - group.start + 1, "");
if (group.start === 0) {
ip.unshift("");
}
if (group.end === 7) {
ip.push("");
}
}
}
return ip.join(":");
};
util2.estimateCores = function(options, callback) {
if (typeof options === "function") {
callback = options;
options = {};
}
options = options || {};
if ("cores" in util2 && !options.update) {
return callback(null, util2.cores);
}
if (typeof navigator !== "undefined" && "hardwareConcurrency" in navigator && navigator.hardwareConcurrency > 0) {
util2.cores = navigator.hardwareConcurrency;
return callback(null, util2.cores);
}
if (typeof Worker === "undefined") {
util2.cores = 1;
return callback(null, util2.cores);
}
if (typeof Blob === "undefined") {
util2.cores = 2;
return callback(null, util2.cores);
}
var blobUrl = URL.createObjectURL(new Blob([
"(",
(function() {
self.addEventListener("message", function(e) {
var st = Date.now();
var et = st + 4;
while (Date.now() < et)
;
self.postMessage({ st, et });
});
}).toString(),
")()"
], { type: "application/javascript" }));
sample([], 5, 16);
function sample(max, samples, numWorkers) {
if (samples === 0) {
var avg = Math.floor(max.reduce(function(avg2, x) {
return avg2 + x;
}, 0) / max.length);
util2.cores = Math.max(1, avg);
URL.revokeObjectURL(blobUrl);
return callback(null, util2.cores);
}
map2(numWorkers, function(err, results) {
max.push(reduce(numWorkers, results));
sample(max, samples - 1, numWorkers);
});
}
function map2(numWorkers, callback2) {
var workers = [];
var results = [];
for (var i = 0; i < numWorkers; ++i) {
var worker = new Worker(blobUrl);
worker.addEventListener("message", function(e) {
results.push(e.data);
if (results.length === numWorkers) {
for (var i2 = 0; i2 < numWorkers; ++i2) {
workers[i2].terminate();
}
callback2(null, results);
}
});
workers.push(worker);
}
for (var i = 0; i < numWorkers; ++i) {
workers[i].postMessage(i);
}
}
function reduce(numWorkers, results) {
var overlaps = [];
for (var n = 0; n < numWorkers; ++n) {
var r1 = results[n];
var overlap = overlaps[n] = [];
for (var i = 0; i < numWorkers; ++i) {
if (n === i) {
continue;
}
var r2 = results[i];
if (r1.st > r2.st && r1.st < r2.et || r2.st > r1.st && r2.st < r1.et) {
overlap.push(i);
}
}
}
return overlaps.reduce(function(max, overlap2) {
return Math.max(max, overlap2.length);
}, 0);
}
};
}
});
// node_modules/node-forge/lib/cipher.js
var require_cipher = __commonJS({
"node_modules/node-forge/lib/cipher.js"(exports2, module2) {
"use strict";
var forge2 = require_forge();
require_util();
module2.exports = forge2.cipher = forge2.cipher || {};
forge2.cipher.algorithms = forge2.cipher.algorithms || {};
forge2.cipher.createCipher = function(algorithm, key2) {
var api = algorithm;
if (typeof api === "string") {
api = forge2.cipher.getAlgorithm(api);
if (api) {
api = api();
}
}
if (!api) {
throw new Error("Unsupported algorithm: " + algorithm);
}
return new forge2.cipher.BlockCipher({
algorithm: api,
key: key2,
decrypt: false
});
};
forge2.cipher.createDecipher = function(algorithm, key2) {
var api = algorithm;
if (typeof api === "string") {
api = forge2.cipher.getAlgorithm(api);
if (api) {
api = api();
}
}
if (!api) {
throw new Error("Unsupported algorithm: " + algorithm);
}
return new forge2.cipher.BlockCipher({
algorithm: api,
key: key2,
decrypt: true
});
};
forge2.cipher.registerAlgorithm = function(name2, algorithm) {
name2 = name2.toUpperCase();
forge2.cipher.algorithms[name2] = algorithm;
};
forge2.cipher.getAlgorithm = function(name2) {
name2 = name2.toUpperCase();
if (name2 in forge2.cipher.algorithms) {
return forge2.cipher.algorithms[name2];
}
return null;
};
var BlockCipher = forge2.cipher.BlockCipher = function(options) {
this.algorithm = options.algorithm;
this.mode = this.algorithm.mode;
this.blockSize = this.mode.blockSize;
this._finish = false;
this._input = null;
this.output = null;
this._op = options.decrypt ? this.mode.decrypt : this.mode.encrypt;
this._decrypt = options.decrypt;
this.algorithm.initialize(options);
};
BlockCipher.prototype.start = function(options) {
options = options || {};
var opts = {};
for (var key2 in options) {
opts[key2] = options[key2];
}
opts.decrypt = this._decrypt;
this._finish = false;
this._input = forge2.util.createBuffer();
this.output = options.output || forge2.util.createBuffer();
this.mode.start(opts);
};
BlockCipher.prototype.update = function(input2) {
if (input2) {
this._input.putBuffer(input2);
}
while (!this._op.call(this.mode, this._input, this.output, this._finish) && !this._finish) {
}
this._input.compact();
};
BlockCipher.prototype.finish = function(pad) {
if (pad && (this.mode.name === "ECB" || this.mode.name === "CBC")) {
this.mode.pad = function(input2) {
return pad(this.blockSize, input2, false);
};
this.mode.unpad = function(output) {
return pad(this.blockSize, output, true);
};
}
var options = {};
options.decrypt = this._decrypt;
options.overflow = this._input.length() % this.blockSize;
if (!this._decrypt && this.mode.pad) {
if (!this.mode.pad(this._input, options)) {
return false;
}
}
this._finish = true;
this.update();
if (this._decrypt && this.mode.unpad) {
if (!this.mode.unpad(this.output, options)) {
return false;
}
}
if (this.mode.afterFinish) {
if (!this.mode.afterFinish(this.output, options)) {
return false;
}
}
return true;
};
}
});
// node_modules/node-forge/lib/cipherModes.js
var require_cipherModes = __commonJS({
"node_modules/node-forge/lib/cipherModes.js"(exports2, module2) {
"use strict";
var forge2 = require_forge();
require_util();
forge2.cipher = forge2.cipher || {};
var modes = module2.exports = forge2.cipher.modes = forge2.cipher.modes || {};
modes.ecb = function(options) {
options = options || {};
this.name = "ECB";
this.cipher = options.cipher;
this.blockSize = options.blockSize || 16;
this._ints = this.blockSize / 4;
this._inBlock = new Array(this._ints);
this._outBlock = new Array(this._ints);
};
modes.ecb.prototype.start = function(options) {
};
modes.ecb.prototype.encrypt = function(input2, output, finish) {
if (input2.length() < this.blockSize && !(finish && input2.length() > 0)) {
return true;
}
for (var i = 0; i < this._ints; ++i) {
this._inBlock[i] = input2.getInt32();
}
this.cipher.encrypt(this._inBlock, this._outBlock);
for (var i = 0; i < this._ints; ++i) {
output.putInt32(this._outBlock[i]);
}
};
modes.ecb.prototype.decrypt = function(input2, output, finish) {
if (input2.length() < this.blockSize && !(finish && input2.length() > 0)) {
return true;
}
for (var i = 0; i < this._ints; ++i) {
this._inBlock[i] = input2.getInt32();
}
this.cipher.decrypt(this._inBlock, this._outBlock);
for (var i = 0; i < this._ints; ++i) {
output.putInt32(this._outBlock[i]);
}
};
modes.ecb.prototype.pad = function(input2, options) {
var padding = input2.length() === this.blockSize ? this.blockSize : this.blockSize - input2.length();
input2.fillWithByte(padding, padding);
return true;
};
modes.ecb.prototype.unpad = function(output, options) {
if (options.overflow > 0) {
return false;
}
var len = output.length();
var count = output.at(len - 1);
if (count > this.blockSize << 2) {
return false;
}
output.truncate(count);
return true;
};
modes.cbc = function(options) {
options = options || {};
this.name = "CBC";
this.cipher = options.cipher;
this.blockSize = options.blockSize || 16;
this._ints = this.blockSize / 4;
this._inBlock = new Array(this._ints);
this._outBlock = new Array(this._ints);
};
modes.cbc.prototype.start = function(options) {
if (options.iv === null) {
if (!this._prev) {
throw new Error("Invalid IV parameter.");
}
this._iv = this._prev.slice(0);
} else if (!("iv" in options)) {
throw new Error("Invalid IV parameter.");
} else {
this._iv = transformIV(options.iv, this.blockSize);
this._prev = this._iv.slice(0);
}
};
modes.cbc.prototype.encrypt = function(input2, output, finish) {
if (input2.length() < this.blockSize && !(finish && input2.length() > 0)) {
return true;
}
for (var i = 0; i < this._ints; ++i) {
this._inBlock[i] = this._prev[i] ^ input2.getInt32();
}
this.cipher.encrypt(this._inBlock, this._outBlock);
for (var i = 0; i < this._ints; ++i) {
output.putInt32(this._outBlock[i]);
}
this._prev = this._outBlock;
};
modes.cbc.prototype.decrypt = function(input2, output, finish) {
if (input2.length() < this.blockSize && !(finish && input2.length() > 0)) {
return true;
}
for (var i = 0; i < this._ints; ++i) {
this._inBlock[i] = input2.getInt32();
}
this.cipher.decrypt(this._inBlock, this._outBlock);
for (var i = 0; i < this._ints; ++i) {
output.putInt32(this._prev[i] ^ this._outBlock[i]);
}
this._prev = this._inBlock.slice(0);
};
modes.cbc.prototype.pad = function(input2, options) {
var padding = input2.length() === this.blockSize ? this.blockSize : this.blockSize - input2.length();
input2.fillWithByte(padding, padding);
return true;
};
modes.cbc.prototype.unpad = function(output, options) {
if (options.overflow > 0) {
return false;
}
var len = output.length();
var count = output.at(len - 1);
if (count > this.blockSize << 2) {
return false;
}
output.truncate(count);
return true;
};
modes.cfb = function(options) {
options = options || {};
this.name = "CFB";
this.cipher = options.cipher;
this.blockSize = options.blockSize || 16;
this._ints = this.blockSize / 4;
this._inBlock = null;
this._outBlock = new Array(this._ints);
this._partialBlock = new Array(this._ints);
this._partialOutput = forge2.util.createBuffer();
this._partialBytes = 0;
};
modes.cfb.prototype.start = function(options) {
if (!("iv" in options)) {
throw new Error("Invalid IV parameter.");
}
this._iv = transformIV(options.iv, this.blockSize);
this._inBlock = this._iv.slice(0);
this._partialBytes = 0;
};
modes.cfb.prototype.encrypt = function(input2, output, finish) {
var inputLength = input2.length();
if (inputLength === 0) {
return true;
}
this.cipher.encrypt(this._inBlock, this._outBlock);
if (this._partialBytes === 0 && inputLength >= this.blockSize) {
for (var i = 0; i < this._ints; ++i) {
this._inBlock[i] = input2.getInt32() ^ this._outBlock[i];
output.putInt32(this._inBlock[i]);
}
return;
}
var partialBytes = (this.blockSize - inputLength) % this.blockSize;
if (partialBytes > 0) {
partialBytes = this.blockSize - partialBytes;
}
this._partialOutput.clear();
for (var i = 0; i < this._ints; ++i) {
this._partialBlock[i] = input2.getInt32() ^ this._outBlock[i];
this._partialOutput.putInt32(this._partialBlock[i]);
}
if (partialBytes > 0) {
input2.read -= this.blockSize;
} else {
for (var i = 0; i < this._ints; ++i) {
this._inBlock[i] = this._partialBlock[i];
}
}
if (this._partialBytes > 0) {
this._partialOutput.getBytes(this._partialBytes);
}
if (partialBytes > 0 && !finish) {
output.putBytes(this._partialOutput.getBytes(
partialBytes - this._partialBytes
));
this._partialBytes = partialBytes;
return true;
}
output.putBytes(this._partialOutput.getBytes(
inputLength - this._partialBytes
));
this._partialBytes = 0;
};
modes.cfb.prototype.decrypt = function(input2, output, finish) {
var inputLength = input2.length();
if (inputLength === 0) {
return true;
}
this.cipher.encrypt(this._inBlock, this._outBlock);
if (this._partialBytes === 0 && inputLength >= this.blockSize) {
for (var i = 0; i < this._ints; ++i) {
this._inBlock[i] = input2.getInt32();
output.putInt32(this._inBlock[i] ^ this._outBlock[i]);
}
return;
}
var partialBytes = (this.blockSize - inputLength) % this.blockSize;
if (partialBytes > 0) {
partialBytes = this.blockSize - partialBytes;
}
this._partialOutput.clear();
for (var i = 0; i < this._ints; ++i) {
this._partialBlock[i] = input2.getInt32();
this._partialOutput.putInt32(this._partialBlock[i] ^ this._outBlock[i]);
}
if (partialBytes > 0) {
input2.read -= this.blockSize;
} else {
for (var i = 0; i < this._ints; ++i) {
this._inBlock[i] = this._partialBlock[i];
}
}
if (this._partialBytes > 0) {
this._partialOutput.getBytes(this._partialBytes);
}
if (partialBytes > 0 && !finish) {
output.putBytes(this._partialOutput.getBytes(
partialBytes - this._partialBytes
));
this._partialBytes = partialBytes;
return true;
}
output.putBytes(this._partialOutput.getBytes(
inputLength - this._partialBytes
));
this._partialBytes = 0;
};
modes.ofb = function(options) {
options = options || {};
this.name = "OFB";
this.cipher = options.cipher;
this.blockSize = options.blockSize || 16;
this._ints = this.blockSize / 4;
this._inBlock = null;
this._outBlock = new Array(this._ints);
this._partialOutput = forge2.util.createBuffer();
this._partialBytes = 0;
};
modes.ofb.prototype.start = function(options) {
if (!("iv" in options)) {
throw new Error("Invalid IV parameter.");
}
this._iv = transformIV(options.iv, this.blockSize);
this._inBlock = this._iv.slice(0);
this._partialBytes = 0;
};
modes.ofb.prototype.encrypt = function(input2, output, finish) {
var inputLength = input2.length();
if (input2.length() === 0) {
return true;
}
this.cipher.encrypt(this._inBlock, this._outBlock);
if (this._partialBytes === 0 && inputLength >= this.blockSize) {
for (var i = 0; i < this._ints; ++i) {
output.putInt32(input2.getInt32() ^ this._outBlock[i]);
this._inBlock[i] = this._outBlock[i];
}
return;
}
var partialBytes = (this.blockSize - inputLength) % this.blockSize;
if (partialBytes > 0) {
partialBytes = this.blockSize - partialBytes;
}
this._partialOutput.clear();
for (var i = 0; i < this._ints; ++i) {
this._partialOutput.putInt32(input2.getInt32() ^ this._outBlock[i]);
}
if (partialBytes > 0) {
input2.read -= this.blockSize;
} else {
for (var i = 0; i < this._ints; ++i) {
this._inBlock[i] = this._outBlock[i];
}
}
if (this._partialBytes > 0) {
this._partialOutput.getBytes(this._partialBytes);
}
if (partialBytes > 0 && !finish) {
output.putBytes(this._partialOutput.getBytes(
partialBytes - this._partialBytes
));
this._partialBytes = partialBytes;
return true;
}
output.putBytes(this._partialOutput.getBytes(
inputLength - this._partialBytes
));
this._partialBytes = 0;
};
modes.ofb.prototype.decrypt = modes.ofb.prototype.encrypt;
modes.ctr = function(options) {
options = options || {};
this.name = "CTR";
this.cipher = options.cipher;
this.blockSize = options.blockSize || 16;
this._ints = this.blockSize / 4;
this._inBlock = null;
this._outBlock = new Array(this._ints);
this._partialOutput = forge2.util.createBuffer();
this._partialBytes = 0;
};
modes.ctr.prototype.start = function(options) {
if (!("iv" in options)) {
throw new Error("Invalid IV parameter.");
}
this._iv = transformIV(options.iv, this.blockSize);
this._inBlock = this._iv.slice(0);
this._partialBytes = 0;
};
modes.ctr.prototype.encrypt = function(input2, output, finish) {
var inputLength = input2.length();
if (inputLength === 0) {
return true;
}
this.cipher.encrypt(this._inBlock, this._outBlock);
if (this._partialBytes === 0 && inputLength >= this.blockSize) {
for (var i = 0; i < this._ints; ++i) {
output.putInt32(input2.getInt32() ^ this._outBlock[i]);
}
} else {
var partialBytes = (this.blockSize - inputLength) % this.blockSize;
if (partialBytes > 0) {
partialBytes = this.blockSize - partialBytes;
}
this._partialOutput.clear();
for (var i = 0; i < this._ints; ++i) {
this._partialOutput.putInt32(input2.getInt32() ^ this._outBlock[i]);
}
if (partialBytes > 0) {
input2.read -= this.blockSize;
}
if (this._partialBytes > 0) {
this._partialOutput.getBytes(this._partialBytes);
}
if (partialBytes > 0 && !finish) {
output.putBytes(this._partialOutput.getBytes(
partialBytes - this._partialBytes
));
this._partialBytes = partialBytes;
return true;
}
output.putBytes(this._partialOutput.getBytes(
inputLength - this._partialBytes
));
this._partialBytes = 0;
}
inc32(this._inBlock);
};
modes.ctr.prototype.decrypt = modes.ctr.prototype.encrypt;
modes.gcm = function(options) {
options = options || {};
this.name = "GCM";
this.cipher = options.cipher;
this.blockSize = options.blockSize || 16;
this._ints = this.blockSize / 4;
this._inBlock = new Array(this._ints);
this._outBlock = new Array(this._ints);
this._partialOutput = forge2.util.createBuffer();
this._partialBytes = 0;
this._R = 3774873600;
};
modes.gcm.prototype.start = function(options) {
if (!("iv" in options)) {
throw new Error("Invalid IV parameter.");
}
var iv = forge2.util.createBuffer(options.iv);
this._cipherLength = 0;
var additionalData;
if ("additionalData" in options) {
additionalData = forge2.util.createBuffer(options.additionalData);
} else {
additionalData = forge2.util.createBuffer();
}
if ("tagLength" in options) {
this._tagLength = options.tagLength;
} else {
this._tagLength = 128;
}
this._tag = null;
if (options.decrypt) {
this._tag = forge2.util.createBuffer(options.tag).getBytes();
if (this._tag.length !== this._tagLength / 8) {
throw new Error("Authentication tag does not match tag length.");
}
}
this._hashBlock = new Array(this._ints);
this.tag = null;
this._hashSubkey = new Array(this._ints);
this.cipher.encrypt([0, 0, 0, 0], this._hashSubkey);
this.componentBits = 4;
this._m = this.generateHashTable(this._hashSubkey, this.componentBits);
var ivLength = iv.length();
if (ivLength === 12) {
this._j0 = [iv.getInt32(), iv.getInt32(), iv.getInt32(), 1];
} else {
this._j0 = [0, 0, 0, 0];
while (iv.length() > 0) {
this._j0 = this.ghash(
this._hashSubkey,
this._j0,
[iv.getInt32(), iv.getInt32(), iv.getInt32(), iv.getInt32()]
);
}
this._j0 = this.ghash(
this._hashSubkey,
this._j0,
[0, 0].concat(from64To32(ivLength * 8))
);
}
this._inBlock = this._j0.slice(0);
inc32(this._inBlock);
this._partialBytes = 0;
additionalData = forge2.util.createBuffer(additionalData);
this._aDataLength = from64To32(additionalData.length() * 8);
var overflow = additionalData.length() % this.blockSize;
if (overflow) {
additionalData.fillWithByte(0, this.blockSize - overflow);
}
this._s = [0, 0, 0, 0];
while (additionalData.length() > 0) {
this._s = this.ghash(this._hashSubkey, this._s, [
additionalData.getInt32(),
additionalData.getInt32(),
additionalData.getInt32(),
additionalData.getInt32()
]);
}
};
modes.gcm.prototype.encrypt = function(input2, output, finish) {
var inputLength = input2.length();
if (inputLength === 0) {
return true;
}
this.cipher.encrypt(this._inBlock, this._outBlock);
if (this._partialBytes === 0 && inputLength >= this.blockSize) {
for (var i = 0; i < this._ints; ++i) {
output.putInt32(this._outBlock[i] ^= input2.getInt32());
}
this._cipherLength += this.blockSize;
} else {
var partialBytes = (this.blockSize - inputLength) % this.blockSize;
if (partialBytes > 0) {
partialBytes = this.blockSize - partialBytes;
}
this._partialOutput.clear();
for (var i = 0; i < this._ints; ++i) {
this._partialOutput.putInt32(input2.getInt32() ^ this._outBlock[i]);
}
if (partialBytes <= 0 || finish) {
if (finish) {
var overflow = inputLength % this.blockSize;
this._cipherLength += overflow;
this._partialOutput.truncate(this.blockSize - overflow);
} else {
this._cipherLength += this.blockSize;
}
for (var i = 0; i < this._ints; ++i) {
this._outBlock[i] = this._partialOutput.getInt32();
}
this._partialOutput.read -= this.blockSize;
}
if (this._partialBytes > 0) {
this._partialOutput.getBytes(this._partialBytes);
}
if (partialBytes > 0 && !finish) {
input2.read -= this.blockSize;
output.putBytes(this._partialOutput.getBytes(
partialBytes - this._partialBytes
));
this._partialBytes = partialBytes;
return true;
}
output.putBytes(this._partialOutput.getBytes(
inputLength - this._partialBytes
));
this._partialBytes = 0;
}
this._s = this.ghash(this._hashSubkey, this._s, this._outBlock);
inc32(this._inBlock);
};
modes.gcm.prototype.decrypt = function(input2, output, finish) {
var inputLength = input2.length();
if (inputLength < this.blockSize && !(finish && inputLength > 0)) {
return true;
}
this.cipher.encrypt(this._inBlock, this._outBlock);
inc32(this._inBlock);
this._hashBlock[0] = input2.getInt32();
this._hashBlock[1] = input2.getInt32();
this._hashBlock[2] = input2.getInt32();
this._hashBlock[3] = input2.getInt32();
this._s = this.ghash(this._hashSubkey, this._s, this._hashBlock);
for (var i = 0; i < this._ints; ++i) {
output.putInt32(this._outBlock[i] ^ this._hashBlock[i]);
}
if (inputLength < this.blockSize) {
this._cipherLength += inputLength % this.blockSize;
} else {
this._cipherLength += this.blockSize;
}
};
modes.gcm.prototype.afterFinish = function(output, options) {
var rval = true;
if (options.decrypt && options.overflow) {
output.truncate(this.blockSize - options.overflow);
}
this.tag = forge2.util.createBuffer();
var lengths = this._aDataLength.concat(from64To32(this._cipherLength * 8));
this._s = this.ghash(this._hashSubkey, this._s, lengths);
var tag = [];
this.cipher.encrypt(this._j0, tag);
for (var i = 0; i < this._ints; ++i) {
this.tag.putInt32(this._s[i] ^ tag[i]);
}
this.tag.truncate(this.tag.length() % (this._tagLength / 8));
if (options.decrypt && this.tag.bytes() !== this._tag) {
rval = false;
}
return rval;
};
modes.gcm.prototype.multiply = function(x, y) {
var z_i = [0, 0, 0, 0];
var v_i = y.slice(0);
for (var i = 0; i < 128; ++i) {
var x_i = x[i / 32 | 0] & 1 << 31 - i % 32;
if (x_i) {
z_i[0] ^= v_i[0];
z_i[1] ^= v_i[1];
z_i[2] ^= v_i[2];
z_i[3] ^= v_i[3];
}
this.pow(v_i, v_i);
}
return z_i;
};
modes.gcm.prototype.pow = function(x, out) {
var lsb = x[3] & 1;
for (var i = 3; i > 0; --i) {
out[i] = x[i] >>> 1 | (x[i - 1] & 1) << 31;
}
out[0] = x[0] >>> 1;
if (lsb) {
out[0] ^= this._R;
}
};
modes.gcm.prototype.tableMultiply = function(x) {
var z = [0, 0, 0, 0];
for (var i = 0; i < 32; ++i) {
var idx = i / 8 | 0;
var x_i = x[idx] >>> (7 - i % 8) * 4 & 15;
var ah = this._m[i][x_i];
z[0] ^= ah[0];
z[1] ^= ah[1];
z[2] ^= ah[2];
z[3] ^= ah[3];
}
return z;
};
modes.gcm.prototype.ghash = function(h, y, x) {
y[0] ^= x[0];
y[1] ^= x[1];
y[2] ^= x[2];
y[3] ^= x[3];
return this.tableMultiply(y);
};
modes.gcm.prototype.generateHashTable = function(h, bits) {
var multiplier = 8 / bits;
var perInt = 4 * multiplier;
var size = 16 * multiplier;
var m = new Array(size);
for (var i = 0; i < size; ++i) {
var tmp = [0, 0, 0, 0];
var idx = i / perInt | 0;
var shft = (perInt - 1 - i % perInt) * bits;
tmp[idx] = 1 << bits - 1 << shft;
m[i] = this.generateSubHashTable(this.multiply(tmp, h), bits);
}
return m;
};
modes.gcm.prototype.generateSubHashTable = function(mid, bits) {
var size = 1 << bits;
var half = size >>> 1;
var m = new Array(size);
m[half] = mid.slice(0);
var i = half >>> 1;
while (i > 0) {
this.pow(m[2 * i], m[i] = []);
i >>= 1;
}
i = 2;
while (i < half) {
for (var j = 1; j < i; ++j) {
var m_i = m[i];
var m_j = m[j];
m[i + j] = [
m_i[0] ^ m_j[0],
m_i[1] ^ m_j[1],
m_i[2] ^ m_j[2],
m_i[3] ^ m_j[3]
];
}
i *= 2;
}
m[0] = [0, 0, 0, 0];
for (i = half + 1; i < size; ++i) {
var c = m[i ^ half];
m[i] = [mid[0] ^ c[0], mid[1] ^ c[1], mid[2] ^ c[2], mid[3] ^ c[3]];
}
return m;
};
function transformIV(iv, blockSize) {
if (typeof iv === "string") {
iv = forge2.util.createBuffer(iv);
}
if (forge2.util.isArray(iv) && iv.length > 4) {
var tmp = iv;
iv = forge2.util.createBuffer();
for (var i = 0; i < tmp.length; ++i) {
iv.putByte(tmp[i]);
}
}
if (iv.length() < blockSize) {
throw new Error(
"Invalid IV length; got " + iv.length() + " bytes and expected " + blockSize + " bytes."
);
}
if (!forge2.util.isArray(iv)) {
var ints = [];
var blocks = blockSize / 4;
for (var i = 0; i < blocks; ++i) {
ints.push(iv.getInt32());
}
iv = ints;
}
return iv;
}
function inc32(block) {
block[block.length - 1] = block[block.length - 1] + 1 & 4294967295;
}
function from64To32(num) {
return [num / 4294967296 | 0, num & 4294967295];
}
}
});
// node_modules/node-forge/lib/aes.js
var require_aes = __commonJS({
"node_modules/node-forge/lib/aes.js"(exports2, module2) {
"use strict";
var forge2 = require_forge();
require_cipher();
require_cipherModes();
require_util();
module2.exports = forge2.aes = forge2.aes || {};
forge2.aes.startEncrypting = function(key2, iv, output, mode) {
var cipher = _createCipher({
key: key2,
output,
decrypt: false,
mode
});
cipher.start(iv);
return cipher;
};
forge2.aes.createEncryptionCipher = function(key2, mode) {
return _createCipher({
key: key2,
output: null,
decrypt: false,
mode
});
};
forge2.aes.startDecrypting = function(key2, iv, output, mode) {
var cipher = _createCipher({
key: key2,
output,
decrypt: true,
mode
});
cipher.start(iv);
return cipher;
};
forge2.aes.createDecryptionCipher = function(key2, mode) {
return _createCipher({
key: key2,
output: null,
decrypt: true,
mode
});
};
forge2.aes.Algorithm = function(name2, mode) {
if (!init) {
initialize2();
}
var self2 = this;
self2.name = name2;
self2.mode = new mode({
blockSize: 16,
cipher: {
encrypt: function(inBlock, outBlock) {
return _updateBlock(self2._w, inBlock, outBlock, false);
},
decrypt: function(inBlock, outBlock) {
return _updateBlock(self2._w, inBlock, outBlock, true);
}
}
});
self2._init = false;
};
forge2.aes.Algorithm.prototype.initialize = function(options) {
if (this._init) {
return;
}
var key2 = options.key;
var tmp;
if (typeof key2 === "string" && (key2.length === 16 || key2.length === 24 || key2.length === 32)) {
key2 = forge2.util.createBuffer(key2);
} else if (forge2.util.isArray(key2) && (key2.length === 16 || key2.length === 24 || key2.length === 32)) {
tmp = key2;
key2 = forge2.util.createBuffer();
for (var i = 0; i < tmp.length; ++i) {
key2.putByte(tmp[i]);
}
}
if (!forge2.util.isArray(key2)) {
tmp = key2;
key2 = [];
var len = tmp.length();
if (len === 16 || len === 24 || len === 32) {
len = len >>> 2;
for (var i = 0; i < len; ++i) {
key2.push(tmp.getInt32());
}
}
}
if (!forge2.util.isArray(key2) || !(key2.length === 4 || key2.length === 6 || key2.length === 8)) {
throw new Error("Invalid key parameter.");
}
var mode = this.mode.name;
var encryptOp = ["CFB", "OFB", "CTR", "GCM"].indexOf(mode) !== -1;
this._w = _expandKey(key2, options.decrypt && !encryptOp);
this._init = true;
};
forge2.aes._expandKey = function(key2, decrypt) {
if (!init) {
initialize2();
}
return _expandKey(key2, decrypt);
};
forge2.aes._updateBlock = _updateBlock;
registerAlgorithm("AES-ECB", forge2.cipher.modes.ecb);
registerAlgorithm("AES-CBC", forge2.cipher.modes.cbc);
registerAlgorithm("AES-CFB", forge2.cipher.modes.cfb);
registerAlgorithm("AES-OFB", forge2.cipher.modes.ofb);
registerAlgorithm("AES-CTR", forge2.cipher.modes.ctr);
registerAlgorithm("AES-GCM", forge2.cipher.modes.gcm);
function registerAlgorithm(name2, mode) {
var factory = function() {
return new forge2.aes.Algorithm(name2, mode);
};
forge2.cipher.registerAlgorithm(name2, factory);
}
var init = false;
var Nb = 4;
var sbox;
var isbox;
var rcon;
var mix;
var imix;
function initialize2() {
init = true;
rcon = [0, 1, 2, 4, 8, 16, 32, 64, 128, 27, 54];
var xtime = new Array(256);
for (var i = 0; i < 128; ++i) {
xtime[i] = i << 1;
xtime[i + 128] = i + 128 << 1 ^ 283;
}
sbox = new Array(256);
isbox = new Array(256);
mix = new Array(4);
imix = new Array(4);
for (var i = 0; i < 4; ++i) {
mix[i] = new Array(256);
imix[i] = new Array(256);
}
var e = 0, ei = 0, e2, e4, e8, sx, sx2, me, ime;
for (var i = 0; i < 256; ++i) {
sx = ei ^ ei << 1 ^ ei << 2 ^ ei << 3 ^ ei << 4;
sx = sx >> 8 ^ sx & 255 ^ 99;
sbox[e] = sx;
isbox[sx] = e;
sx2 = xtime[sx];
e2 = xtime[e];
e4 = xtime[e2];
e8 = xtime[e4];
me = sx2 << 24 ^ // 2
sx << 16 ^ // 1
sx << 8 ^ // 1
(sx ^ sx2);
ime = (e2 ^ e4 ^ e8) << 24 ^ // E (14)
(e ^ e8) << 16 ^ // 9
(e ^ e4 ^ e8) << 8 ^ // D (13)
(e ^ e2 ^ e8);
for (var n = 0; n < 4; ++n) {
mix[n][e] = me;
imix[n][sx] = ime;
me = me << 24 | me >>> 8;
ime = ime << 24 | ime >>> 8;
}
if (e === 0) {
e = ei = 1;
} else {
e = e2 ^ xtime[xtime[xtime[e2 ^ e8]]];
ei ^= xtime[xtime[ei]];
}
}
}
function _expandKey(key2, decrypt) {
var w = key2.slice(0);
var temp, iNk = 1;
var Nk = w.length;
var Nr1 = Nk + 6 + 1;
var end = Nb * Nr1;
for (var i = Nk; i < end; ++i) {
temp = w[i - 1];
if (i % Nk === 0) {
temp = sbox[temp >>> 16 & 255] << 24 ^ sbox[temp >>> 8 & 255] << 16 ^ sbox[temp & 255] << 8 ^ sbox[temp >>> 24] ^ rcon[iNk] << 24;
iNk++;
} else if (Nk > 6 && i % Nk === 4) {
temp = sbox[temp >>> 24] << 24 ^ sbox[temp >>> 16 & 255] << 16 ^ sbox[temp >>> 8 & 255] << 8 ^ sbox[temp & 255];
}
w[i] = w[i - Nk] ^ temp;
}
if (decrypt) {
var tmp;
var m0 = imix[0];
var m1 = imix[1];
var m2 = imix[2];
var m3 = imix[3];
var wnew = w.slice(0);
end = w.length;
for (var i = 0, wi = end - Nb; i < end; i += Nb, wi -= Nb) {
if (i === 0 || i === end - Nb) {
wnew[i] = w[wi];
wnew[i + 1] = w[wi + 3];
wnew[i + 2] = w[wi + 2];
wnew[i + 3] = w[wi + 1];
} else {
for (var n = 0; n < Nb; ++n) {
tmp = w[wi + n];
wnew[i + (3 & -n)] = m0[sbox[tmp >>> 24]] ^ m1[sbox[tmp >>> 16 & 255]] ^ m2[sbox[tmp >>> 8 & 255]] ^ m3[sbox[tmp & 255]];
}
}
}
w = wnew;
}
return w;
}
function _updateBlock(w, input2, output, decrypt) {
var Nr = w.length / 4 - 1;
var m0, m1, m2, m3, sub2;
if (decrypt) {
m0 = imix[0];
m1 = imix[1];
m2 = imix[2];
m3 = imix[3];
sub2 = isbox;
} else {
m0 = mix[0];
m1 = mix[1];
m2 = mix[2];
m3 = mix[3];
sub2 = sbox;
}
var a, b, c, d, a2, b2, c2;
a = input2[0] ^ w[0];
b = input2[decrypt ? 3 : 1] ^ w[1];
c = input2[2] ^ w[2];
d = input2[decrypt ? 1 : 3] ^ w[3];
var i = 3;
for (var round2 = 1; round2 < Nr; ++round2) {
a2 = m0[a >>> 24] ^ m1[b >>> 16 & 255] ^ m2[c >>> 8 & 255] ^ m3[d & 255] ^ w[++i];
b2 = m0[b >>> 24] ^ m1[c >>> 16 & 255] ^ m2[d >>> 8 & 255] ^ m3[a & 255] ^ w[++i];
c2 = m0[c >>> 24] ^ m1[d >>> 16 & 255] ^ m2[a >>> 8 & 255] ^ m3[b & 255] ^ w[++i];
d = m0[d >>> 24] ^ m1[a >>> 16 & 255] ^ m2[b >>> 8 & 255] ^ m3[c & 255] ^ w[++i];
a = a2;
b = b2;
c = c2;
}
output[0] = sub2[a >>> 24] << 24 ^ sub2[b >>> 16 & 255] << 16 ^ sub2[c >>> 8 & 255] << 8 ^ sub2[d & 255] ^ w[++i];
output[decrypt ? 3 : 1] = sub2[b >>> 24] << 24 ^ sub2[c >>> 16 & 255] << 16 ^ sub2[d >>> 8 & 255] << 8 ^ sub2[a & 255] ^ w[++i];
output[2] = sub2[c >>> 24] << 24 ^ sub2[d >>> 16 & 255] << 16 ^ sub2[a >>> 8 & 255] << 8 ^ sub2[b & 255] ^ w[++i];
output[decrypt ? 1 : 3] = sub2[d >>> 24] << 24 ^ sub2[a >>> 16 & 255] << 16 ^ sub2[b >>> 8 & 255] << 8 ^ sub2[c & 255] ^ w[++i];
}
function _createCipher(options) {
options = options || {};
var mode = (options.mode || "CBC").toUpperCase();
var algorithm = "AES-" + mode;
var cipher;
if (options.decrypt) {
cipher = forge2.cipher.createDecipher(algorithm, options.key);
} else {
cipher = forge2.cipher.createCipher(algorithm, options.key);
}
var start = cipher.start;
cipher.start = function(iv, options2) {
var output = null;
if (options2 instanceof forge2.util.ByteBuffer) {
output = options2;
options2 = {};
}
options2 = options2 || {};
options2.output = output;
options2.iv = iv;
start.call(cipher, options2);
};
return cipher;
}
}
});
// node_modules/node-forge/lib/oids.js
var require_oids = __commonJS({
"node_modules/node-forge/lib/oids.js"(exports2, module2) {
"use strict";
var forge2 = require_forge();
forge2.pki = forge2.pki || {};
var oids = module2.exports = forge2.pki.oids = forge2.oids = forge2.oids || {};
function _IN(id, name2) {
oids[id] = name2;
oids[name2] = id;
}
function _I_(id, name2) {
oids[id] = name2;
}
_IN("1.2.840.113549.1.1.1", "rsaEncryption");
_IN("1.2.840.113549.1.1.4", "md5WithRSAEncryption");
_IN("1.2.840.113549.1.1.5", "sha1WithRSAEncryption");
_IN("1.2.840.113549.1.1.7", "RSAES-OAEP");
_IN("1.2.840.113549.1.1.8", "mgf1");
_IN("1.2.840.113549.1.1.9", "pSpecified");
_IN("1.2.840.113549.1.1.10", "RSASSA-PSS");
_IN("1.2.840.113549.1.1.11", "sha256WithRSAEncryption");
_IN("1.2.840.113549.1.1.12", "sha384WithRSAEncryption");
_IN("1.2.840.113549.1.1.13", "sha512WithRSAEncryption");
_IN("1.3.101.112", "EdDSA25519");
_IN("1.2.840.10040.4.3", "dsa-with-sha1");
_IN("1.3.14.3.2.7", "desCBC");
_IN("1.3.14.3.2.26", "sha1");
_IN("1.3.14.3.2.29", "sha1WithRSASignature");
_IN("2.16.840.1.101.3.4.2.1", "sha256");
_IN("2.16.840.1.101.3.4.2.2", "sha384");
_IN("2.16.840.1.101.3.4.2.3", "sha512");
_IN("2.16.840.1.101.3.4.2.4", "sha224");
_IN("2.16.840.1.101.3.4.2.5", "sha512-224");
_IN("2.16.840.1.101.3.4.2.6", "sha512-256");
_IN("1.2.840.113549.2.2", "md2");
_IN("1.2.840.113549.2.5", "md5");
_IN("1.2.840.113549.1.7.1", "data");
_IN("1.2.840.113549.1.7.2", "signedData");
_IN("1.2.840.113549.1.7.3", "envelopedData");
_IN("1.2.840.113549.1.7.4", "signedAndEnvelopedData");
_IN("1.2.840.113549.1.7.5", "digestedData");
_IN("1.2.840.113549.1.7.6", "encryptedData");
_IN("1.2.840.113549.1.9.1", "emailAddress");
_IN("1.2.840.113549.1.9.2", "unstructuredName");
_IN("1.2.840.113549.1.9.3", "contentType");
_IN("1.2.840.113549.1.9.4", "messageDigest");
_IN("1.2.840.113549.1.9.5", "signingTime");
_IN("1.2.840.113549.1.9.6", "counterSignature");
_IN("1.2.840.113549.1.9.7", "challengePassword");
_IN("1.2.840.113549.1.9.8", "unstructuredAddress");
_IN("1.2.840.113549.1.9.14", "extensionRequest");
_IN("1.2.840.113549.1.9.20", "friendlyName");
_IN("1.2.840.113549.1.9.21", "localKeyId");
_IN("1.2.840.113549.1.9.22.1", "x509Certificate");
_IN("1.2.840.113549.1.12.10.1.1", "keyBag");
_IN("1.2.840.113549.1.12.10.1.2", "pkcs8ShroudedKeyBag");
_IN("1.2.840.113549.1.12.10.1.3", "certBag");
_IN("1.2.840.113549.1.12.10.1.4", "crlBag");
_IN("1.2.840.113549.1.12.10.1.5", "secretBag");
_IN("1.2.840.113549.1.12.10.1.6", "safeContentsBag");
_IN("1.2.840.113549.1.5.13", "pkcs5PBES2");
_IN("1.2.840.113549.1.5.12", "pkcs5PBKDF2");
_IN("1.2.840.113549.1.12.1.1", "pbeWithSHAAnd128BitRC4");
_IN("1.2.840.113549.1.12.1.2", "pbeWithSHAAnd40BitRC4");
_IN("1.2.840.113549.1.12.1.3", "pbeWithSHAAnd3-KeyTripleDES-CBC");
_IN("1.2.840.113549.1.12.1.4", "pbeWithSHAAnd2-KeyTripleDES-CBC");
_IN("1.2.840.113549.1.12.1.5", "pbeWithSHAAnd128BitRC2-CBC");
_IN("1.2.840.113549.1.12.1.6", "pbewithSHAAnd40BitRC2-CBC");
_IN("1.2.840.113549.2.7", "hmacWithSHA1");
_IN("1.2.840.113549.2.8", "hmacWithSHA224");
_IN("1.2.840.113549.2.9", "hmacWithSHA256");
_IN("1.2.840.113549.2.10", "hmacWithSHA384");
_IN("1.2.840.113549.2.11", "hmacWithSHA512");
_IN("1.2.840.113549.3.7", "des-EDE3-CBC");
_IN("2.16.840.1.101.3.4.1.2", "aes128-CBC");
_IN("2.16.840.1.101.3.4.1.22", "aes192-CBC");
_IN("2.16.840.1.101.3.4.1.42", "aes256-CBC");
_IN("2.5.4.3", "commonName");
_IN("2.5.4.4", "surname");
_IN("2.5.4.5", "serialNumber");
_IN("2.5.4.6", "countryName");
_IN("2.5.4.7", "localityName");
_IN("2.5.4.8", "stateOrProvinceName");
_IN("2.5.4.9", "streetAddress");
_IN("2.5.4.10", "organizationName");
_IN("2.5.4.11", "organizationalUnitName");
_IN("2.5.4.12", "title");
_IN("2.5.4.13", "description");
_IN("2.5.4.15", "businessCategory");
_IN("2.5.4.17", "postalCode");
_IN("2.5.4.42", "givenName");
_IN("1.3.6.1.4.1.311.60.2.1.2", "jurisdictionOfIncorporationStateOrProvinceName");
_IN("1.3.6.1.4.1.311.60.2.1.3", "jurisdictionOfIncorporationCountryName");
_IN("2.16.840.1.113730.1.1", "nsCertType");
_IN("2.16.840.1.113730.1.13", "nsComment");
_I_("2.5.29.1", "authorityKeyIdentifier");
_I_("2.5.29.2", "keyAttributes");
_I_("2.5.29.3", "certificatePolicies");
_I_("2.5.29.4", "keyUsageRestriction");
_I_("2.5.29.5", "policyMapping");
_I_("2.5.29.6", "subtreesConstraint");
_I_("2.5.29.7", "subjectAltName");
_I_("2.5.29.8", "issuerAltName");
_I_("2.5.29.9", "subjectDirectoryAttributes");
_I_("2.5.29.10", "basicConstraints");
_I_("2.5.29.11", "nameConstraints");
_I_("2.5.29.12", "policyConstraints");
_I_("2.5.29.13", "basicConstraints");
_IN("2.5.29.14", "subjectKeyIdentifier");
_IN("2.5.29.15", "keyUsage");
_I_("2.5.29.16", "privateKeyUsagePeriod");
_IN("2.5.29.17", "subjectAltName");
_IN("2.5.29.18", "issuerAltName");
_IN("2.5.29.19", "basicConstraints");
_I_("2.5.29.20", "cRLNumber");
_I_("2.5.29.21", "cRLReason");
_I_("2.5.29.22", "expirationDate");
_I_("2.5.29.23", "instructionCode");
_I_("2.5.29.24", "invalidityDate");
_I_("2.5.29.25", "cRLDistributionPoints");
_I_("2.5.29.26", "issuingDistributionPoint");
_I_("2.5.29.27", "deltaCRLIndicator");
_I_("2.5.29.28", "issuingDistributionPoint");
_I_("2.5.29.29", "certificateIssuer");
_I_("2.5.29.30", "nameConstraints");
_IN("2.5.29.31", "cRLDistributionPoints");
_IN("2.5.29.32", "certificatePolicies");
_I_("2.5.29.33", "policyMappings");
_I_("2.5.29.34", "policyConstraints");
_IN("2.5.29.35", "authorityKeyIdentifier");
_I_("2.5.29.36", "policyConstraints");
_IN("2.5.29.37", "extKeyUsage");
_I_("2.5.29.46", "freshestCRL");
_I_("2.5.29.54", "inhibitAnyPolicy");
_IN("1.3.6.1.4.1.11129.2.4.2", "timestampList");
_IN("1.3.6.1.5.5.7.1.1", "authorityInfoAccess");
_IN("1.3.6.1.5.5.7.3.1", "serverAuth");
_IN("1.3.6.1.5.5.7.3.2", "clientAuth");
_IN("1.3.6.1.5.5.7.3.3", "codeSigning");
_IN("1.3.6.1.5.5.7.3.4", "emailProtection");
_IN("1.3.6.1.5.5.7.3.8", "timeStamping");
}
});
// node_modules/node-forge/lib/asn1.js
var require_asn1 = __commonJS({
"node_modules/node-forge/lib/asn1.js"(exports2, module2) {
"use strict";
var forge2 = require_forge();
require_util();
require_oids();
var asn1 = module2.exports = forge2.asn1 = forge2.asn1 || {};
asn1.Class = {
UNIVERSAL: 0,
APPLICATION: 64,
CONTEXT_SPECIFIC: 128,
PRIVATE: 192
};
asn1.Type = {
NONE: 0,
BOOLEAN: 1,
INTEGER: 2,
BITSTRING: 3,
OCTETSTRING: 4,
NULL: 5,
OID: 6,
ODESC: 7,
EXTERNAL: 8,
REAL: 9,
ENUMERATED: 10,
EMBEDDED: 11,
UTF8: 12,
ROID: 13,
SEQUENCE: 16,
SET: 17,
PRINTABLESTRING: 19,
IA5STRING: 22,
UTCTIME: 23,
GENERALIZEDTIME: 24,
BMPSTRING: 30
};
asn1.create = function(tagClass, type, constructed, value2, options) {
if (forge2.util.isArray(value2)) {
var tmp = [];
for (var i = 0; i < value2.length; ++i) {
if (value2[i] !== void 0) {
tmp.push(value2[i]);
}
}
value2 = tmp;
}
var obj = {
tagClass,
type,
constructed,
composed: constructed || forge2.util.isArray(value2),
value: value2
};
if (options && "bitStringContents" in options) {
obj.bitStringContents = options.bitStringContents;
obj.original = asn1.copy(obj);
}
return obj;
};
asn1.copy = function(obj, options) {
var copy;
if (forge2.util.isArray(obj)) {
copy = [];
for (var i = 0; i < obj.length; ++i) {
copy.push(asn1.copy(obj[i], options));
}
return copy;
}
if (typeof obj === "string") {
return obj;
}
copy = {
tagClass: obj.tagClass,
type: obj.type,
constructed: obj.constructed,
composed: obj.composed,
value: asn1.copy(obj.value, options)
};
if (options && !options.excludeBitStringContents) {
copy.bitStringContents = obj.bitStringContents;
}
return copy;
};
asn1.equals = function(obj1, obj2, options) {
if (forge2.util.isArray(obj1)) {
if (!forge2.util.isArray(obj2)) {
return false;
}
if (obj1.length !== obj2.length) {
return false;
}
for (var i = 0; i < obj1.length; ++i) {
if (!asn1.equals(obj1[i], obj2[i])) {
return false;
}
}
return true;
}
if (typeof obj1 !== typeof obj2) {
return false;
}
if (typeof obj1 === "string") {
return obj1 === obj2;
}
var equal = obj1.tagClass === obj2.tagClass && obj1.type === obj2.type && obj1.constructed === obj2.constructed && obj1.composed === obj2.composed && asn1.equals(obj1.value, obj2.value);
if (options && options.includeBitStringContents) {
equal = equal && obj1.bitStringContents === obj2.bitStringContents;
}
return equal;
};
asn1.getBerValueLength = function(b) {
var b2 = b.getByte();
if (b2 === 128) {
return void 0;
}
var length2;
var longForm = b2 & 128;
if (!longForm) {
length2 = b2;
} else {
length2 = b.getInt((b2 & 127) << 3);
}
return length2;
};
function _checkBufferLength(bytes, remaining, n) {
if (n > remaining) {
var error = new Error("Too few bytes to parse DER.");
error.available = bytes.length();
error.remaining = remaining;
error.requested = n;
throw error;
}
}
var _getValueLength = function(bytes, remaining) {
var b2 = bytes.getByte();
remaining--;
if (b2 === 128) {
return void 0;
}
var length2;
var longForm = b2 & 128;
if (!longForm) {
length2 = b2;
} else {
var longFormBytes = b2 & 127;
_checkBufferLength(bytes, remaining, longFormBytes);
length2 = bytes.getInt(longFormBytes << 3);
}
if (length2 < 0) {
throw new Error("Negative length: " + length2);
}
return length2;
};
asn1.fromDer = function(bytes, options) {
if (options === void 0) {
options = {
strict: true,
parseAllBytes: true,
decodeBitStrings: true
};
}
if (typeof options === "boolean") {
options = {
strict: options,
parseAllBytes: true,
decodeBitStrings: true
};
}
if (!("strict" in options)) {
options.strict = true;
}
if (!("parseAllBytes" in options)) {
options.parseAllBytes = true;
}
if (!("decodeBitStrings" in options)) {
options.decodeBitStrings = true;
}
if (typeof bytes === "string") {
bytes = forge2.util.createBuffer(bytes);
}
var byteCount = bytes.length();
var value2 = _fromDer(bytes, bytes.length(), 0, options);
if (options.parseAllBytes && bytes.length() !== 0) {
var error = new Error("Unparsed DER bytes remain after ASN.1 parsing.");
error.byteCount = byteCount;
error.remaining = bytes.length();
throw error;
}
return value2;
};
function _fromDer(bytes, remaining, depth, options) {
var start;
_checkBufferLength(bytes, remaining, 2);
var b1 = bytes.getByte();
remaining--;
var tagClass = b1 & 192;
var type = b1 & 31;
start = bytes.length();
var length2 = _getValueLength(bytes, remaining);
remaining -= start - bytes.length();
if (length2 !== void 0 && length2 > remaining) {
if (options.strict) {
var error = new Error("Too few bytes to read ASN.1 value.");
error.available = bytes.length();
error.remaining = remaining;
error.requested = length2;
throw error;
}
length2 = remaining;
}
var value2;
var bitStringContents;
var constructed = (b1 & 32) === 32;
if (constructed) {
value2 = [];
if (length2 === void 0) {
for (; ; ) {
_checkBufferLength(bytes, remaining, 2);
if (bytes.bytes(2) === String.fromCharCode(0, 0)) {
bytes.getBytes(2);
remaining -= 2;
break;
}
start = bytes.length();
value2.push(_fromDer(bytes, remaining, depth + 1, options));
remaining -= start - bytes.length();
}
} else {
while (length2 > 0) {
start = bytes.length();
value2.push(_fromDer(bytes, length2, depth + 1, options));
remaining -= start - bytes.length();
length2 -= start - bytes.length();
}
}
}
if (value2 === void 0 && tagClass === asn1.Class.UNIVERSAL && type === asn1.Type.BITSTRING) {
bitStringContents = bytes.bytes(length2);
}
if (value2 === void 0 && options.decodeBitStrings && tagClass === asn1.Class.UNIVERSAL && // FIXME: OCTET STRINGs not yet supported here
// .. other parts of forge expect to decode OCTET STRINGs manually
type === asn1.Type.BITSTRING && length2 > 1) {
var savedRead = bytes.read;
var savedRemaining = remaining;
var unused = 0;
if (type === asn1.Type.BITSTRING) {
_checkBufferLength(bytes, remaining, 1);
unused = bytes.getByte();
remaining--;
}
if (unused === 0) {
try {
start = bytes.length();
var subOptions = {
// enforce strict mode to avoid parsing ASN.1 from plain data
strict: true,
decodeBitStrings: true
};
var composed = _fromDer(bytes, remaining, depth + 1, subOptions);
var used = start - bytes.length();
remaining -= used;
if (type == asn1.Type.BITSTRING) {
used++;
}
var tc = composed.tagClass;
if (used === length2 && (tc === asn1.Class.UNIVERSAL || tc === asn1.Class.CONTEXT_SPECIFIC)) {
value2 = [composed];
}
} catch (ex) {
}
}
if (value2 === void 0) {
bytes.read = savedRead;
remaining = savedRemaining;
}
}
if (value2 === void 0) {
if (length2 === void 0) {
if (options.strict) {
throw new Error("Non-constructed ASN.1 object of indefinite length.");
}
length2 = remaining;
}
if (type === asn1.Type.BMPSTRING) {
value2 = "";
for (; length2 > 0; length2 -= 2) {
_checkBufferLength(bytes, remaining, 2);
value2 += String.fromCharCode(bytes.getInt16());
remaining -= 2;
}
} else {
value2 = bytes.getBytes(length2);
remaining -= length2;
}
}
var asn1Options = bitStringContents === void 0 ? null : {
bitStringContents
};
return asn1.create(tagClass, type, constructed, value2, asn1Options);
}
asn1.toDer = function(obj) {
var bytes = forge2.util.createBuffer();
var b1 = obj.tagClass | obj.type;
var value2 = forge2.util.createBuffer();
var useBitStringContents = false;
if ("bitStringContents" in obj) {
useBitStringContents = true;
if (obj.original) {
useBitStringContents = asn1.equals(obj, obj.original);
}
}
if (useBitStringContents) {
value2.putBytes(obj.bitStringContents);
} else if (obj.composed) {
if (obj.constructed) {
b1 |= 32;
} else {
value2.putByte(0);
}
for (var i = 0; i < obj.value.length; ++i) {
if (obj.value[i] !== void 0) {
value2.putBuffer(asn1.toDer(obj.value[i]));
}
}
} else {
if (obj.type === asn1.Type.BMPSTRING) {
for (var i = 0; i < obj.value.length; ++i) {
value2.putInt16(obj.value.charCodeAt(i));
}
} else {
if (obj.type === asn1.Type.INTEGER && obj.value.length > 1 && // leading 0x00 for positive integer
(obj.value.charCodeAt(0) === 0 && (obj.value.charCodeAt(1) & 128) === 0 || // leading 0xFF for negative integer
obj.value.charCodeAt(0) === 255 && (obj.value.charCodeAt(1) & 128) === 128)) {
value2.putBytes(obj.value.substr(1));
} else {
value2.putBytes(obj.value);
}
}
}
bytes.putByte(b1);
if (value2.length() <= 127) {
bytes.putByte(value2.length() & 127);
} else {
var len = value2.length();
var lenBytes = "";
do {
lenBytes += String.fromCharCode(len & 255);
len = len >>> 8;
} while (len > 0);
bytes.putByte(lenBytes.length | 128);
for (var i = lenBytes.length - 1; i >= 0; --i) {
bytes.putByte(lenBytes.charCodeAt(i));
}
}
bytes.putBuffer(value2);
return bytes;
};
asn1.oidToDer = function(oid) {
var values = oid.split(".");
var bytes = forge2.util.createBuffer();
bytes.putByte(40 * parseInt(values[0], 10) + parseInt(values[1], 10));
var last4, valueBytes, value2, b;
for (var i = 2; i < values.length; ++i) {
last4 = true;
valueBytes = [];
value2 = parseInt(values[i], 10);
do {
b = value2 & 127;
value2 = value2 >>> 7;
if (!last4) {
b |= 128;
}
valueBytes.push(b);
last4 = false;
} while (value2 > 0);
for (var n = valueBytes.length - 1; n >= 0; --n) {
bytes.putByte(valueBytes[n]);
}
}
return bytes;
};
asn1.derToOid = function(bytes) {
var oid;
if (typeof bytes === "string") {
bytes = forge2.util.createBuffer(bytes);
}
var b = bytes.getByte();
oid = Math.floor(b / 40) + "." + b % 40;
var value2 = 0;
while (bytes.length() > 0) {
b = bytes.getByte();
value2 = value2 << 7;
if (b & 128) {
value2 += b & 127;
} else {
oid += "." + (value2 + b);
value2 = 0;
}
}
return oid;
};
asn1.utcTimeToDate = function(utc) {
var date = /* @__PURE__ */ new Date();
var year = parseInt(utc.substr(0, 2), 10);
year = year >= 50 ? 1900 + year : 2e3 + year;
var MM = parseInt(utc.substr(2, 2), 10) - 1;
var DD = parseInt(utc.substr(4, 2), 10);
var hh = parseInt(utc.substr(6, 2), 10);
var mm = parseInt(utc.substr(8, 2), 10);
var ss = 0;
if (utc.length > 11) {
var c = utc.charAt(10);
var end = 10;
if (c !== "+" && c !== "-") {
ss = parseInt(utc.substr(10, 2), 10);
end += 2;
}
}
date.setUTCFullYear(year, MM, DD);
date.setUTCHours(hh, mm, ss, 0);
if (end) {
c = utc.charAt(end);
if (c === "+" || c === "-") {
var hhoffset = parseInt(utc.substr(end + 1, 2), 10);
var mmoffset = parseInt(utc.substr(end + 4, 2), 10);
var offset = hhoffset * 60 + mmoffset;
offset *= 6e4;
if (c === "+") {
date.setTime(+date - offset);
} else {
date.setTime(+date + offset);
}
}
}
return date;
};
asn1.generalizedTimeToDate = function(gentime) {
var date = /* @__PURE__ */ new Date();
var YYYY = parseInt(gentime.substr(0, 4), 10);
var MM = parseInt(gentime.substr(4, 2), 10) - 1;
var DD = parseInt(gentime.substr(6, 2), 10);
var hh = parseInt(gentime.substr(8, 2), 10);
var mm = parseInt(gentime.substr(10, 2), 10);
var ss = parseInt(gentime.substr(12, 2), 10);
var fff = 0;
var offset = 0;
var isUTC = false;
if (gentime.charAt(gentime.length - 1) === "Z") {
isUTC = true;
}
var end = gentime.length - 5, c = gentime.charAt(end);
if (c === "+" || c === "-") {
var hhoffset = parseInt(gentime.substr(end + 1, 2), 10);
var mmoffset = parseInt(gentime.substr(end + 4, 2), 10);
offset = hhoffset * 60 + mmoffset;
offset *= 6e4;
if (c === "+") {
offset *= -1;
}
isUTC = true;
}
if (gentime.charAt(14) === ".") {
fff = parseFloat(gentime.substr(14), 10) * 1e3;
}
if (isUTC) {
date.setUTCFullYear(YYYY, MM, DD);
date.setUTCHours(hh, mm, ss, fff);
date.setTime(+date + offset);
} else {
date.setFullYear(YYYY, MM, DD);
date.setHours(hh, mm, ss, fff);
}
return date;
};
asn1.dateToUtcTime = function(date) {
if (typeof date === "string") {
return date;
}
var rval = "";
var format = [];
format.push(("" + date.getUTCFullYear()).substr(2));
format.push("" + (date.getUTCMonth() + 1));
format.push("" + date.getUTCDate());
format.push("" + date.getUTCHours());
format.push("" + date.getUTCMinutes());
format.push("" + date.getUTCSeconds());
for (var i = 0; i < format.length; ++i) {
if (format[i].length < 2) {
rval += "0";
}
rval += format[i];
}
rval += "Z";
return rval;
};
asn1.dateToGeneralizedTime = function(date) {
if (typeof date === "string") {
return date;
}
var rval = "";
var format = [];
format.push("" + date.getUTCFullYear());
format.push("" + (date.getUTCMonth() + 1));
format.push("" + date.getUTCDate());
format.push("" + date.getUTCHours());
format.push("" + date.getUTCMinutes());
format.push("" + date.getUTCSeconds());
for (var i = 0; i < format.length; ++i) {
if (format[i].length < 2) {
rval += "0";
}
rval += format[i];
}
rval += "Z";
return rval;
};
asn1.integerToDer = function(x) {
var rval = forge2.util.createBuffer();
if (x >= -128 && x < 128) {
return rval.putSignedInt(x, 8);
}
if (x >= -32768 && x < 32768) {
return rval.putSignedInt(x, 16);
}
if (x >= -8388608 && x < 8388608) {
return rval.putSignedInt(x, 24);
}
if (x >= -2147483648 && x < 2147483648) {
return rval.putSignedInt(x, 32);
}
var error = new Error("Integer too large; max is 32-bits.");
error.integer = x;
throw error;
};
asn1.derToInteger = function(bytes) {
if (typeof bytes === "string") {
bytes = forge2.util.createBuffer(bytes);
}
var n = bytes.length() * 8;
if (n > 32) {
throw new Error("Integer too large; max is 32-bits.");
}
return bytes.getSignedInt(n);
};
asn1.validate = function(obj, v, capture, errors) {
var rval = false;
if ((obj.tagClass === v.tagClass || typeof v.tagClass === "undefined") && (obj.type === v.type || typeof v.type === "undefined")) {
if (obj.constructed === v.constructed || typeof v.constructed === "undefined") {
rval = true;
if (v.value && forge2.util.isArray(v.value)) {
var j = 0;
for (var i = 0; rval && i < v.value.length; ++i) {
rval = v.value[i].optional || false;
if (obj.value[j]) {
rval = asn1.validate(obj.value[j], v.value[i], capture, errors);
if (rval) {
++j;
} else if (v.value[i].optional) {
rval = true;
}
}
if (!rval && errors) {
errors.push(
"[" + v.name + '] Tag class "' + v.tagClass + '", type "' + v.type + '" expected value length "' + v.value.length + '", got "' + obj.value.length + '"'
);
}
}
}
if (rval && capture) {
if (v.capture) {
capture[v.capture] = obj.value;
}
if (v.captureAsn1) {
capture[v.captureAsn1] = obj;
}
if (v.captureBitStringContents && "bitStringContents" in obj) {
capture[v.captureBitStringContents] = obj.bitStringContents;
}
if (v.captureBitStringValue && "bitStringContents" in obj) {
var value2;
if (obj.bitStringContents.length < 2) {
capture[v.captureBitStringValue] = "";
} else {
var unused = obj.bitStringContents.charCodeAt(0);
if (unused !== 0) {
throw new Error(
"captureBitStringValue only supported for zero unused bits"
);
}
capture[v.captureBitStringValue] = obj.bitStringContents.slice(1);
}
}
}
} else if (errors) {
errors.push(
"[" + v.name + '] Expected constructed "' + v.constructed + '", got "' + obj.constructed + '"'
);
}
} else if (errors) {
if (obj.tagClass !== v.tagClass) {
errors.push(
"[" + v.name + '] Expected tag class "' + v.tagClass + '", got "' + obj.tagClass + '"'
);
}
if (obj.type !== v.type) {
errors.push(
"[" + v.name + '] Expected type "' + v.type + '", got "' + obj.type + '"'
);
}
}
return rval;
};
var _nonLatinRegex = /[^\\u0000-\\u00ff]/;
asn1.prettyPrint = function(obj, level, indentation) {
var rval = "";
level = level || 0;
indentation = indentation || 2;
if (level > 0) {
rval += "\n";
}
var indent = "";
for (var i = 0; i < level * indentation; ++i) {
indent += " ";
}
rval += indent + "Tag: ";
switch (obj.tagClass) {
case asn1.Class.UNIVERSAL:
rval += "Universal:";
break;
case asn1.Class.APPLICATION:
rval += "Application:";
break;
case asn1.Class.CONTEXT_SPECIFIC:
rval += "Context-Specific:";
break;
case asn1.Class.PRIVATE:
rval += "Private:";
break;
}
if (obj.tagClass === asn1.Class.UNIVERSAL) {
rval += obj.type;
switch (obj.type) {
case asn1.Type.NONE:
rval += " (None)";
break;
case asn1.Type.BOOLEAN:
rval += " (Boolean)";
break;
case asn1.Type.INTEGER:
rval += " (Integer)";
break;
case asn1.Type.BITSTRING:
rval += " (Bit string)";
break;
case asn1.Type.OCTETSTRING:
rval += " (Octet string)";
break;
case asn1.Type.NULL:
rval += " (Null)";
break;
case asn1.Type.OID:
rval += " (Object Identifier)";
break;
case asn1.Type.ODESC:
rval += " (Object Descriptor)";
break;
case asn1.Type.EXTERNAL:
rval += " (External or Instance of)";
break;
case asn1.Type.REAL:
rval += " (Real)";
break;
case asn1.Type.ENUMERATED:
rval += " (Enumerated)";
break;
case asn1.Type.EMBEDDED:
rval += " (Embedded PDV)";
break;
case asn1.Type.UTF8:
rval += " (UTF8)";
break;
case asn1.Type.ROID:
rval += " (Relative Object Identifier)";
break;
case asn1.Type.SEQUENCE:
rval += " (Sequence)";
break;
case asn1.Type.SET:
rval += " (Set)";
break;
case asn1.Type.PRINTABLESTRING:
rval += " (Printable String)";
break;
case asn1.Type.IA5String:
rval += " (IA5String (ASCII))";
break;
case asn1.Type.UTCTIME:
rval += " (UTC time)";
break;
case asn1.Type.GENERALIZEDTIME:
rval += " (Generalized time)";
break;
case asn1.Type.BMPSTRING:
rval += " (BMP String)";
break;
}
} else {
rval += obj.type;
}
rval += "\n";
rval += indent + "Constructed: " + obj.constructed + "\n";
if (obj.composed) {
var subvalues = 0;
var sub2 = "";
for (var i = 0; i < obj.value.length; ++i) {
if (obj.value[i] !== void 0) {
subvalues += 1;
sub2 += asn1.prettyPrint(obj.value[i], level + 1, indentation);
if (i + 1 < obj.value.length) {
sub2 += ",";
}
}
}
rval += indent + "Sub values: " + subvalues + sub2;
} else {
rval += indent + "Value: ";
if (obj.type === asn1.Type.OID) {
var oid = asn1.derToOid(obj.value);
rval += oid;
if (forge2.pki && forge2.pki.oids) {
if (oid in forge2.pki.oids) {
rval += " (" + forge2.pki.oids[oid] + ") ";
}
}
}
if (obj.type === asn1.Type.INTEGER) {
try {
rval += asn1.derToInteger(obj.value);
} catch (ex) {
rval += "0x" + forge2.util.bytesToHex(obj.value);
}
} else if (obj.type === asn1.Type.BITSTRING) {
if (obj.value.length > 1) {
rval += "0x" + forge2.util.bytesToHex(obj.value.slice(1));
} else {
rval += "(none)";
}
if (obj.value.length > 0) {
var unused = obj.value.charCodeAt(0);
if (unused == 1) {
rval += " (1 unused bit shown)";
} else if (unused > 1) {
rval += " (" + unused + " unused bits shown)";
}
}
} else if (obj.type === asn1.Type.OCTETSTRING) {
if (!_nonLatinRegex.test(obj.value)) {
rval += "(" + obj.value + ") ";
}
rval += "0x" + forge2.util.bytesToHex(obj.value);
} else if (obj.type === asn1.Type.UTF8) {
try {
rval += forge2.util.decodeUtf8(obj.value);
} catch (e) {
if (e.message === "URI malformed") {
rval += "0x" + forge2.util.bytesToHex(obj.value) + " (malformed UTF8)";
} else {
throw e;
}
}
} else if (obj.type === asn1.Type.PRINTABLESTRING || obj.type === asn1.Type.IA5String) {
rval += obj.value;
} else if (_nonLatinRegex.test(obj.value)) {
rval += "0x" + forge2.util.bytesToHex(obj.value);
} else if (obj.value.length === 0) {
rval += "[null]";
} else {
rval += obj.value;
}
}
return rval;
};
}
});
// node_modules/node-forge/lib/md.js
var require_md = __commonJS({
"node_modules/node-forge/lib/md.js"(exports2, module2) {
"use strict";
var forge2 = require_forge();
module2.exports = forge2.md = forge2.md || {};
forge2.md.algorithms = forge2.md.algorithms || {};
}
});
// node_modules/node-forge/lib/hmac.js
var require_hmac = __commonJS({
"node_modules/node-forge/lib/hmac.js"(exports2, module2) {
"use strict";
var forge2 = require_forge();
require_md();
require_util();
var hmac = module2.exports = forge2.hmac = forge2.hmac || {};
hmac.create = function() {
var _key = null;
var _md = null;
var _ipadding = null;
var _opadding = null;
var ctx = {};
ctx.start = function(md, key2) {
if (md !== null) {
if (typeof md === "string") {
md = md.toLowerCase();
if (md in forge2.md.algorithms) {
_md = forge2.md.algorithms[md].create();
} else {
throw new Error('Unknown hash algorithm "' + md + '"');
}
} else {
_md = md;
}
}
if (key2 === null) {
key2 = _key;
} else {
if (typeof key2 === "string") {
key2 = forge2.util.createBuffer(key2);
} else if (forge2.util.isArray(key2)) {
var tmp = key2;
key2 = forge2.util.createBuffer();
for (var i = 0; i < tmp.length; ++i) {
key2.putByte(tmp[i]);
}
}
var keylen = key2.length();
if (keylen > _md.blockLength) {
_md.start();
_md.update(key2.bytes());
key2 = _md.digest();
}
_ipadding = forge2.util.createBuffer();
_opadding = forge2.util.createBuffer();
keylen = key2.length();
for (var i = 0; i < keylen; ++i) {
var tmp = key2.at(i);
_ipadding.putByte(54 ^ tmp);
_opadding.putByte(92 ^ tmp);
}
if (keylen < _md.blockLength) {
var tmp = _md.blockLength - keylen;
for (var i = 0; i < tmp; ++i) {
_ipadding.putByte(54);
_opadding.putByte(92);
}
}
_key = key2;
_ipadding = _ipadding.bytes();
_opadding = _opadding.bytes();
}
_md.start();
_md.update(_ipadding);
};
ctx.update = function(bytes) {
_md.update(bytes);
};
ctx.getMac = function() {
var inner = _md.digest().bytes();
_md.start();
_md.update(_opadding);
_md.update(inner);
return _md.digest();
};
ctx.digest = ctx.getMac;
return ctx;
};
}
});
// node_modules/node-forge/lib/md5.js
var require_md5 = __commonJS({
"node_modules/node-forge/lib/md5.js"(exports2, module2) {
"use strict";
var forge2 = require_forge();
require_md();
require_util();
var md5 = module2.exports = forge2.md5 = forge2.md5 || {};
forge2.md.md5 = forge2.md.algorithms.md5 = md5;
md5.create = function() {
if (!_initialized) {
_init();
}
var _state = null;
var _input = forge2.util.createBuffer();
var _w = new Array(16);
var md = {
algorithm: "md5",
blockLength: 64,
digestLength: 16,
// 56-bit length of message so far (does not including padding)
messageLength: 0,
// true message length
fullMessageLength: null,
// size of message length in bytes
messageLengthSize: 8
};
md.start = function() {
md.messageLength = 0;
md.fullMessageLength = md.messageLength64 = [];
var int32s = md.messageLengthSize / 4;
for (var i = 0; i < int32s; ++i) {
md.fullMessageLength.push(0);
}
_input = forge2.util.createBuffer();
_state = {
h0: 1732584193,
h1: 4023233417,
h2: 2562383102,
h3: 271733878
};
return md;
};
md.start();
md.update = function(msg, encoding) {
if (encoding === "utf8") {
msg = forge2.util.encodeUtf8(msg);
}
var len = msg.length;
md.messageLength += len;
len = [len / 4294967296 >>> 0, len >>> 0];
for (var i = md.fullMessageLength.length - 1; i >= 0; --i) {
md.fullMessageLength[i] += len[1];
len[1] = len[0] + (md.fullMessageLength[i] / 4294967296 >>> 0);
md.fullMessageLength[i] = md.fullMessageLength[i] >>> 0;
len[0] = len[1] / 4294967296 >>> 0;
}
_input.putBytes(msg);
_update(_state, _w, _input);
if (_input.read > 2048 || _input.length() === 0) {
_input.compact();
}
return md;
};
md.digest = function() {
var finalBlock = forge2.util.createBuffer();
finalBlock.putBytes(_input.bytes());
var remaining = md.fullMessageLength[md.fullMessageLength.length - 1] + md.messageLengthSize;
var overflow = remaining & md.blockLength - 1;
finalBlock.putBytes(_padding.substr(0, md.blockLength - overflow));
var bits, carry = 0;
for (var i = md.fullMessageLength.length - 1; i >= 0; --i) {
bits = md.fullMessageLength[i] * 8 + carry;
carry = bits / 4294967296 >>> 0;
finalBlock.putInt32Le(bits >>> 0);
}
var s2 = {
h0: _state.h0,
h1: _state.h1,
h2: _state.h2,
h3: _state.h3
};
_update(s2, _w, finalBlock);
var rval = forge2.util.createBuffer();
rval.putInt32Le(s2.h0);
rval.putInt32Le(s2.h1);
rval.putInt32Le(s2.h2);
rval.putInt32Le(s2.h3);
return rval;
};
return md;
};
var _padding = null;
var _g = null;
var _r = null;
var _k = null;
var _initialized = false;
function _init() {
_padding = String.fromCharCode(128);
_padding += forge2.util.fillString(String.fromCharCode(0), 64);
_g = [
0,
1,
2,
3,
4,
5,
6,
7,
8,
9,
10,
11,
12,
13,
14,
15,
1,
6,
11,
0,
5,
10,
15,
4,
9,
14,
3,
8,
13,
2,
7,
12,
5,
8,
11,
14,
1,
4,
7,
10,
13,
0,
3,
6,
9,
12,
15,
2,
0,
7,
14,
5,
12,
3,
10,
1,
8,
15,
6,
13,
4,
11,
2,
9
];
_r = [
7,
12,
17,
22,
7,
12,
17,
22,
7,
12,
17,
22,
7,
12,
17,
22,
5,
9,
14,
20,
5,
9,
14,
20,
5,
9,
14,
20,
5,
9,
14,
20,
4,
11,
16,
23,
4,
11,
16,
23,
4,
11,
16,
23,
4,
11,
16,
23,
6,
10,
15,
21,
6,
10,
15,
21,
6,
10,
15,
21,
6,
10,
15,
21
];
_k = new Array(64);
for (var i = 0; i < 64; ++i) {
_k[i] = Math.floor(Math.abs(Math.sin(i + 1)) * 4294967296);
}
_initialized = true;
}
function _update(s, w, bytes) {
var t, a, b, c, d, f, r, i;
var len = bytes.length();
while (len >= 64) {
a = s.h0;
b = s.h1;
c = s.h2;
d = s.h3;
for (i = 0; i < 16; ++i) {
w[i] = bytes.getInt32Le();
f = d ^ b & (c ^ d);
t = a + f + _k[i] + w[i];
r = _r[i];
a = d;
d = c;
c = b;
b += t << r | t >>> 32 - r;
}
for (; i < 32; ++i) {
f = c ^ d & (b ^ c);
t = a + f + _k[i] + w[_g[i]];
r = _r[i];
a = d;
d = c;
c = b;
b += t << r | t >>> 32 - r;
}
for (; i < 48; ++i) {
f = b ^ c ^ d;
t = a + f + _k[i] + w[_g[i]];
r = _r[i];
a = d;
d = c;
c = b;
b += t << r | t >>> 32 - r;
}
for (; i < 64; ++i) {
f = c ^ (b | ~d);
t = a + f + _k[i] + w[_g[i]];
r = _r[i];
a = d;
d = c;
c = b;
b += t << r | t >>> 32 - r;
}
s.h0 = s.h0 + a | 0;
s.h1 = s.h1 + b | 0;
s.h2 = s.h2 + c | 0;
s.h3 = s.h3 + d | 0;
len -= 64;
}
}
}
});
// node_modules/node-forge/lib/pem.js
var require_pem = __commonJS({
"node_modules/node-forge/lib/pem.js"(exports2, module2) {
"use strict";
var forge2 = require_forge();
require_util();
var pem = module2.exports = forge2.pem = forge2.pem || {};
pem.encode = function(msg, options) {
options = options || {};
var rval = "-----BEGIN " + msg.type + "-----\r\n";
var header;
if (msg.procType) {
header = {
name: "Proc-Type",
values: [String(msg.procType.version), msg.procType.type]
};
rval += foldHeader(header);
}
if (msg.contentDomain) {
header = { name: "Content-Domain", values: [msg.contentDomain] };
rval += foldHeader(header);
}
if (msg.dekInfo) {
header = { name: "DEK-Info", values: [msg.dekInfo.algorithm] };
if (msg.dekInfo.parameters) {
header.values.push(msg.dekInfo.parameters);
}
rval += foldHeader(header);
}
if (msg.headers) {
for (var i = 0; i < msg.headers.length; ++i) {
rval += foldHeader(msg.headers[i]);
}
}
if (msg.procType) {
rval += "\r\n";
}
rval += forge2.util.encode64(msg.body, options.maxline || 64) + "\r\n";
rval += "-----END " + msg.type + "-----\r\n";
return rval;
};
pem.decode = function(str) {
var rval = [];
var rMessage = /\s*-----BEGIN ([A-Z0-9- ]+)-----\r?\n?([\x21-\x7e\s]+?(?:\r?\n\r?\n))?([:A-Za-z0-9+\/=\s]+?)-----END \1-----/g;
var rHeader = /([\x21-\x7e]+):\s*([\x21-\x7e\s^:]+)/;
var rCRLF = /\r?\n/;
var match2;
while (true) {
match2 = rMessage.exec(str);
if (!match2) {
break;
}
var type = match2[1];
if (type === "NEW CERTIFICATE REQUEST") {
type = "CERTIFICATE REQUEST";
}
var msg = {
type,
procType: null,
contentDomain: null,
dekInfo: null,
headers: [],
body: forge2.util.decode64(match2[3])
};
rval.push(msg);
if (!match2[2]) {
continue;
}
var lines = match2[2].split(rCRLF);
var li = 0;
while (match2 && li < lines.length) {
var line = lines[li].replace(/\s+$/, "");
for (var nl = li + 1; nl < lines.length; ++nl) {
var next = lines[nl];
if (!/\s/.test(next[0])) {
break;
}
line += next;
li = nl;
}
match2 = line.match(rHeader);
if (match2) {
var header = { name: match2[1], values: [] };
var values = match2[2].split(",");
for (var vi = 0; vi < values.length; ++vi) {
header.values.push(ltrim(values[vi]));
}
if (!msg.procType) {
if (header.name !== "Proc-Type") {
throw new Error('Invalid PEM formatted message. The first encapsulated header must be "Proc-Type".');
} else if (header.values.length !== 2) {
throw new Error('Invalid PEM formatted message. The "Proc-Type" header must have two subfields.');
}
msg.procType = { version: values[0], type: values[1] };
} else if (!msg.contentDomain && header.name === "Content-Domain") {
msg.contentDomain = values[0] || "";
} else if (!msg.dekInfo && header.name === "DEK-Info") {
if (header.values.length === 0) {
throw new Error('Invalid PEM formatted message. The "DEK-Info" header must have at least one subfield.');
}
msg.dekInfo = { algorithm: values[0], parameters: values[1] || null };
} else {
msg.headers.push(header);
}
}
++li;
}
if (msg.procType === "ENCRYPTED" && !msg.dekInfo) {
throw new Error('Invalid PEM formatted message. The "DEK-Info" header must be present if "Proc-Type" is "ENCRYPTED".');
}
}
if (rval.length === 0) {
throw new Error("Invalid PEM formatted message.");
}
return rval;
};
function foldHeader(header) {
var rval = header.name + ": ";
var values = [];
var insertSpace = function(match2, $1) {
return " " + $1;
};
for (var i = 0; i < header.values.length; ++i) {
values.push(header.values[i].replace(/^(\S+\r\n)/, insertSpace));
}
rval += values.join(",") + "\r\n";
var length2 = 0;
var candidate = -1;
for (var i = 0; i < rval.length; ++i, ++length2) {
if (length2 > 65 && candidate !== -1) {
var insert = rval[candidate];
if (insert === ",") {
++candidate;
rval = rval.substr(0, candidate) + "\r\n " + rval.substr(candidate);
} else {
rval = rval.substr(0, candidate) + "\r\n" + insert + rval.substr(candidate + 1);
}
length2 = i - candidate - 1;
candidate = -1;
++i;
} else if (rval[i] === " " || rval[i] === " " || rval[i] === ",") {
candidate = i;
}
}
return rval;
}
function ltrim(str) {
return str.replace(/^\s+/, "");
}
}
});
// node_modules/node-forge/lib/des.js
var require_des = __commonJS({
"node_modules/node-forge/lib/des.js"(exports2, module2) {
"use strict";
var forge2 = require_forge();
require_cipher();
require_cipherModes();
require_util();
module2.exports = forge2.des = forge2.des || {};
forge2.des.startEncrypting = function(key2, iv, output, mode) {
var cipher = _createCipher({
key: key2,
output,
decrypt: false,
mode: mode || (iv === null ? "ECB" : "CBC")
});
cipher.start(iv);
return cipher;
};
forge2.des.createEncryptionCipher = function(key2, mode) {
return _createCipher({
key: key2,
output: null,
decrypt: false,
mode
});
};
forge2.des.startDecrypting = function(key2, iv, output, mode) {
var cipher = _createCipher({
key: key2,
output,
decrypt: true,
mode: mode || (iv === null ? "ECB" : "CBC")
});
cipher.start(iv);
return cipher;
};
forge2.des.createDecryptionCipher = function(key2, mode) {
return _createCipher({
key: key2,
output: null,
decrypt: true,
mode
});
};
forge2.des.Algorithm = function(name2, mode) {
var self2 = this;
self2.name = name2;
self2.mode = new mode({
blockSize: 8,
cipher: {
encrypt: function(inBlock, outBlock) {
return _updateBlock(self2._keys, inBlock, outBlock, false);
},
decrypt: function(inBlock, outBlock) {
return _updateBlock(self2._keys, inBlock, outBlock, true);
}
}
});
self2._init = false;
};
forge2.des.Algorithm.prototype.initialize = function(options) {
if (this._init) {
return;
}
var key2 = forge2.util.createBuffer(options.key);
if (this.name.indexOf("3DES") === 0) {
if (key2.length() !== 24) {
throw new Error("Invalid Triple-DES key size: " + key2.length() * 8);
}
}
this._keys = _createKeys(key2);
this._init = true;
};
registerAlgorithm("DES-ECB", forge2.cipher.modes.ecb);
registerAlgorithm("DES-CBC", forge2.cipher.modes.cbc);
registerAlgorithm("DES-CFB", forge2.cipher.modes.cfb);
registerAlgorithm("DES-OFB", forge2.cipher.modes.ofb);
registerAlgorithm("DES-CTR", forge2.cipher.modes.ctr);
registerAlgorithm("3DES-ECB", forge2.cipher.modes.ecb);
registerAlgorithm("3DES-CBC", forge2.cipher.modes.cbc);
registerAlgorithm("3DES-CFB", forge2.cipher.modes.cfb);
registerAlgorithm("3DES-OFB", forge2.cipher.modes.ofb);
registerAlgorithm("3DES-CTR", forge2.cipher.modes.ctr);
function registerAlgorithm(name2, mode) {
var factory = function() {
return new forge2.des.Algorithm(name2, mode);
};
forge2.cipher.registerAlgorithm(name2, factory);
}
var spfunction1 = [16843776, 0, 65536, 16843780, 16842756, 66564, 4, 65536, 1024, 16843776, 16843780, 1024, 16778244, 16842756, 16777216, 4, 1028, 16778240, 16778240, 66560, 66560, 16842752, 16842752, 16778244, 65540, 16777220, 16777220, 65540, 0, 1028, 66564, 16777216, 65536, 16843780, 4, 16842752, 16843776, 16777216, 16777216, 1024, 16842756, 65536, 66560, 16777220, 1024, 4, 16778244, 66564, 16843780, 65540, 16842752, 16778244, 16777220, 1028, 66564, 16843776, 1028, 16778240, 16778240, 0, 65540, 66560, 0, 16842756];
var spfunction2 = [-2146402272, -2147450880, 32768, 1081376, 1048576, 32, -2146435040, -2147450848, -2147483616, -2146402272, -2146402304, -2147483648, -2147450880, 1048576, 32, -2146435040, 1081344, 1048608, -2147450848, 0, -2147483648, 32768, 1081376, -2146435072, 1048608, -2147483616, 0, 1081344, 32800, -2146402304, -2146435072, 32800, 0, 1081376, -2146435040, 1048576, -2147450848, -2146435072, -2146402304, 32768, -2146435072, -2147450880, 32, -2146402272, 1081376, 32, 32768, -2147483648, 32800, -2146402304, 1048576, -2147483616, 1048608, -2147450848, -2147483616, 1048608, 1081344, 0, -2147450880, 32800, -2147483648, -2146435040, -2146402272, 1081344];
var spfunction3 = [520, 134349312, 0, 134348808, 134218240, 0, 131592, 134218240, 131080, 134217736, 134217736, 131072, 134349320, 131080, 134348800, 520, 134217728, 8, 134349312, 512, 131584, 134348800, 134348808, 131592, 134218248, 131584, 131072, 134218248, 8, 134349320, 512, 134217728, 134349312, 134217728, 131080, 520, 131072, 134349312, 134218240, 0, 512, 131080, 134349320, 134218240, 134217736, 512, 0, 134348808, 134218248, 131072, 134217728, 134349320, 8, 131592, 131584, 134217736, 134348800, 134218248, 520, 134348800, 131592, 8, 134348808, 131584];
var spfunction4 = [8396801, 8321, 8321, 128, 8396928, 8388737, 8388609, 8193, 0, 8396800, 8396800, 8396929, 129, 0, 8388736, 8388609, 1, 8192, 8388608, 8396801, 128, 8388608, 8193, 8320, 8388737, 1, 8320, 8388736, 8192, 8396928, 8396929, 129, 8388736, 8388609, 8396800, 8396929, 129, 0, 0, 8396800, 8320, 8388736, 8388737, 1, 8396801, 8321, 8321, 128, 8396929, 129, 1, 8192, 8388609, 8193, 8396928, 8388737, 8193, 8320, 8388608, 8396801, 128, 8388608, 8192, 8396928];
var spfunction5 = [256, 34078976, 34078720, 1107296512, 524288, 256, 1073741824, 34078720, 1074266368, 524288, 33554688, 1074266368, 1107296512, 1107820544, 524544, 1073741824, 33554432, 1074266112, 1074266112, 0, 1073742080, 1107820800, 1107820800, 33554688, 1107820544, 1073742080, 0, 1107296256, 34078976, 33554432, 1107296256, 524544, 524288, 1107296512, 256, 33554432, 1073741824, 34078720, 1107296512, 1074266368, 33554688, 1073741824, 1107820544, 34078976, 1074266368, 256, 33554432, 1107820544, 1107820800, 524544, 1107296256, 1107820800, 34078720, 0, 1074266112, 1107296256, 524544, 33554688, 1073742080, 524288, 0, 1074266112, 34078976, 1073742080];
var spfunction6 = [536870928, 541065216, 16384, 541081616, 541065216, 16, 541081616, 4194304, 536887296, 4210704, 4194304, 536870928, 4194320, 536887296, 536870912, 16400, 0, 4194320, 536887312, 16384, 4210688, 536887312, 16, 541065232, 541065232, 0, 4210704, 541081600, 16400, 4210688, 541081600, 536870912, 536887296, 16, 541065232, 4210688, 541081616, 4194304, 16400, 536870928, 4194304, 536887296, 536870912, 16400, 536870928, 541081616, 4210688, 541065216, 4210704, 541081600, 0, 541065232, 16, 16384, 541065216, 4210704, 16384, 4194320, 536887312, 0, 541081600, 536870912, 4194320, 536887312];
var spfunction7 = [2097152, 69206018, 67110914, 0, 2048, 67110914, 2099202, 69208064, 69208066, 2097152, 0, 67108866, 2, 67108864, 69206018, 2050, 67110912, 2099202, 2097154, 67110912, 67108866, 69206016, 69208064, 2097154, 69206016, 2048, 2050, 69208066, 2099200, 2, 67108864, 2099200, 67108864, 2099200, 2097152, 67110914, 67110914, 69206018, 69206018, 2, 2097154, 67108864, 67110912, 2097152, 69208064, 2050, 2099202, 69208064, 2050, 67108866, 69208066, 69206016, 2099200, 0, 2, 69208066, 0, 2099202, 69206016, 2048, 67108866, 67110912, 2048, 2097154];
var spfunction8 = [268439616, 4096, 262144, 268701760, 268435456, 268439616, 64, 268435456, 262208, 268697600, 268701760, 266240, 268701696, 266304, 4096, 64, 268697600, 268435520, 268439552, 4160, 266240, 262208, 268697664, 268701696, 4160, 0, 0, 268697664, 268435520, 268439552, 266304, 262144, 266304, 262144, 268701696, 4096, 64, 268697664, 4096, 266304, 268439552, 64, 268435520, 268697600, 268697664, 268435456, 262144, 268439616, 0, 268701760, 262208, 268435520, 268697600, 268439552, 268439616, 0, 268701760, 266240, 266240, 4160, 4160, 262208, 268435456, 268701696];
function _createKeys(key2) {
var pc2bytes0 = [0, 4, 536870912, 536870916, 65536, 65540, 536936448, 536936452, 512, 516, 536871424, 536871428, 66048, 66052, 536936960, 536936964], pc2bytes1 = [0, 1, 1048576, 1048577, 67108864, 67108865, 68157440, 68157441, 256, 257, 1048832, 1048833, 67109120, 67109121, 68157696, 68157697], pc2bytes2 = [0, 8, 2048, 2056, 16777216, 16777224, 16779264, 16779272, 0, 8, 2048, 2056, 16777216, 16777224, 16779264, 16779272], pc2bytes3 = [0, 2097152, 134217728, 136314880, 8192, 2105344, 134225920, 136323072, 131072, 2228224, 134348800, 136445952, 139264, 2236416, 134356992, 136454144], pc2bytes4 = [0, 262144, 16, 262160, 0, 262144, 16, 262160, 4096, 266240, 4112, 266256, 4096, 266240, 4112, 266256], pc2bytes5 = [0, 1024, 32, 1056, 0, 1024, 32, 1056, 33554432, 33555456, 33554464, 33555488, 33554432, 33555456, 33554464, 33555488], pc2bytes6 = [0, 268435456, 524288, 268959744, 2, 268435458, 524290, 268959746, 0, 268435456, 524288, 268959744, 2, 268435458, 524290, 268959746], pc2bytes7 = [0, 65536, 2048, 67584, 536870912, 536936448, 536872960, 536938496, 131072, 196608, 133120, 198656, 537001984, 537067520, 537004032, 537069568], pc2bytes8 = [0, 262144, 0, 262144, 2, 262146, 2, 262146, 33554432, 33816576, 33554432, 33816576, 33554434, 33816578, 33554434, 33816578], pc2bytes9 = [0, 268435456, 8, 268435464, 0, 268435456, 8, 268435464, 1024, 268436480, 1032, 268436488, 1024, 268436480, 1032, 268436488], pc2bytes10 = [0, 32, 0, 32, 1048576, 1048608, 1048576, 1048608, 8192, 8224, 8192, 8224, 1056768, 1056800, 1056768, 1056800], pc2bytes11 = [0, 16777216, 512, 16777728, 2097152, 18874368, 2097664, 18874880, 67108864, 83886080, 67109376, 83886592, 69206016, 85983232, 69206528, 85983744], pc2bytes12 = [0, 4096, 134217728, 134221824, 524288, 528384, 134742016, 134746112, 16, 4112, 134217744, 134221840, 524304, 528400, 134742032, 134746128], pc2bytes13 = [0, 4, 256, 260, 0, 4, 256, 260, 1, 5, 257, 261, 1, 5, 257, 261];
var iterations = key2.length() > 8 ? 3 : 1;
var keys = [];
var shifts = [0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0];
var n = 0, tmp;
for (var j = 0; j < iterations; j++) {
var left = key2.getInt32();
var right = key2.getInt32();
tmp = (left >>> 4 ^ right) & 252645135;
right ^= tmp;
left ^= tmp << 4;
tmp = (right >>> -16 ^ left) & 65535;
left ^= tmp;
right ^= tmp << -16;
tmp = (left >>> 2 ^ right) & 858993459;
right ^= tmp;
left ^= tmp << 2;
tmp = (right >>> -16 ^ left) & 65535;
left ^= tmp;
right ^= tmp << -16;
tmp = (left >>> 1 ^ right) & 1431655765;
right ^= tmp;
left ^= tmp << 1;
tmp = (right >>> 8 ^ left) & 16711935;
left ^= tmp;
right ^= tmp << 8;
tmp = (left >>> 1 ^ right) & 1431655765;
right ^= tmp;
left ^= tmp << 1;
tmp = left << 8 | right >>> 20 & 240;
left = right << 24 | right << 8 & 16711680 | right >>> 8 & 65280 | right >>> 24 & 240;
right = tmp;
for (var i = 0; i < shifts.length; ++i) {
if (shifts[i]) {
left = left << 2 | left >>> 26;
right = right << 2 | right >>> 26;
} else {
left = left << 1 | left >>> 27;
right = right << 1 | right >>> 27;
}
left &= -15;
right &= -15;
var lefttmp = pc2bytes0[left >>> 28] | pc2bytes1[left >>> 24 & 15] | pc2bytes2[left >>> 20 & 15] | pc2bytes3[left >>> 16 & 15] | pc2bytes4[left >>> 12 & 15] | pc2bytes5[left >>> 8 & 15] | pc2bytes6[left >>> 4 & 15];
var righttmp = pc2bytes7[right >>> 28] | pc2bytes8[right >>> 24 & 15] | pc2bytes9[right >>> 20 & 15] | pc2bytes10[right >>> 16 & 15] | pc2bytes11[right >>> 12 & 15] | pc2bytes12[right >>> 8 & 15] | pc2bytes13[right >>> 4 & 15];
tmp = (righttmp >>> 16 ^ lefttmp) & 65535;
keys[n++] = lefttmp ^ tmp;
keys[n++] = righttmp ^ tmp << 16;
}
}
return keys;
}
function _updateBlock(keys, input2, output, decrypt) {
var iterations = keys.length === 32 ? 3 : 9;
var looping;
if (iterations === 3) {
looping = decrypt ? [30, -2, -2] : [0, 32, 2];
} else {
looping = decrypt ? [94, 62, -2, 32, 64, 2, 30, -2, -2] : [0, 32, 2, 62, 30, -2, 64, 96, 2];
}
var tmp;
var left = input2[0];
var right = input2[1];
tmp = (left >>> 4 ^ right) & 252645135;
right ^= tmp;
left ^= tmp << 4;
tmp = (left >>> 16 ^ right) & 65535;
right ^= tmp;
left ^= tmp << 16;
tmp = (right >>> 2 ^ left) & 858993459;
left ^= tmp;
right ^= tmp << 2;
tmp = (right >>> 8 ^ left) & 16711935;
left ^= tmp;
right ^= tmp << 8;
tmp = (left >>> 1 ^ right) & 1431655765;
right ^= tmp;
left ^= tmp << 1;
left = left << 1 | left >>> 31;
right = right << 1 | right >>> 31;
for (var j = 0; j < iterations; j += 3) {
var endloop = looping[j + 1];
var loopinc = looping[j + 2];
for (var i = looping[j]; i != endloop; i += loopinc) {
var right1 = right ^ keys[i];
var right2 = (right >>> 4 | right << 28) ^ keys[i + 1];
tmp = left;
left = right;
right = tmp ^ (spfunction2[right1 >>> 24 & 63] | spfunction4[right1 >>> 16 & 63] | spfunction6[right1 >>> 8 & 63] | spfunction8[right1 & 63] | spfunction1[right2 >>> 24 & 63] | spfunction3[right2 >>> 16 & 63] | spfunction5[right2 >>> 8 & 63] | spfunction7[right2 & 63]);
}
tmp = left;
left = right;
right = tmp;
}
left = left >>> 1 | left << 31;
right = right >>> 1 | right << 31;
tmp = (left >>> 1 ^ right) & 1431655765;
right ^= tmp;
left ^= tmp << 1;
tmp = (right >>> 8 ^ left) & 16711935;
left ^= tmp;
right ^= tmp << 8;
tmp = (right >>> 2 ^ left) & 858993459;
left ^= tmp;
right ^= tmp << 2;
tmp = (left >>> 16 ^ right) & 65535;
right ^= tmp;
left ^= tmp << 16;
tmp = (left >>> 4 ^ right) & 252645135;
right ^= tmp;
left ^= tmp << 4;
output[0] = left;
output[1] = right;
}
function _createCipher(options) {
options = options || {};
var mode = (options.mode || "CBC").toUpperCase();
var algorithm = "DES-" + mode;
var cipher;
if (options.decrypt) {
cipher = forge2.cipher.createDecipher(algorithm, options.key);
} else {
cipher = forge2.cipher.createCipher(algorithm, options.key);
}
var start = cipher.start;
cipher.start = function(iv, options2) {
var output = null;
if (options2 instanceof forge2.util.ByteBuffer) {
output = options2;
options2 = {};
}
options2 = options2 || {};
options2.output = output;
options2.iv = iv;
start.call(cipher, options2);
};
return cipher;
}
}
});
// (disabled):crypto
var require_crypto = __commonJS({
"(disabled):crypto"() {
"use strict";
}
});
// node_modules/node-forge/lib/pbkdf2.js
var require_pbkdf2 = __commonJS({
"node_modules/node-forge/lib/pbkdf2.js"(exports2, module2) {
"use strict";
var forge2 = require_forge();
require_hmac();
require_md();
require_util();
var pkcs5 = forge2.pkcs5 = forge2.pkcs5 || {};
var crypto2;
if (forge2.util.isNodejs && !forge2.options.usePureJavaScript) {
crypto2 = require_crypto();
}
module2.exports = forge2.pbkdf2 = pkcs5.pbkdf2 = function(p, s, c, dkLen, md, callback) {
if (typeof md === "function") {
callback = md;
md = null;
}
if (forge2.util.isNodejs && !forge2.options.usePureJavaScript && crypto2.pbkdf2 && (md === null || typeof md !== "object") && (crypto2.pbkdf2Sync.length > 4 || (!md || md === "sha1"))) {
if (typeof md !== "string") {
md = "sha1";
}
p = Buffer.from(p, "binary");
s = Buffer.from(s, "binary");
if (!callback) {
if (crypto2.pbkdf2Sync.length === 4) {
return crypto2.pbkdf2Sync(p, s, c, dkLen).toString("binary");
}
return crypto2.pbkdf2Sync(p, s, c, dkLen, md).toString("binary");
}
if (crypto2.pbkdf2Sync.length === 4) {
return crypto2.pbkdf2(p, s, c, dkLen, function(err2, key2) {
if (err2) {
return callback(err2);
}
callback(null, key2.toString("binary"));
});
}
return crypto2.pbkdf2(p, s, c, dkLen, md, function(err2, key2) {
if (err2) {
return callback(err2);
}
callback(null, key2.toString("binary"));
});
}
if (typeof md === "undefined" || md === null) {
md = "sha1";
}
if (typeof md === "string") {
if (!(md in forge2.md.algorithms)) {
throw new Error("Unknown hash algorithm: " + md);
}
md = forge2.md[md].create();
}
var hLen = md.digestLength;
if (dkLen > 4294967295 * hLen) {
var err = new Error("Derived key is too long.");
if (callback) {
return callback(err);
}
throw err;
}
var len = Math.ceil(dkLen / hLen);
var r = dkLen - (len - 1) * hLen;
var prf = forge2.hmac.create();
prf.start(md, p);
var dk = "";
var xor, u_c, u_c1;
if (!callback) {
for (var i = 1; i <= len; ++i) {
prf.start(null, null);
prf.update(s);
prf.update(forge2.util.int32ToBytes(i));
xor = u_c1 = prf.digest().getBytes();
for (var j = 2; j <= c; ++j) {
prf.start(null, null);
prf.update(u_c1);
u_c = prf.digest().getBytes();
xor = forge2.util.xorBytes(xor, u_c, hLen);
u_c1 = u_c;
}
dk += i < len ? xor : xor.substr(0, r);
}
return dk;
}
var i = 1, j;
function outer() {
if (i > len) {
return callback(null, dk);
}
prf.start(null, null);
prf.update(s);
prf.update(forge2.util.int32ToBytes(i));
xor = u_c1 = prf.digest().getBytes();
j = 2;
inner();
}
function inner() {
if (j <= c) {
prf.start(null, null);
prf.update(u_c1);
u_c = prf.digest().getBytes();
xor = forge2.util.xorBytes(xor, u_c, hLen);
u_c1 = u_c;
++j;
return forge2.util.setImmediate(inner);
}
dk += i < len ? xor : xor.substr(0, r);
++i;
outer();
}
outer();
};
}
});
// node_modules/node-forge/lib/sha256.js
var require_sha256 = __commonJS({
"node_modules/node-forge/lib/sha256.js"(exports2, module2) {
"use strict";
var forge2 = require_forge();
require_md();
require_util();
var sha256 = module2.exports = forge2.sha256 = forge2.sha256 || {};
forge2.md.sha256 = forge2.md.algorithms.sha256 = sha256;
sha256.create = function() {
if (!_initialized) {
_init();
}
var _state = null;
var _input = forge2.util.createBuffer();
var _w = new Array(64);
var md = {
algorithm: "sha256",
blockLength: 64,
digestLength: 32,
// 56-bit length of message so far (does not including padding)
messageLength: 0,
// true message length
fullMessageLength: null,
// size of message length in bytes
messageLengthSize: 8
};
md.start = function() {
md.messageLength = 0;
md.fullMessageLength = md.messageLength64 = [];
var int32s = md.messageLengthSize / 4;
for (var i = 0; i < int32s; ++i) {
md.fullMessageLength.push(0);
}
_input = forge2.util.createBuffer();
_state = {
h0: 1779033703,
h1: 3144134277,
h2: 1013904242,
h3: 2773480762,
h4: 1359893119,
h5: 2600822924,
h6: 528734635,
h7: 1541459225
};
return md;
};
md.start();
md.update = function(msg, encoding) {
if (encoding === "utf8") {
msg = forge2.util.encodeUtf8(msg);
}
var len = msg.length;
md.messageLength += len;
len = [len / 4294967296 >>> 0, len >>> 0];
for (var i = md.fullMessageLength.length - 1; i >= 0; --i) {
md.fullMessageLength[i] += len[1];
len[1] = len[0] + (md.fullMessageLength[i] / 4294967296 >>> 0);
md.fullMessageLength[i] = md.fullMessageLength[i] >>> 0;
len[0] = len[1] / 4294967296 >>> 0;
}
_input.putBytes(msg);
_update(_state, _w, _input);
if (_input.read > 2048 || _input.length() === 0) {
_input.compact();
}
return md;
};
md.digest = function() {
var finalBlock = forge2.util.createBuffer();
finalBlock.putBytes(_input.bytes());
var remaining = md.fullMessageLength[md.fullMessageLength.length - 1] + md.messageLengthSize;
var overflow = remaining & md.blockLength - 1;
finalBlock.putBytes(_padding.substr(0, md.blockLength - overflow));
var next, carry;
var bits = md.fullMessageLength[0] * 8;
for (var i = 0; i < md.fullMessageLength.length - 1; ++i) {
next = md.fullMessageLength[i + 1] * 8;
carry = next / 4294967296 >>> 0;
bits += carry;
finalBlock.putInt32(bits >>> 0);
bits = next >>> 0;
}
finalBlock.putInt32(bits);
var s2 = {
h0: _state.h0,
h1: _state.h1,
h2: _state.h2,
h3: _state.h3,
h4: _state.h4,
h5: _state.h5,
h6: _state.h6,
h7: _state.h7
};
_update(s2, _w, finalBlock);
var rval = forge2.util.createBuffer();
rval.putInt32(s2.h0);
rval.putInt32(s2.h1);
rval.putInt32(s2.h2);
rval.putInt32(s2.h3);
rval.putInt32(s2.h4);
rval.putInt32(s2.h5);
rval.putInt32(s2.h6);
rval.putInt32(s2.h7);
return rval;
};
return md;
};
var _padding = null;
var _initialized = false;
var _k = null;
function _init() {
_padding = String.fromCharCode(128);
_padding += forge2.util.fillString(String.fromCharCode(0), 64);
_k = [
1116352408,
1899447441,
3049323471,
3921009573,
961987163,
1508970993,
2453635748,
2870763221,
3624381080,
310598401,
607225278,
1426881987,
1925078388,
2162078206,
2614888103,
3248222580,
3835390401,
4022224774,
264347078,
604807628,
770255983,
1249150122,
1555081692,
1996064986,
2554220882,
2821834349,
2952996808,
3210313671,
3336571891,
3584528711,
113926993,
338241895,
666307205,
773529912,
1294757372,
1396182291,
1695183700,
1986661051,
2177026350,
2456956037,
2730485921,
2820302411,
3259730800,
3345764771,
3516065817,
3600352804,
4094571909,
275423344,
430227734,
506948616,
659060556,
883997877,
958139571,
1322822218,
1537002063,
1747873779,
1955562222,
2024104815,
2227730452,
2361852424,
2428436474,
2756734187,
3204031479,
3329325298
];
_initialized = true;
}
function _update(s, w, bytes) {
var t1, t2, s0, s1, ch, maj, i, a, b, c, d, e, f, g, h;
var len = bytes.length();
while (len >= 64) {
for (i = 0; i < 16; ++i) {
w[i] = bytes.getInt32();
}
for (; i < 64; ++i) {
t1 = w[i - 2];
t1 = (t1 >>> 17 | t1 << 15) ^ (t1 >>> 19 | t1 << 13) ^ t1 >>> 10;
t2 = w[i - 15];
t2 = (t2 >>> 7 | t2 << 25) ^ (t2 >>> 18 | t2 << 14) ^ t2 >>> 3;
w[i] = t1 + w[i - 7] + t2 + w[i - 16] | 0;
}
a = s.h0;
b = s.h1;
c = s.h2;
d = s.h3;
e = s.h4;
f = s.h5;
g = s.h6;
h = s.h7;
for (i = 0; i < 64; ++i) {
s1 = (e >>> 6 | e << 26) ^ (e >>> 11 | e << 21) ^ (e >>> 25 | e << 7);
ch = g ^ e & (f ^ g);
s0 = (a >>> 2 | a << 30) ^ (a >>> 13 | a << 19) ^ (a >>> 22 | a << 10);
maj = a & b | c & (a ^ b);
t1 = h + s1 + ch + _k[i] + w[i];
t2 = s0 + maj;
h = g;
g = f;
f = e;
e = d + t1 >>> 0;
d = c;
c = b;
b = a;
a = t1 + t2 >>> 0;
}
s.h0 = s.h0 + a | 0;
s.h1 = s.h1 + b | 0;
s.h2 = s.h2 + c | 0;
s.h3 = s.h3 + d | 0;
s.h4 = s.h4 + e | 0;
s.h5 = s.h5 + f | 0;
s.h6 = s.h6 + g | 0;
s.h7 = s.h7 + h | 0;
len -= 64;
}
}
}
});
// node_modules/node-forge/lib/prng.js
var require_prng = __commonJS({
"node_modules/node-forge/lib/prng.js"(exports2, module2) {
"use strict";
var forge2 = require_forge();
require_util();
var _crypto = null;
if (forge2.util.isNodejs && !forge2.options.usePureJavaScript && !process.versions["node-webkit"]) {
_crypto = require_crypto();
}
var prng = module2.exports = forge2.prng = forge2.prng || {};
prng.create = function(plugin) {
var ctx = {
plugin,
key: null,
seed: null,
time: null,
// number of reseeds so far
reseeds: 0,
// amount of data generated so far
generated: 0,
// no initial key bytes
keyBytes: ""
};
var md = plugin.md;
var pools = new Array(32);
for (var i = 0; i < 32; ++i) {
pools[i] = md.create();
}
ctx.pools = pools;
ctx.pool = 0;
ctx.generate = function(count, callback) {
if (!callback) {
return ctx.generateSync(count);
}
var cipher = ctx.plugin.cipher;
var increment = ctx.plugin.increment;
var formatKey = ctx.plugin.formatKey;
var formatSeed = ctx.plugin.formatSeed;
var b = forge2.util.createBuffer();
ctx.key = null;
generate();
function generate(err) {
if (err) {
return callback(err);
}
if (b.length() >= count) {
return callback(null, b.getBytes(count));
}
if (ctx.generated > 1048575) {
ctx.key = null;
}
if (ctx.key === null) {
return forge2.util.nextTick(function() {
_reseed(generate);
});
}
var bytes = cipher(ctx.key, ctx.seed);
ctx.generated += bytes.length;
b.putBytes(bytes);
ctx.key = formatKey(cipher(ctx.key, increment(ctx.seed)));
ctx.seed = formatSeed(cipher(ctx.key, ctx.seed));
forge2.util.setImmediate(generate);
}
};
ctx.generateSync = function(count) {
var cipher = ctx.plugin.cipher;
var increment = ctx.plugin.increment;
var formatKey = ctx.plugin.formatKey;
var formatSeed = ctx.plugin.formatSeed;
ctx.key = null;
var b = forge2.util.createBuffer();
while (b.length() < count) {
if (ctx.generated > 1048575) {
ctx.key = null;
}
if (ctx.key === null) {
_reseedSync();
}
var bytes = cipher(ctx.key, ctx.seed);
ctx.generated += bytes.length;
b.putBytes(bytes);
ctx.key = formatKey(cipher(ctx.key, increment(ctx.seed)));
ctx.seed = formatSeed(cipher(ctx.key, ctx.seed));
}
return b.getBytes(count);
};
function _reseed(callback) {
if (ctx.pools[0].messageLength >= 32) {
_seed();
return callback();
}
var needed = 32 - ctx.pools[0].messageLength << 5;
ctx.seedFile(needed, function(err, bytes) {
if (err) {
return callback(err);
}
ctx.collect(bytes);
_seed();
callback();
});
}
function _reseedSync() {
if (ctx.pools[0].messageLength >= 32) {
return _seed();
}
var needed = 32 - ctx.pools[0].messageLength << 5;
ctx.collect(ctx.seedFileSync(needed));
_seed();
}
function _seed() {
ctx.reseeds = ctx.reseeds === 4294967295 ? 0 : ctx.reseeds + 1;
var md2 = ctx.plugin.md.create();
md2.update(ctx.keyBytes);
var _2powK = 1;
for (var k = 0; k < 32; ++k) {
if (ctx.reseeds % _2powK === 0) {
md2.update(ctx.pools[k].digest().getBytes());
ctx.pools[k].start();
}
_2powK = _2powK << 1;
}
ctx.keyBytes = md2.digest().getBytes();
md2.start();
md2.update(ctx.keyBytes);
var seedBytes = md2.digest().getBytes();
ctx.key = ctx.plugin.formatKey(ctx.keyBytes);
ctx.seed = ctx.plugin.formatSeed(seedBytes);
ctx.generated = 0;
}
function defaultSeedFile(needed) {
var getRandomValues2 = null;
var globalScope = forge2.util.globalScope;
var _crypto2 = globalScope.crypto || globalScope.msCrypto;
if (_crypto2 && _crypto2.getRandomValues) {
getRandomValues2 = function(arr) {
return _crypto2.getRandomValues(arr);
};
}
var b = forge2.util.createBuffer();
if (getRandomValues2) {
while (b.length() < needed) {
var count = Math.max(1, Math.min(needed - b.length(), 65536) / 4);
var entropy = new Uint32Array(Math.floor(count));
try {
getRandomValues2(entropy);
for (var i2 = 0; i2 < entropy.length; ++i2) {
b.putInt32(entropy[i2]);
}
} catch (e) {
if (!(typeof QuotaExceededError !== "undefined" && e instanceof QuotaExceededError)) {
throw e;
}
}
}
}
if (b.length() < needed) {
var hi, lo, next;
var seed = Math.floor(Math.random() * 65536);
while (b.length() < needed) {
lo = 16807 * (seed & 65535);
hi = 16807 * (seed >> 16);
lo += (hi & 32767) << 16;
lo += hi >> 15;
lo = (lo & 2147483647) + (lo >> 31);
seed = lo & 4294967295;
for (var i2 = 0; i2 < 3; ++i2) {
next = seed >>> (i2 << 3);
next ^= Math.floor(Math.random() * 256);
b.putByte(next & 255);
}
}
}
return b.getBytes(needed);
}
if (_crypto) {
ctx.seedFile = function(needed, callback) {
_crypto.randomBytes(needed, function(err, bytes) {
if (err) {
return callback(err);
}
callback(null, bytes.toString());
});
};
ctx.seedFileSync = function(needed) {
return _crypto.randomBytes(needed).toString();
};
} else {
ctx.seedFile = function(needed, callback) {
try {
callback(null, defaultSeedFile(needed));
} catch (e) {
callback(e);
}
};
ctx.seedFileSync = defaultSeedFile;
}
ctx.collect = function(bytes) {
var count = bytes.length;
for (var i2 = 0; i2 < count; ++i2) {
ctx.pools[ctx.pool].update(bytes.substr(i2, 1));
ctx.pool = ctx.pool === 31 ? 0 : ctx.pool + 1;
}
};
ctx.collectInt = function(i2, n) {
var bytes = "";
for (var x = 0; x < n; x += 8) {
bytes += String.fromCharCode(i2 >> x & 255);
}
ctx.collect(bytes);
};
ctx.registerWorker = function(worker) {
if (worker === self) {
ctx.seedFile = function(needed, callback) {
function listener2(e) {
var data2 = e.data;
if (data2.forge && data2.forge.prng) {
self.removeEventListener("message", listener2);
callback(data2.forge.prng.err, data2.forge.prng.bytes);
}
}
self.addEventListener("message", listener2);
self.postMessage({ forge: { prng: { needed } } });
};
} else {
var listener = function(e) {
var data2 = e.data;
if (data2.forge && data2.forge.prng) {
ctx.seedFile(data2.forge.prng.needed, function(err, bytes) {
worker.postMessage({ forge: { prng: { err, bytes } } });
});
}
};
worker.addEventListener("message", listener);
}
};
return ctx;
};
}
});
// node_modules/node-forge/lib/random.js
var require_random = __commonJS({
"node_modules/node-forge/lib/random.js"(exports2, module2) {
"use strict";
var forge2 = require_forge();
require_aes();
require_sha256();
require_prng();
require_util();
(function() {
if (forge2.random && forge2.random.getBytes) {
module2.exports = forge2.random;
return;
}
(function(jQuery2) {
var prng_aes = {};
var _prng_aes_output = new Array(4);
var _prng_aes_buffer = forge2.util.createBuffer();
prng_aes.formatKey = function(key3) {
var tmp = forge2.util.createBuffer(key3);
key3 = new Array(4);
key3[0] = tmp.getInt32();
key3[1] = tmp.getInt32();
key3[2] = tmp.getInt32();
key3[3] = tmp.getInt32();
return forge2.aes._expandKey(key3, false);
};
prng_aes.formatSeed = function(seed) {
var tmp = forge2.util.createBuffer(seed);
seed = new Array(4);
seed[0] = tmp.getInt32();
seed[1] = tmp.getInt32();
seed[2] = tmp.getInt32();
seed[3] = tmp.getInt32();
return seed;
};
prng_aes.cipher = function(key3, seed) {
forge2.aes._updateBlock(key3, seed, _prng_aes_output, false);
_prng_aes_buffer.putInt32(_prng_aes_output[0]);
_prng_aes_buffer.putInt32(_prng_aes_output[1]);
_prng_aes_buffer.putInt32(_prng_aes_output[2]);
_prng_aes_buffer.putInt32(_prng_aes_output[3]);
return _prng_aes_buffer.getBytes();
};
prng_aes.increment = function(seed) {
++seed[3];
return seed;
};
prng_aes.md = forge2.md.sha256;
function spawnPrng() {
var ctx = forge2.prng.create(prng_aes);
ctx.getBytes = function(count, callback) {
return ctx.generate(count, callback);
};
ctx.getBytesSync = function(count) {
return ctx.generate(count);
};
return ctx;
}
var _ctx = spawnPrng();
var getRandomValues2 = null;
var globalScope = forge2.util.globalScope;
var _crypto = globalScope.crypto || globalScope.msCrypto;
if (_crypto && _crypto.getRandomValues) {
getRandomValues2 = function(arr) {
return _crypto.getRandomValues(arr);
};
}
if (forge2.options.usePureJavaScript || !forge2.util.isNodejs && !getRandomValues2) {
if (typeof window === "undefined" || window.document === void 0) {
}
_ctx.collectInt(+/* @__PURE__ */ new Date(), 32);
if (typeof navigator !== "undefined") {
var _navBytes = "";
for (var key2 in navigator) {
try {
if (typeof navigator[key2] == "string") {
_navBytes += navigator[key2];
}
} catch (e) {
}
}
_ctx.collect(_navBytes);
_navBytes = null;
}
if (jQuery2) {
jQuery2().mousemove(function(e) {
_ctx.collectInt(e.clientX, 16);
_ctx.collectInt(e.clientY, 16);
});
jQuery2().keypress(function(e) {
_ctx.collectInt(e.charCode, 8);
});
}
}
if (!forge2.random) {
forge2.random = _ctx;
} else {
for (var key2 in _ctx) {
forge2.random[key2] = _ctx[key2];
}
}
forge2.random.createInstance = spawnPrng;
module2.exports = forge2.random;
})(typeof jQuery !== "undefined" ? jQuery : null);
})();
}
});
// node_modules/node-forge/lib/rc2.js
var require_rc2 = __commonJS({
"node_modules/node-forge/lib/rc2.js"(exports2, module2) {
"use strict";
var forge2 = require_forge();
require_util();
var piTable = [
217,
120,
249,
196,
25,
221,
181,
237,
40,
233,
253,
121,
74,
160,
216,
157,
198,
126,
55,
131,
43,
118,
83,
142,
98,
76,
100,
136,
68,
139,
251,
162,
23,
154,
89,
245,
135,
179,
79,
19,
97,
69,
109,
141,
9,
129,
125,
50,
189,
143,
64,
235,
134,
183,
123,
11,
240,
149,
33,
34,
92,
107,
78,
130,
84,
214,
101,
147,
206,
96,
178,
28,
115,
86,
192,
20,
167,
140,
241,
220,
18,
117,
202,
31,
59,
190,
228,
209,
66,
61,
212,
48,
163,
60,
182,
38,
111,
191,
14,
218,
70,
105,
7,
87,
39,
242,
29,
155,
188,
148,
67,
3,
248,
17,
199,
246,
144,
239,
62,
231,
6,
195,
213,
47,
200,
102,
30,
215,
8,
232,
234,
222,
128,
82,
238,
247,
132,
170,
114,
172,
53,
77,
106,
42,
150,
26,
210,
113,
90,
21,
73,
116,
75,
159,
208,
94,
4,
24,
164,
236,
194,
224,
65,
110,
15,
81,
203,
204,
36,
145,
175,
80,
161,
244,
112,
57,
153,
124,
58,
133,
35,
184,
180,
122,
252,
2,
54,
91,
37,
85,
151,
49,
45,
93,
250,
152,
227,
138,
146,
174,
5,
223,
41,
16,
103,
108,
186,
201,
211,
0,
230,
207,
225,
158,
168,
44,
99,
22,
1,
63,
88,
226,
137,
169,
13,
56,
52,
27,
171,
51,
255,
176,
187,
72,
12,
95,
185,
177,
205,
46,
197,
243,
219,
71,
229,
165,
156,
119,
10,
166,
32,
104,
254,
127,
193,
173
];
var s = [1, 2, 3, 5];
var rol = function(word, bits) {
return word << bits & 65535 | (word & 65535) >> 16 - bits;
};
var ror = function(word, bits) {
return (word & 65535) >> bits | word << 16 - bits & 65535;
};
module2.exports = forge2.rc2 = forge2.rc2 || {};
forge2.rc2.expandKey = function(key2, effKeyBits) {
if (typeof key2 === "string") {
key2 = forge2.util.createBuffer(key2);
}
effKeyBits = effKeyBits || 128;
var L = key2;
var T = key2.length();
var T1 = effKeyBits;
var T8 = Math.ceil(T1 / 8);
var TM = 255 >> (T1 & 7);
var i;
for (i = T; i < 128; i++) {
L.putByte(piTable[L.at(i - 1) + L.at(i - T) & 255]);
}
L.setAt(128 - T8, piTable[L.at(128 - T8) & TM]);
for (i = 127 - T8; i >= 0; i--) {
L.setAt(i, piTable[L.at(i + 1) ^ L.at(i + T8)]);
}
return L;
};
var createCipher = function(key2, bits, encrypt) {
var _finish = false, _input = null, _output = null, _iv = null;
var mixRound, mashRound;
var i, j, K = [];
key2 = forge2.rc2.expandKey(key2, bits);
for (i = 0; i < 64; i++) {
K.push(key2.getInt16Le());
}
if (encrypt) {
mixRound = function(R) {
for (i = 0; i < 4; i++) {
R[i] += K[j] + (R[(i + 3) % 4] & R[(i + 2) % 4]) + (~R[(i + 3) % 4] & R[(i + 1) % 4]);
R[i] = rol(R[i], s[i]);
j++;
}
};
mashRound = function(R) {
for (i = 0; i < 4; i++) {
R[i] += K[R[(i + 3) % 4] & 63];
}
};
} else {
mixRound = function(R) {
for (i = 3; i >= 0; i--) {
R[i] = ror(R[i], s[i]);
R[i] -= K[j] + (R[(i + 3) % 4] & R[(i + 2) % 4]) + (~R[(i + 3) % 4] & R[(i + 1) % 4]);
j--;
}
};
mashRound = function(R) {
for (i = 3; i >= 0; i--) {
R[i] -= K[R[(i + 3) % 4] & 63];
}
};
}
var runPlan = function(plan) {
var R = [];
for (i = 0; i < 4; i++) {
var val2 = _input.getInt16Le();
if (_iv !== null) {
if (encrypt) {
val2 ^= _iv.getInt16Le();
} else {
_iv.putInt16Le(val2);
}
}
R.push(val2 & 65535);
}
j = encrypt ? 0 : 63;
for (var ptr = 0; ptr < plan.length; ptr++) {
for (var ctr = 0; ctr < plan[ptr][0]; ctr++) {
plan[ptr][1](R);
}
}
for (i = 0; i < 4; i++) {
if (_iv !== null) {
if (encrypt) {
_iv.putInt16Le(R[i]);
} else {
R[i] ^= _iv.getInt16Le();
}
}
_output.putInt16Le(R[i]);
}
};
var cipher = null;
cipher = {
/**
* Starts or restarts the encryption or decryption process, whichever
* was previously configured.
*
* To use the cipher in CBC mode, iv may be given either as a string
* of bytes, or as a byte buffer. For ECB mode, give null as iv.
*
* @param iv the initialization vector to use, null for ECB mode.
* @param output the output the buffer to write to, null to create one.
*/
start: function(iv, output) {
if (iv) {
if (typeof iv === "string") {
iv = forge2.util.createBuffer(iv);
}
}
_finish = false;
_input = forge2.util.createBuffer();
_output = output || new forge2.util.createBuffer();
_iv = iv;
cipher.output = _output;
},
/**
* Updates the next block.
*
* @param input the buffer to read from.
*/
update: function(input2) {
if (!_finish) {
_input.putBuffer(input2);
}
while (_input.length() >= 8) {
runPlan([
[5, mixRound],
[1, mashRound],
[6, mixRound],
[1, mashRound],
[5, mixRound]
]);
}
},
/**
* Finishes encrypting or decrypting.
*
* @param pad a padding function to use, null for PKCS#7 padding,
* signature(blockSize, buffer, decrypt).
*
* @return true if successful, false on error.
*/
finish: function(pad) {
var rval = true;
if (encrypt) {
if (pad) {
rval = pad(8, _input, !encrypt);
} else {
var padding = _input.length() === 8 ? 8 : 8 - _input.length();
_input.fillWithByte(padding, padding);
}
}
if (rval) {
_finish = true;
cipher.update();
}
if (!encrypt) {
rval = _input.length() === 0;
if (rval) {
if (pad) {
rval = pad(8, _output, !encrypt);
} else {
var len = _output.length();
var count = _output.at(len - 1);
if (count > len) {
rval = false;
} else {
_output.truncate(count);
}
}
}
}
return rval;
}
};
return cipher;
};
forge2.rc2.startEncrypting = function(key2, iv, output) {
var cipher = forge2.rc2.createEncryptionCipher(key2, 128);
cipher.start(iv, output);
return cipher;
};
forge2.rc2.createEncryptionCipher = function(key2, bits) {
return createCipher(key2, bits, true);
};
forge2.rc2.startDecrypting = function(key2, iv, output) {
var cipher = forge2.rc2.createDecryptionCipher(key2, 128);
cipher.start(iv, output);
return cipher;
};
forge2.rc2.createDecryptionCipher = function(key2, bits) {
return createCipher(key2, bits, false);
};
}
});
// node_modules/node-forge/lib/jsbn.js
var require_jsbn = __commonJS({
"node_modules/node-forge/lib/jsbn.js"(exports2, module2) {
"use strict";
var forge2 = require_forge();
module2.exports = forge2.jsbn = forge2.jsbn || {};
var dbits;
var canary = 244837814094590;
var j_lm = (canary & 16777215) == 15715070;
function BigInteger(a, b, c) {
this.data = [];
if (a != null)
if ("number" == typeof a)
this.fromNumber(a, b, c);
else if (b == null && "string" != typeof a)
this.fromString(a, 256);
else
this.fromString(a, b);
}
forge2.jsbn.BigInteger = BigInteger;
function nbi() {
return new BigInteger(null);
}
function am1(i, x, w, j, c, n) {
while (--n >= 0) {
var v = x * this.data[i++] + w.data[j] + c;
c = Math.floor(v / 67108864);
w.data[j++] = v & 67108863;
}
return c;
}
function am2(i, x, w, j, c, n) {
var xl = x & 32767, xh = x >> 15;
while (--n >= 0) {
var l = this.data[i] & 32767;
var h = this.data[i++] >> 15;
var m = xh * l + h * xl;
l = xl * l + ((m & 32767) << 15) + w.data[j] + (c & 1073741823);
c = (l >>> 30) + (m >>> 15) + xh * h + (c >>> 30);
w.data[j++] = l & 1073741823;
}
return c;
}
function am3(i, x, w, j, c, n) {
var xl = x & 16383, xh = x >> 14;
while (--n >= 0) {
var l = this.data[i] & 16383;
var h = this.data[i++] >> 14;
var m = xh * l + h * xl;
l = xl * l + ((m & 16383) << 14) + w.data[j] + c;
c = (l >> 28) + (m >> 14) + xh * h;
w.data[j++] = l & 268435455;
}
return c;
}
if (typeof navigator === "undefined") {
BigInteger.prototype.am = am3;
dbits = 28;
} else if (j_lm && navigator.appName == "Microsoft Internet Explorer") {
BigInteger.prototype.am = am2;
dbits = 30;
} else if (j_lm && navigator.appName != "Netscape") {
BigInteger.prototype.am = am1;
dbits = 26;
} else {
BigInteger.prototype.am = am3;
dbits = 28;
}
BigInteger.prototype.DB = dbits;
BigInteger.prototype.DM = (1 << dbits) - 1;
BigInteger.prototype.DV = 1 << dbits;
var BI_FP = 52;
BigInteger.prototype.FV = Math.pow(2, BI_FP);
BigInteger.prototype.F1 = BI_FP - dbits;
BigInteger.prototype.F2 = 2 * dbits - BI_FP;
var BI_RM = "0123456789abcdefghijklmnopqrstuvwxyz";
var BI_RC = new Array();
var rr;
var vv;
rr = "0".charCodeAt(0);
for (vv = 0; vv <= 9; ++vv)
BI_RC[rr++] = vv;
rr = "a".charCodeAt(0);
for (vv = 10; vv < 36; ++vv)
BI_RC[rr++] = vv;
rr = "A".charCodeAt(0);
for (vv = 10; vv < 36; ++vv)
BI_RC[rr++] = vv;
function int2char(n) {
return BI_RM.charAt(n);
}
function intAt(s, i) {
var c = BI_RC[s.charCodeAt(i)];
return c == null ? -1 : c;
}
function bnpCopyTo(r) {
for (var i = this.t - 1; i >= 0; --i)
r.data[i] = this.data[i];
r.t = this.t;
r.s = this.s;
}
function bnpFromInt(x) {
this.t = 1;
this.s = x < 0 ? -1 : 0;
if (x > 0)
this.data[0] = x;
else if (x < -1)
this.data[0] = x + this.DV;
else
this.t = 0;
}
function nbv(i) {
var r = nbi();
r.fromInt(i);
return r;
}
function bnpFromString(s, b) {
var k;
if (b == 16)
k = 4;
else if (b == 8)
k = 3;
else if (b == 256)
k = 8;
else if (b == 2)
k = 1;
else if (b == 32)
k = 5;
else if (b == 4)
k = 2;
else {
this.fromRadix(s, b);
return;
}
this.t = 0;
this.s = 0;
var i = s.length, mi = false, sh = 0;
while (--i >= 0) {
var x = k == 8 ? s[i] & 255 : intAt(s, i);
if (x < 0) {
if (s.charAt(i) == "-")
mi = true;
continue;
}
mi = false;
if (sh == 0)
this.data[this.t++] = x;
else if (sh + k > this.DB) {
this.data[this.t - 1] |= (x & (1 << this.DB - sh) - 1) << sh;
this.data[this.t++] = x >> this.DB - sh;
} else
this.data[this.t - 1] |= x << sh;
sh += k;
if (sh >= this.DB)
sh -= this.DB;
}
if (k == 8 && (s[0] & 128) != 0) {
this.s = -1;
if (sh > 0)
this.data[this.t - 1] |= (1 << this.DB - sh) - 1 << sh;
}
this.clamp();
if (mi)
BigInteger.ZERO.subTo(this, this);
}
function bnpClamp() {
var c = this.s & this.DM;
while (this.t > 0 && this.data[this.t - 1] == c)
--this.t;
}
function bnToString(b) {
if (this.s < 0)
return "-" + this.negate().toString(b);
var k;
if (b == 16)
k = 4;
else if (b == 8)
k = 3;
else if (b == 2)
k = 1;
else if (b == 32)
k = 5;
else if (b == 4)
k = 2;
else
return this.toRadix(b);
var km = (1 << k) - 1, d, m = false, r = "", i = this.t;
var p = this.DB - i * this.DB % k;
if (i-- > 0) {
if (p < this.DB && (d = this.data[i] >> p) > 0) {
m = true;
r = int2char(d);
}
while (i >= 0) {
if (p < k) {
d = (this.data[i] & (1 << p) - 1) << k - p;
d |= this.data[--i] >> (p += this.DB - k);
} else {
d = this.data[i] >> (p -= k) & km;
if (p <= 0) {
p += this.DB;
--i;
}
}
if (d > 0)
m = true;
if (m)
r += int2char(d);
}
}
return m ? r : "0";
}
function bnNegate() {
var r = nbi();
BigInteger.ZERO.subTo(this, r);
return r;
}
function bnAbs() {
return this.s < 0 ? this.negate() : this;
}
function bnCompareTo(a) {
var r = this.s - a.s;
if (r != 0)
return r;
var i = this.t;
r = i - a.t;
if (r != 0)
return this.s < 0 ? -r : r;
while (--i >= 0)
if ((r = this.data[i] - a.data[i]) != 0)
return r;
return 0;
}
function nbits(x) {
var r = 1, t;
if ((t = x >>> 16) != 0) {
x = t;
r += 16;
}
if ((t = x >> 8) != 0) {
x = t;
r += 8;
}
if ((t = x >> 4) != 0) {
x = t;
r += 4;
}
if ((t = x >> 2) != 0) {
x = t;
r += 2;
}
if ((t = x >> 1) != 0) {
x = t;
r += 1;
}
return r;
}
function bnBitLength() {
if (this.t <= 0)
return 0;
return this.DB * (this.t - 1) + nbits(this.data[this.t - 1] ^ this.s & this.DM);
}
function bnpDLShiftTo(n, r) {
var i;
for (i = this.t - 1; i >= 0; --i)
r.data[i + n] = this.data[i];
for (i = n - 1; i >= 0; --i)
r.data[i] = 0;
r.t = this.t + n;
r.s = this.s;
}
function bnpDRShiftTo(n, r) {
for (var i = n; i < this.t; ++i)
r.data[i - n] = this.data[i];
r.t = Math.max(this.t - n, 0);
r.s = this.s;
}
function bnpLShiftTo(n, r) {
var bs = n % this.DB;
var cbs = this.DB - bs;
var bm = (1 << cbs) - 1;
var ds = Math.floor(n / this.DB), c = this.s << bs & this.DM, i;
for (i = this.t - 1; i >= 0; --i) {
r.data[i + ds + 1] = this.data[i] >> cbs | c;
c = (this.data[i] & bm) << bs;
}
for (i = ds - 1; i >= 0; --i)
r.data[i] = 0;
r.data[ds] = c;
r.t = this.t + ds + 1;
r.s = this.s;
r.clamp();
}
function bnpRShiftTo(n, r) {
r.s = this.s;
var ds = Math.floor(n / this.DB);
if (ds >= this.t) {
r.t = 0;
return;
}
var bs = n % this.DB;
var cbs = this.DB - bs;
var bm = (1 << bs) - 1;
r.data[0] = this.data[ds] >> bs;
for (var i = ds + 1; i < this.t; ++i) {
r.data[i - ds - 1] |= (this.data[i] & bm) << cbs;
r.data[i - ds] = this.data[i] >> bs;
}
if (bs > 0)
r.data[this.t - ds - 1] |= (this.s & bm) << cbs;
r.t = this.t - ds;
r.clamp();
}
function bnpSubTo(a, r) {
var i = 0, c = 0, m = Math.min(a.t, this.t);
while (i < m) {
c += this.data[i] - a.data[i];
r.data[i++] = c & this.DM;
c >>= this.DB;
}
if (a.t < this.t) {
c -= a.s;
while (i < this.t) {
c += this.data[i];
r.data[i++] = c & this.DM;
c >>= this.DB;
}
c += this.s;
} else {
c += this.s;
while (i < a.t) {
c -= a.data[i];
r.data[i++] = c & this.DM;
c >>= this.DB;
}
c -= a.s;
}
r.s = c < 0 ? -1 : 0;
if (c < -1)
r.data[i++] = this.DV + c;
else if (c > 0)
r.data[i++] = c;
r.t = i;
r.clamp();
}
function bnpMultiplyTo(a, r) {
var x = this.abs(), y = a.abs();
var i = x.t;
r.t = i + y.t;
while (--i >= 0)
r.data[i] = 0;
for (i = 0; i < y.t; ++i)
r.data[i + x.t] = x.am(0, y.data[i], r, i, 0, x.t);
r.s = 0;
r.clamp();
if (this.s != a.s)
BigInteger.ZERO.subTo(r, r);
}
function bnpSquareTo(r) {
var x = this.abs();
var i = r.t = 2 * x.t;
while (--i >= 0)
r.data[i] = 0;
for (i = 0; i < x.t - 1; ++i) {
var c = x.am(i, x.data[i], r, 2 * i, 0, 1);
if ((r.data[i + x.t] += x.am(i + 1, 2 * x.data[i], r, 2 * i + 1, c, x.t - i - 1)) >= x.DV) {
r.data[i + x.t] -= x.DV;
r.data[i + x.t + 1] = 1;
}
}
if (r.t > 0)
r.data[r.t - 1] += x.am(i, x.data[i], r, 2 * i, 0, 1);
r.s = 0;
r.clamp();
}
function bnpDivRemTo(m, q, r) {
var pm = m.abs();
if (pm.t <= 0)
return;
var pt = this.abs();
if (pt.t < pm.t) {
if (q != null)
q.fromInt(0);
if (r != null)
this.copyTo(r);
return;
}
if (r == null)
r = nbi();
var y = nbi(), ts = this.s, ms = m.s;
var nsh = this.DB - nbits(pm.data[pm.t - 1]);
if (nsh > 0) {
pm.lShiftTo(nsh, y);
pt.lShiftTo(nsh, r);
} else {
pm.copyTo(y);
pt.copyTo(r);
}
var ys = y.t;
var y0 = y.data[ys - 1];
if (y0 == 0)
return;
var yt = y0 * (1 << this.F1) + (ys > 1 ? y.data[ys - 2] >> this.F2 : 0);
var d1 = this.FV / yt, d2 = (1 << this.F1) / yt, e = 1 << this.F2;
var i = r.t, j = i - ys, t = q == null ? nbi() : q;
y.dlShiftTo(j, t);
if (r.compareTo(t) >= 0) {
r.data[r.t++] = 1;
r.subTo(t, r);
}
BigInteger.ONE.dlShiftTo(ys, t);
t.subTo(y, y);
while (y.t < ys)
y.data[y.t++] = 0;
while (--j >= 0) {
var qd = r.data[--i] == y0 ? this.DM : Math.floor(r.data[i] * d1 + (r.data[i - 1] + e) * d2);
if ((r.data[i] += y.am(0, qd, r, j, 0, ys)) < qd) {
y.dlShiftTo(j, t);
r.subTo(t, r);
while (r.data[i] < --qd)
r.subTo(t, r);
}
}
if (q != null) {
r.drShiftTo(ys, q);
if (ts != ms)
BigInteger.ZERO.subTo(q, q);
}
r.t = ys;
r.clamp();
if (nsh > 0)
r.rShiftTo(nsh, r);
if (ts < 0)
BigInteger.ZERO.subTo(r, r);
}
function bnMod(a) {
var r = nbi();
this.abs().divRemTo(a, null, r);
if (this.s < 0 && r.compareTo(BigInteger.ZERO) > 0)
a.subTo(r, r);
return r;
}
function Classic(m) {
this.m = m;
}
function cConvert(x) {
if (x.s < 0 || x.compareTo(this.m) >= 0)
return x.mod(this.m);
else
return x;
}
function cRevert(x) {
return x;
}
function cReduce(x) {
x.divRemTo(this.m, null, x);
}
function cMulTo(x, y, r) {
x.multiplyTo(y, r);
this.reduce(r);
}
function cSqrTo(x, r) {
x.squareTo(r);
this.reduce(r);
}
Classic.prototype.convert = cConvert;
Classic.prototype.revert = cRevert;
Classic.prototype.reduce = cReduce;
Classic.prototype.mulTo = cMulTo;
Classic.prototype.sqrTo = cSqrTo;
function bnpInvDigit() {
if (this.t < 1)
return 0;
var x = this.data[0];
if ((x & 1) == 0)
return 0;
var y = x & 3;
y = y * (2 - (x & 15) * y) & 15;
y = y * (2 - (x & 255) * y) & 255;
y = y * (2 - ((x & 65535) * y & 65535)) & 65535;
y = y * (2 - x * y % this.DV) % this.DV;
return y > 0 ? this.DV - y : -y;
}
function Montgomery(m) {
this.m = m;
this.mp = m.invDigit();
this.mpl = this.mp & 32767;
this.mph = this.mp >> 15;
this.um = (1 << m.DB - 15) - 1;
this.mt2 = 2 * m.t;
}
function montConvert(x) {
var r = nbi();
x.abs().dlShiftTo(this.m.t, r);
r.divRemTo(this.m, null, r);
if (x.s < 0 && r.compareTo(BigInteger.ZERO) > 0)
this.m.subTo(r, r);
return r;
}
function montRevert(x) {
var r = nbi();
x.copyTo(r);
this.reduce(r);
return r;
}
function montReduce(x) {
while (x.t <= this.mt2)
x.data[x.t++] = 0;
for (var i = 0; i < this.m.t; ++i) {
var j = x.data[i] & 32767;
var u0 = j * this.mpl + ((j * this.mph + (x.data[i] >> 15) * this.mpl & this.um) << 15) & x.DM;
j = i + this.m.t;
x.data[j] += this.m.am(0, u0, x, i, 0, this.m.t);
while (x.data[j] >= x.DV) {
x.data[j] -= x.DV;
x.data[++j]++;
}
}
x.clamp();
x.drShiftTo(this.m.t, x);
if (x.compareTo(this.m) >= 0)
x.subTo(this.m, x);
}
function montSqrTo(x, r) {
x.squareTo(r);
this.reduce(r);
}
function montMulTo(x, y, r) {
x.multiplyTo(y, r);
this.reduce(r);
}
Montgomery.prototype.convert = montConvert;
Montgomery.prototype.revert = montRevert;
Montgomery.prototype.reduce = montReduce;
Montgomery.prototype.mulTo = montMulTo;
Montgomery.prototype.sqrTo = montSqrTo;
function bnpIsEven() {
return (this.t > 0 ? this.data[0] & 1 : this.s) == 0;
}
function bnpExp(e, z) {
if (e > 4294967295 || e < 1)
return BigInteger.ONE;
var r = nbi(), r2 = nbi(), g = z.convert(this), i = nbits(e) - 1;
g.copyTo(r);
while (--i >= 0) {
z.sqrTo(r, r2);
if ((e & 1 << i) > 0)
z.mulTo(r2, g, r);
else {
var t = r;
r = r2;
r2 = t;
}
}
return z.revert(r);
}
function bnModPowInt(e, m) {
var z;
if (e < 256 || m.isEven())
z = new Classic(m);
else
z = new Montgomery(m);
return this.exp(e, z);
}
BigInteger.prototype.copyTo = bnpCopyTo;
BigInteger.prototype.fromInt = bnpFromInt;
BigInteger.prototype.fromString = bnpFromString;
BigInteger.prototype.clamp = bnpClamp;
BigInteger.prototype.dlShiftTo = bnpDLShiftTo;
BigInteger.prototype.drShiftTo = bnpDRShiftTo;
BigInteger.prototype.lShiftTo = bnpLShiftTo;
BigInteger.prototype.rShiftTo = bnpRShiftTo;
BigInteger.prototype.subTo = bnpSubTo;
BigInteger.prototype.multiplyTo = bnpMultiplyTo;
BigInteger.prototype.squareTo = bnpSquareTo;
BigInteger.prototype.divRemTo = bnpDivRemTo;
BigInteger.prototype.invDigit = bnpInvDigit;
BigInteger.prototype.isEven = bnpIsEven;
BigInteger.prototype.exp = bnpExp;
BigInteger.prototype.toString = bnToString;
BigInteger.prototype.negate = bnNegate;
BigInteger.prototype.abs = bnAbs;
BigInteger.prototype.compareTo = bnCompareTo;
BigInteger.prototype.bitLength = bnBitLength;
BigInteger.prototype.mod = bnMod;
BigInteger.prototype.modPowInt = bnModPowInt;
BigInteger.ZERO = nbv(0);
BigInteger.ONE = nbv(1);
function bnClone() {
var r = nbi();
this.copyTo(r);
return r;
}
function bnIntValue() {
if (this.s < 0) {
if (this.t == 1)
return this.data[0] - this.DV;
else if (this.t == 0)
return -1;
} else if (this.t == 1)
return this.data[0];
else if (this.t == 0)
return 0;
return (this.data[1] & (1 << 32 - this.DB) - 1) << this.DB | this.data[0];
}
function bnByteValue() {
return this.t == 0 ? this.s : this.data[0] << 24 >> 24;
}
function bnShortValue() {
return this.t == 0 ? this.s : this.data[0] << 16 >> 16;
}
function bnpChunkSize(r) {
return Math.floor(Math.LN2 * this.DB / Math.log(r));
}
function bnSigNum() {
if (this.s < 0)
return -1;
else if (this.t <= 0 || this.t == 1 && this.data[0] <= 0)
return 0;
else
return 1;
}
function bnpToRadix(b) {
if (b == null)
b = 10;
if (this.signum() == 0 || b < 2 || b > 36)
return "0";
var cs = this.chunkSize(b);
var a = Math.pow(b, cs);
var d = nbv(a), y = nbi(), z = nbi(), r = "";
this.divRemTo(d, y, z);
while (y.signum() > 0) {
r = (a + z.intValue()).toString(b).substr(1) + r;
y.divRemTo(d, y, z);
}
return z.intValue().toString(b) + r;
}
function bnpFromRadix(s, b) {
this.fromInt(0);
if (b == null)
b = 10;
var cs = this.chunkSize(b);
var d = Math.pow(b, cs), mi = false, j = 0, w = 0;
for (var i = 0; i < s.length; ++i) {
var x = intAt(s, i);
if (x < 0) {
if (s.charAt(i) == "-" && this.signum() == 0)
mi = true;
continue;
}
w = b * w + x;
if (++j >= cs) {
this.dMultiply(d);
this.dAddOffset(w, 0);
j = 0;
w = 0;
}
}
if (j > 0) {
this.dMultiply(Math.pow(b, j));
this.dAddOffset(w, 0);
}
if (mi)
BigInteger.ZERO.subTo(this, this);
}
function bnpFromNumber(a, b, c) {
if ("number" == typeof b) {
if (a < 2)
this.fromInt(1);
else {
this.fromNumber(a, c);
if (!this.testBit(a - 1))
this.bitwiseTo(BigInteger.ONE.shiftLeft(a - 1), op_or, this);
if (this.isEven())
this.dAddOffset(1, 0);
while (!this.isProbablePrime(b)) {
this.dAddOffset(2, 0);
if (this.bitLength() > a)
this.subTo(BigInteger.ONE.shiftLeft(a - 1), this);
}
}
} else {
var x = new Array(), t = a & 7;
x.length = (a >> 3) + 1;
b.nextBytes(x);
if (t > 0)
x[0] &= (1 << t) - 1;
else
x[0] = 0;
this.fromString(x, 256);
}
}
function bnToByteArray() {
var i = this.t, r = new Array();
r[0] = this.s;
var p = this.DB - i * this.DB % 8, d, k = 0;
if (i-- > 0) {
if (p < this.DB && (d = this.data[i] >> p) != (this.s & this.DM) >> p)
r[k++] = d | this.s << this.DB - p;
while (i >= 0) {
if (p < 8) {
d = (this.data[i] & (1 << p) - 1) << 8 - p;
d |= this.data[--i] >> (p += this.DB - 8);
} else {
d = this.data[i] >> (p -= 8) & 255;
if (p <= 0) {
p += this.DB;
--i;
}
}
if ((d & 128) != 0)
d |= -256;
if (k == 0 && (this.s & 128) != (d & 128))
++k;
if (k > 0 || d != this.s)
r[k++] = d;
}
}
return r;
}
function bnEquals(a) {
return this.compareTo(a) == 0;
}
function bnMin(a) {
return this.compareTo(a) < 0 ? this : a;
}
function bnMax(a) {
return this.compareTo(a) > 0 ? this : a;
}
function bnpBitwiseTo(a, op, r) {
var i, f, m = Math.min(a.t, this.t);
for (i = 0; i < m; ++i)
r.data[i] = op(this.data[i], a.data[i]);
if (a.t < this.t) {
f = a.s & this.DM;
for (i = m; i < this.t; ++i)
r.data[i] = op(this.data[i], f);
r.t = this.t;
} else {
f = this.s & this.DM;
for (i = m; i < a.t; ++i)
r.data[i] = op(f, a.data[i]);
r.t = a.t;
}
r.s = op(this.s, a.s);
r.clamp();
}
function op_and(x, y) {
return x & y;
}
function bnAnd(a) {
var r = nbi();
this.bitwiseTo(a, op_and, r);
return r;
}
function op_or(x, y) {
return x | y;
}
function bnOr(a) {
var r = nbi();
this.bitwiseTo(a, op_or, r);
return r;
}
function op_xor(x, y) {
return x ^ y;
}
function bnXor(a) {
var r = nbi();
this.bitwiseTo(a, op_xor, r);
return r;
}
function op_andnot(x, y) {
return x & ~y;
}
function bnAndNot(a) {
var r = nbi();
this.bitwiseTo(a, op_andnot, r);
return r;
}
function bnNot() {
var r = nbi();
for (var i = 0; i < this.t; ++i)
r.data[i] = this.DM & ~this.data[i];
r.t = this.t;
r.s = ~this.s;
return r;
}
function bnShiftLeft(n) {
var r = nbi();
if (n < 0)
this.rShiftTo(-n, r);
else
this.lShiftTo(n, r);
return r;
}
function bnShiftRight(n) {
var r = nbi();
if (n < 0)
this.lShiftTo(-n, r);
else
this.rShiftTo(n, r);
return r;
}
function lbit(x) {
if (x == 0)
return -1;
var r = 0;
if ((x & 65535) == 0) {
x >>= 16;
r += 16;
}
if ((x & 255) == 0) {
x >>= 8;
r += 8;
}
if ((x & 15) == 0) {
x >>= 4;
r += 4;
}
if ((x & 3) == 0) {
x >>= 2;
r += 2;
}
if ((x & 1) == 0)
++r;
return r;
}
function bnGetLowestSetBit() {
for (var i = 0; i < this.t; ++i)
if (this.data[i] != 0)
return i * this.DB + lbit(this.data[i]);
if (this.s < 0)
return this.t * this.DB;
return -1;
}
function cbit(x) {
var r = 0;
while (x != 0) {
x &= x - 1;
++r;
}
return r;
}
function bnBitCount() {
var r = 0, x = this.s & this.DM;
for (var i = 0; i < this.t; ++i)
r += cbit(this.data[i] ^ x);
return r;
}
function bnTestBit(n) {
var j = Math.floor(n / this.DB);
if (j >= this.t)
return this.s != 0;
return (this.data[j] & 1 << n % this.DB) != 0;
}
function bnpChangeBit(n, op) {
var r = BigInteger.ONE.shiftLeft(n);
this.bitwiseTo(r, op, r);
return r;
}
function bnSetBit(n) {
return this.changeBit(n, op_or);
}
function bnClearBit(n) {
return this.changeBit(n, op_andnot);
}
function bnFlipBit(n) {
return this.changeBit(n, op_xor);
}
function bnpAddTo(a, r) {
var i = 0, c = 0, m = Math.min(a.t, this.t);
while (i < m) {
c += this.data[i] + a.data[i];
r.data[i++] = c & this.DM;
c >>= this.DB;
}
if (a.t < this.t) {
c += a.s;
while (i < this.t) {
c += this.data[i];
r.data[i++] = c & this.DM;
c >>= this.DB;
}
c += this.s;
} else {
c += this.s;
while (i < a.t) {
c += a.data[i];
r.data[i++] = c & this.DM;
c >>= this.DB;
}
c += a.s;
}
r.s = c < 0 ? -1 : 0;
if (c > 0)
r.data[i++] = c;
else if (c < -1)
r.data[i++] = this.DV + c;
r.t = i;
r.clamp();
}
function bnAdd(a) {
var r = nbi();
this.addTo(a, r);
return r;
}
function bnSubtract(a) {
var r = nbi();
this.subTo(a, r);
return r;
}
function bnMultiply(a) {
var r = nbi();
this.multiplyTo(a, r);
return r;
}
function bnDivide(a) {
var r = nbi();
this.divRemTo(a, r, null);
return r;
}
function bnRemainder(a) {
var r = nbi();
this.divRemTo(a, null, r);
return r;
}
function bnDivideAndRemainder(a) {
var q = nbi(), r = nbi();
this.divRemTo(a, q, r);
return new Array(q, r);
}
function bnpDMultiply(n) {
this.data[this.t] = this.am(0, n - 1, this, 0, 0, this.t);
++this.t;
this.clamp();
}
function bnpDAddOffset(n, w) {
if (n == 0)
return;
while (this.t <= w)
this.data[this.t++] = 0;
this.data[w] += n;
while (this.data[w] >= this.DV) {
this.data[w] -= this.DV;
if (++w >= this.t)
this.data[this.t++] = 0;
++this.data[w];
}
}
function NullExp() {
}
function nNop(x) {
return x;
}
function nMulTo(x, y, r) {
x.multiplyTo(y, r);
}
function nSqrTo(x, r) {
x.squareTo(r);
}
NullExp.prototype.convert = nNop;
NullExp.prototype.revert = nNop;
NullExp.prototype.mulTo = nMulTo;
NullExp.prototype.sqrTo = nSqrTo;
function bnPow(e) {
return this.exp(e, new NullExp());
}
function bnpMultiplyLowerTo(a, n, r) {
var i = Math.min(this.t + a.t, n);
r.s = 0;
r.t = i;
while (i > 0)
r.data[--i] = 0;
var j;
for (j = r.t - this.t; i < j; ++i)
r.data[i + this.t] = this.am(0, a.data[i], r, i, 0, this.t);
for (j = Math.min(a.t, n); i < j; ++i)
this.am(0, a.data[i], r, i, 0, n - i);
r.clamp();
}
function bnpMultiplyUpperTo(a, n, r) {
--n;
var i = r.t = this.t + a.t - n;
r.s = 0;
while (--i >= 0)
r.data[i] = 0;
for (i = Math.max(n - this.t, 0); i < a.t; ++i)
r.data[this.t + i - n] = this.am(n - i, a.data[i], r, 0, 0, this.t + i - n);
r.clamp();
r.drShiftTo(1, r);
}
function Barrett(m) {
this.r2 = nbi();
this.q3 = nbi();
BigInteger.ONE.dlShiftTo(2 * m.t, this.r2);
this.mu = this.r2.divide(m);
this.m = m;
}
function barrettConvert(x) {
if (x.s < 0 || x.t > 2 * this.m.t)
return x.mod(this.m);
else if (x.compareTo(this.m) < 0)
return x;
else {
var r = nbi();
x.copyTo(r);
this.reduce(r);
return r;
}
}
function barrettRevert(x) {
return x;
}
function barrettReduce(x) {
x.drShiftTo(this.m.t - 1, this.r2);
if (x.t > this.m.t + 1) {
x.t = this.m.t + 1;
x.clamp();
}
this.mu.multiplyUpperTo(this.r2, this.m.t + 1, this.q3);
this.m.multiplyLowerTo(this.q3, this.m.t + 1, this.r2);
while (x.compareTo(this.r2) < 0)
x.dAddOffset(1, this.m.t + 1);
x.subTo(this.r2, x);
while (x.compareTo(this.m) >= 0)
x.subTo(this.m, x);
}
function barrettSqrTo(x, r) {
x.squareTo(r);
this.reduce(r);
}
function barrettMulTo(x, y, r) {
x.multiplyTo(y, r);
this.reduce(r);
}
Barrett.prototype.convert = barrettConvert;
Barrett.prototype.revert = barrettRevert;
Barrett.prototype.reduce = barrettReduce;
Barrett.prototype.mulTo = barrettMulTo;
Barrett.prototype.sqrTo = barrettSqrTo;
function bnModPow(e, m) {
var i = e.bitLength(), k, r = nbv(1), z;
if (i <= 0)
return r;
else if (i < 18)
k = 1;
else if (i < 48)
k = 3;
else if (i < 144)
k = 4;
else if (i < 768)
k = 5;
else
k = 6;
if (i < 8)
z = new Classic(m);
else if (m.isEven())
z = new Barrett(m);
else
z = new Montgomery(m);
var g = new Array(), n = 3, k1 = k - 1, km = (1 << k) - 1;
g[1] = z.convert(this);
if (k > 1) {
var g2 = nbi();
z.sqrTo(g[1], g2);
while (n <= km) {
g[n] = nbi();
z.mulTo(g2, g[n - 2], g[n]);
n += 2;
}
}
var j = e.t - 1, w, is1 = true, r2 = nbi(), t;
i = nbits(e.data[j]) - 1;
while (j >= 0) {
if (i >= k1)
w = e.data[j] >> i - k1 & km;
else {
w = (e.data[j] & (1 << i + 1) - 1) << k1 - i;
if (j > 0)
w |= e.data[j - 1] >> this.DB + i - k1;
}
n = k;
while ((w & 1) == 0) {
w >>= 1;
--n;
}
if ((i -= n) < 0) {
i += this.DB;
--j;
}
if (is1) {
g[w].copyTo(r);
is1 = false;
} else {
while (n > 1) {
z.sqrTo(r, r2);
z.sqrTo(r2, r);
n -= 2;
}
if (n > 0)
z.sqrTo(r, r2);
else {
t = r;
r = r2;
r2 = t;
}
z.mulTo(r2, g[w], r);
}
while (j >= 0 && (e.data[j] & 1 << i) == 0) {
z.sqrTo(r, r2);
t = r;
r = r2;
r2 = t;
if (--i < 0) {
i = this.DB - 1;
--j;
}
}
}
return z.revert(r);
}
function bnGCD(a) {
var x = this.s < 0 ? this.negate() : this.clone();
var y = a.s < 0 ? a.negate() : a.clone();
if (x.compareTo(y) < 0) {
var t = x;
x = y;
y = t;
}
var i = x.getLowestSetBit(), g = y.getLowestSetBit();
if (g < 0)
return x;
if (i < g)
g = i;
if (g > 0) {
x.rShiftTo(g, x);
y.rShiftTo(g, y);
}
while (x.signum() > 0) {
if ((i = x.getLowestSetBit()) > 0)
x.rShiftTo(i, x);
if ((i = y.getLowestSetBit()) > 0)
y.rShiftTo(i, y);
if (x.compareTo(y) >= 0) {
x.subTo(y, x);
x.rShiftTo(1, x);
} else {
y.subTo(x, y);
y.rShiftTo(1, y);
}
}
if (g > 0)
y.lShiftTo(g, y);
return y;
}
function bnpModInt(n) {
if (n <= 0)
return 0;
var d = this.DV % n, r = this.s < 0 ? n - 1 : 0;
if (this.t > 0)
if (d == 0)
r = this.data[0] % n;
else
for (var i = this.t - 1; i >= 0; --i)
r = (d * r + this.data[i]) % n;
return r;
}
function bnModInverse(m) {
var ac = m.isEven();
if (this.isEven() && ac || m.signum() == 0)
return BigInteger.ZERO;
var u2 = m.clone(), v = this.clone();
var a = nbv(1), b = nbv(0), c = nbv(0), d = nbv(1);
while (u2.signum() != 0) {
while (u2.isEven()) {
u2.rShiftTo(1, u2);
if (ac) {
if (!a.isEven() || !b.isEven()) {
a.addTo(this, a);
b.subTo(m, b);
}
a.rShiftTo(1, a);
} else if (!b.isEven())
b.subTo(m, b);
b.rShiftTo(1, b);
}
while (v.isEven()) {
v.rShiftTo(1, v);
if (ac) {
if (!c.isEven() || !d.isEven()) {
c.addTo(this, c);
d.subTo(m, d);
}
c.rShiftTo(1, c);
} else if (!d.isEven())
d.subTo(m, d);
d.rShiftTo(1, d);
}
if (u2.compareTo(v) >= 0) {
u2.subTo(v, u2);
if (ac)
a.subTo(c, a);
b.subTo(d, b);
} else {
v.subTo(u2, v);
if (ac)
c.subTo(a, c);
d.subTo(b, d);
}
}
if (v.compareTo(BigInteger.ONE) != 0)
return BigInteger.ZERO;
if (d.compareTo(m) >= 0)
return d.subtract(m);
if (d.signum() < 0)
d.addTo(m, d);
else
return d;
if (d.signum() < 0)
return d.add(m);
else
return d;
}
var lowprimes = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499, 503, 509];
var lplim = (1 << 26) / lowprimes[lowprimes.length - 1];
function bnIsProbablePrime(t) {
var i, x = this.abs();
if (x.t == 1 && x.data[0] <= lowprimes[lowprimes.length - 1]) {
for (i = 0; i < lowprimes.length; ++i)
if (x.data[0] == lowprimes[i])
return true;
return false;
}
if (x.isEven())
return false;
i = 1;
while (i < lowprimes.length) {
var m = lowprimes[i], j = i + 1;
while (j < lowprimes.length && m < lplim)
m *= lowprimes[j++];
m = x.modInt(m);
while (i < j)
if (m % lowprimes[i++] == 0)
return false;
}
return x.millerRabin(t);
}
function bnpMillerRabin(t) {
var n1 = this.subtract(BigInteger.ONE);
var k = n1.getLowestSetBit();
if (k <= 0)
return false;
var r = n1.shiftRight(k);
var prng = bnGetPrng();
var a;
for (var i = 0; i < t; ++i) {
do {
a = new BigInteger(this.bitLength(), prng);
} while (a.compareTo(BigInteger.ONE) <= 0 || a.compareTo(n1) >= 0);
var y = a.modPow(r, this);
if (y.compareTo(BigInteger.ONE) != 0 && y.compareTo(n1) != 0) {
var j = 1;
while (j++ < k && y.compareTo(n1) != 0) {
y = y.modPowInt(2, this);
if (y.compareTo(BigInteger.ONE) == 0)
return false;
}
if (y.compareTo(n1) != 0)
return false;
}
}
return true;
}
function bnGetPrng() {
return {
// x is an array to fill with bytes
nextBytes: function(x) {
for (var i = 0; i < x.length; ++i) {
x[i] = Math.floor(Math.random() * 256);
}
}
};
}
BigInteger.prototype.chunkSize = bnpChunkSize;
BigInteger.prototype.toRadix = bnpToRadix;
BigInteger.prototype.fromRadix = bnpFromRadix;
BigInteger.prototype.fromNumber = bnpFromNumber;
BigInteger.prototype.bitwiseTo = bnpBitwiseTo;
BigInteger.prototype.changeBit = bnpChangeBit;
BigInteger.prototype.addTo = bnpAddTo;
BigInteger.prototype.dMultiply = bnpDMultiply;
BigInteger.prototype.dAddOffset = bnpDAddOffset;
BigInteger.prototype.multiplyLowerTo = bnpMultiplyLowerTo;
BigInteger.prototype.multiplyUpperTo = bnpMultiplyUpperTo;
BigInteger.prototype.modInt = bnpModInt;
BigInteger.prototype.millerRabin = bnpMillerRabin;
BigInteger.prototype.clone = bnClone;
BigInteger.prototype.intValue = bnIntValue;
BigInteger.prototype.byteValue = bnByteValue;
BigInteger.prototype.shortValue = bnShortValue;
BigInteger.prototype.signum = bnSigNum;
BigInteger.prototype.toByteArray = bnToByteArray;
BigInteger.prototype.equals = bnEquals;
BigInteger.prototype.min = bnMin;
BigInteger.prototype.max = bnMax;
BigInteger.prototype.and = bnAnd;
BigInteger.prototype.or = bnOr;
BigInteger.prototype.xor = bnXor;
BigInteger.prototype.andNot = bnAndNot;
BigInteger.prototype.not = bnNot;
BigInteger.prototype.shiftLeft = bnShiftLeft;
BigInteger.prototype.shiftRight = bnShiftRight;
BigInteger.prototype.getLowestSetBit = bnGetLowestSetBit;
BigInteger.prototype.bitCount = bnBitCount;
BigInteger.prototype.testBit = bnTestBit;
BigInteger.prototype.setBit = bnSetBit;
BigInteger.prototype.clearBit = bnClearBit;
BigInteger.prototype.flipBit = bnFlipBit;
BigInteger.prototype.add = bnAdd;
BigInteger.prototype.subtract = bnSubtract;
BigInteger.prototype.multiply = bnMultiply;
BigInteger.prototype.divide = bnDivide;
BigInteger.prototype.remainder = bnRemainder;
BigInteger.prototype.divideAndRemainder = bnDivideAndRemainder;
BigInteger.prototype.modPow = bnModPow;
BigInteger.prototype.modInverse = bnModInverse;
BigInteger.prototype.pow = bnPow;
BigInteger.prototype.gcd = bnGCD;
BigInteger.prototype.isProbablePrime = bnIsProbablePrime;
}
});
// node_modules/node-forge/lib/sha1.js
var require_sha1 = __commonJS({
"node_modules/node-forge/lib/sha1.js"(exports2, module2) {
"use strict";
var forge2 = require_forge();
require_md();
require_util();
var sha1 = module2.exports = forge2.sha1 = forge2.sha1 || {};
forge2.md.sha1 = forge2.md.algorithms.sha1 = sha1;
sha1.create = function() {
if (!_initialized) {
_init();
}
var _state = null;
var _input = forge2.util.createBuffer();
var _w = new Array(80);
var md = {
algorithm: "sha1",
blockLength: 64,
digestLength: 20,
// 56-bit length of message so far (does not including padding)
messageLength: 0,
// true message length
fullMessageLength: null,
// size of message length in bytes
messageLengthSize: 8
};
md.start = function() {
md.messageLength = 0;
md.fullMessageLength = md.messageLength64 = [];
var int32s = md.messageLengthSize / 4;
for (var i = 0; i < int32s; ++i) {
md.fullMessageLength.push(0);
}
_input = forge2.util.createBuffer();
_state = {
h0: 1732584193,
h1: 4023233417,
h2: 2562383102,
h3: 271733878,
h4: 3285377520
};
return md;
};
md.start();
md.update = function(msg, encoding) {
if (encoding === "utf8") {
msg = forge2.util.encodeUtf8(msg);
}
var len = msg.length;
md.messageLength += len;
len = [len / 4294967296 >>> 0, len >>> 0];
for (var i = md.fullMessageLength.length - 1; i >= 0; --i) {
md.fullMessageLength[i] += len[1];
len[1] = len[0] + (md.fullMessageLength[i] / 4294967296 >>> 0);
md.fullMessageLength[i] = md.fullMessageLength[i] >>> 0;
len[0] = len[1] / 4294967296 >>> 0;
}
_input.putBytes(msg);
_update(_state, _w, _input);
if (_input.read > 2048 || _input.length() === 0) {
_input.compact();
}
return md;
};
md.digest = function() {
var finalBlock = forge2.util.createBuffer();
finalBlock.putBytes(_input.bytes());
var remaining = md.fullMessageLength[md.fullMessageLength.length - 1] + md.messageLengthSize;
var overflow = remaining & md.blockLength - 1;
finalBlock.putBytes(_padding.substr(0, md.blockLength - overflow));
var next, carry;
var bits = md.fullMessageLength[0] * 8;
for (var i = 0; i < md.fullMessageLength.length - 1; ++i) {
next = md.fullMessageLength[i + 1] * 8;
carry = next / 4294967296 >>> 0;
bits += carry;
finalBlock.putInt32(bits >>> 0);
bits = next >>> 0;
}
finalBlock.putInt32(bits);
var s2 = {
h0: _state.h0,
h1: _state.h1,
h2: _state.h2,
h3: _state.h3,
h4: _state.h4
};
_update(s2, _w, finalBlock);
var rval = forge2.util.createBuffer();
rval.putInt32(s2.h0);
rval.putInt32(s2.h1);
rval.putInt32(s2.h2);
rval.putInt32(s2.h3);
rval.putInt32(s2.h4);
return rval;
};
return md;
};
var _padding = null;
var _initialized = false;
function _init() {
_padding = String.fromCharCode(128);
_padding += forge2.util.fillString(String.fromCharCode(0), 64);
_initialized = true;
}
function _update(s, w, bytes) {
var t, a, b, c, d, e, f, i;
var len = bytes.length();
while (len >= 64) {
a = s.h0;
b = s.h1;
c = s.h2;
d = s.h3;
e = s.h4;
for (i = 0; i < 16; ++i) {
t = bytes.getInt32();
w[i] = t;
f = d ^ b & (c ^ d);
t = (a << 5 | a >>> 27) + f + e + 1518500249 + t;
e = d;
d = c;
c = (b << 30 | b >>> 2) >>> 0;
b = a;
a = t;
}
for (; i < 20; ++i) {
t = w[i - 3] ^ w[i - 8] ^ w[i - 14] ^ w[i - 16];
t = t << 1 | t >>> 31;
w[i] = t;
f = d ^ b & (c ^ d);
t = (a << 5 | a >>> 27) + f + e + 1518500249 + t;
e = d;
d = c;
c = (b << 30 | b >>> 2) >>> 0;
b = a;
a = t;
}
for (; i < 32; ++i) {
t = w[i - 3] ^ w[i - 8] ^ w[i - 14] ^ w[i - 16];
t = t << 1 | t >>> 31;
w[i] = t;
f = b ^ c ^ d;
t = (a << 5 | a >>> 27) + f + e + 1859775393 + t;
e = d;
d = c;
c = (b << 30 | b >>> 2) >>> 0;
b = a;
a = t;
}
for (; i < 40; ++i) {
t = w[i - 6] ^ w[i - 16] ^ w[i - 28] ^ w[i - 32];
t = t << 2 | t >>> 30;
w[i] = t;
f = b ^ c ^ d;
t = (a << 5 | a >>> 27) + f + e + 1859775393 + t;
e = d;
d = c;
c = (b << 30 | b >>> 2) >>> 0;
b = a;
a = t;
}
for (; i < 60; ++i) {
t = w[i - 6] ^ w[i - 16] ^ w[i - 28] ^ w[i - 32];
t = t << 2 | t >>> 30;
w[i] = t;
f = b & c | d & (b ^ c);
t = (a << 5 | a >>> 27) + f + e + 2400959708 + t;
e = d;
d = c;
c = (b << 30 | b >>> 2) >>> 0;
b = a;
a = t;
}
for (; i < 80; ++i) {
t = w[i - 6] ^ w[i - 16] ^ w[i - 28] ^ w[i - 32];
t = t << 2 | t >>> 30;
w[i] = t;
f = b ^ c ^ d;
t = (a << 5 | a >>> 27) + f + e + 3395469782 + t;
e = d;
d = c;
c = (b << 30 | b >>> 2) >>> 0;
b = a;
a = t;
}
s.h0 = s.h0 + a | 0;
s.h1 = s.h1 + b | 0;
s.h2 = s.h2 + c | 0;
s.h3 = s.h3 + d | 0;
s.h4 = s.h4 + e | 0;
len -= 64;
}
}
}
});
// node_modules/node-forge/lib/pkcs1.js
var require_pkcs1 = __commonJS({
"node_modules/node-forge/lib/pkcs1.js"(exports2, module2) {
"use strict";
var forge2 = require_forge();
require_util();
require_random();
require_sha1();
var pkcs1 = module2.exports = forge2.pkcs1 = forge2.pkcs1 || {};
pkcs1.encode_rsa_oaep = function(key2, message, options) {
var label;
var seed;
var md;
var mgf1Md;
if (typeof options === "string") {
label = options;
seed = arguments[3] || void 0;
md = arguments[4] || void 0;
} else if (options) {
label = options.label || void 0;
seed = options.seed || void 0;
md = options.md || void 0;
if (options.mgf1 && options.mgf1.md) {
mgf1Md = options.mgf1.md;
}
}
if (!md) {
md = forge2.md.sha1.create();
} else {
md.start();
}
if (!mgf1Md) {
mgf1Md = md;
}
var keyLength = Math.ceil(key2.n.bitLength() / 8);
var maxLength = keyLength - 2 * md.digestLength - 2;
if (message.length > maxLength) {
var error = new Error("RSAES-OAEP input message length is too long.");
error.length = message.length;
error.maxLength = maxLength;
throw error;
}
if (!label) {
label = "";
}
md.update(label, "raw");
var lHash = md.digest();
var PS = "";
var PS_length = maxLength - message.length;
for (var i = 0; i < PS_length; i++) {
PS += "\0";
}
var DB = lHash.getBytes() + PS + "" + message;
if (!seed) {
seed = forge2.random.getBytes(md.digestLength);
} else if (seed.length !== md.digestLength) {
var error = new Error("Invalid RSAES-OAEP seed. The seed length must match the digest length.");
error.seedLength = seed.length;
error.digestLength = md.digestLength;
throw error;
}
var dbMask = rsa_mgf1(seed, keyLength - md.digestLength - 1, mgf1Md);
var maskedDB = forge2.util.xorBytes(DB, dbMask, DB.length);
var seedMask = rsa_mgf1(maskedDB, md.digestLength, mgf1Md);
var maskedSeed = forge2.util.xorBytes(seed, seedMask, seed.length);
return "\0" + maskedSeed + maskedDB;
};
pkcs1.decode_rsa_oaep = function(key2, em, options) {
var label;
var md;
var mgf1Md;
if (typeof options === "string") {
label = options;
md = arguments[3] || void 0;
} else if (options) {
label = options.label || void 0;
md = options.md || void 0;
if (options.mgf1 && options.mgf1.md) {
mgf1Md = options.mgf1.md;
}
}
var keyLength = Math.ceil(key2.n.bitLength() / 8);
if (em.length !== keyLength) {
var error = new Error("RSAES-OAEP encoded message length is invalid.");
error.length = em.length;
error.expectedLength = keyLength;
throw error;
}
if (md === void 0) {
md = forge2.md.sha1.create();
} else {
md.start();
}
if (!mgf1Md) {
mgf1Md = md;
}
if (keyLength < 2 * md.digestLength + 2) {
throw new Error("RSAES-OAEP key is too short for the hash function.");
}
if (!label) {
label = "";
}
md.update(label, "raw");
var lHash = md.digest().getBytes();
var y = em.charAt(0);
var maskedSeed = em.substring(1, md.digestLength + 1);
var maskedDB = em.substring(1 + md.digestLength);
var seedMask = rsa_mgf1(maskedDB, md.digestLength, mgf1Md);
var seed = forge2.util.xorBytes(maskedSeed, seedMask, maskedSeed.length);
var dbMask = rsa_mgf1(seed, keyLength - md.digestLength - 1, mgf1Md);
var db = forge2.util.xorBytes(maskedDB, dbMask, maskedDB.length);
var lHashPrime = db.substring(0, md.digestLength);
var error = y !== "\0";
for (var i = 0; i < md.digestLength; ++i) {
error |= lHash.charAt(i) !== lHashPrime.charAt(i);
}
var in_ps = 1;
var index2 = md.digestLength;
for (var j = md.digestLength; j < db.length; j++) {
var code = db.charCodeAt(j);
var is_0 = code & 1 ^ 1;
var error_mask = in_ps ? 65534 : 0;
error |= code & error_mask;
in_ps = in_ps & is_0;
index2 += in_ps;
}
if (error || db.charCodeAt(index2) !== 1) {
throw new Error("Invalid RSAES-OAEP padding.");
}
return db.substring(index2 + 1);
};
function rsa_mgf1(seed, maskLength, hash) {
if (!hash) {
hash = forge2.md.sha1.create();
}
var t = "";
var count = Math.ceil(maskLength / hash.digestLength);
for (var i = 0; i < count; ++i) {
var c = String.fromCharCode(
i >> 24 & 255,
i >> 16 & 255,
i >> 8 & 255,
i & 255
);
hash.start();
hash.update(seed + c);
t += hash.digest().getBytes();
}
return t.substring(0, maskLength);
}
}
});
// node_modules/node-forge/lib/prime.js
var require_prime = __commonJS({
"node_modules/node-forge/lib/prime.js"(exports2, module2) {
"use strict";
var forge2 = require_forge();
require_util();
require_jsbn();
require_random();
(function() {
if (forge2.prime) {
module2.exports = forge2.prime;
return;
}
var prime = module2.exports = forge2.prime = forge2.prime || {};
var BigInteger = forge2.jsbn.BigInteger;
var GCD_30_DELTA = [6, 4, 2, 4, 2, 4, 6, 2];
var THIRTY = new BigInteger(null);
THIRTY.fromInt(30);
var op_or = function(x, y) {
return x | y;
};
prime.generateProbablePrime = function(bits, options, callback) {
if (typeof options === "function") {
callback = options;
options = {};
}
options = options || {};
var algorithm = options.algorithm || "PRIMEINC";
if (typeof algorithm === "string") {
algorithm = { name: algorithm };
}
algorithm.options = algorithm.options || {};
var prng = options.prng || forge2.random;
var rng2 = {
// x is an array to fill with bytes
nextBytes: function(x) {
var b = prng.getBytesSync(x.length);
for (var i = 0; i < x.length; ++i) {
x[i] = b.charCodeAt(i);
}
}
};
if (algorithm.name === "PRIMEINC") {
return primeincFindPrime(bits, rng2, algorithm.options, callback);
}
throw new Error("Invalid prime generation algorithm: " + algorithm.name);
};
function primeincFindPrime(bits, rng2, options, callback) {
if ("workers" in options) {
return primeincFindPrimeWithWorkers(bits, rng2, options, callback);
}
return primeincFindPrimeWithoutWorkers(bits, rng2, options, callback);
}
function primeincFindPrimeWithoutWorkers(bits, rng2, options, callback) {
var num = generateRandom(bits, rng2);
var deltaIdx = 0;
var mrTests = getMillerRabinTests(num.bitLength());
if ("millerRabinTests" in options) {
mrTests = options.millerRabinTests;
}
var maxBlockTime = 10;
if ("maxBlockTime" in options) {
maxBlockTime = options.maxBlockTime;
}
_primeinc(num, bits, rng2, deltaIdx, mrTests, maxBlockTime, callback);
}
function _primeinc(num, bits, rng2, deltaIdx, mrTests, maxBlockTime, callback) {
var start = +/* @__PURE__ */ new Date();
do {
if (num.bitLength() > bits) {
num = generateRandom(bits, rng2);
}
if (num.isProbablePrime(mrTests)) {
return callback(null, num);
}
num.dAddOffset(GCD_30_DELTA[deltaIdx++ % 8], 0);
} while (maxBlockTime < 0 || +/* @__PURE__ */ new Date() - start < maxBlockTime);
forge2.util.setImmediate(function() {
_primeinc(num, bits, rng2, deltaIdx, mrTests, maxBlockTime, callback);
});
}
function primeincFindPrimeWithWorkers(bits, rng2, options, callback) {
if (typeof Worker === "undefined") {
return primeincFindPrimeWithoutWorkers(bits, rng2, options, callback);
}
var num = generateRandom(bits, rng2);
var numWorkers = options.workers;
var workLoad = options.workLoad || 100;
var range = workLoad * 30 / 8;
var workerScript = options.workerScript || "forge/prime.worker.js";
if (numWorkers === -1) {
return forge2.util.estimateCores(function(err, cores) {
if (err) {
cores = 2;
}
numWorkers = cores - 1;
generate();
});
}
generate();
function generate() {
numWorkers = Math.max(1, numWorkers);
var workers = [];
for (var i = 0; i < numWorkers; ++i) {
workers[i] = new Worker(workerScript);
}
var running = numWorkers;
for (var i = 0; i < numWorkers; ++i) {
workers[i].addEventListener("message", workerMessage);
}
var found = false;
function workerMessage(e) {
if (found) {
return;
}
--running;
var data2 = e.data;
if (data2.found) {
for (var i2 = 0; i2 < workers.length; ++i2) {
workers[i2].terminate();
}
found = true;
return callback(null, new BigInteger(data2.prime, 16));
}
if (num.bitLength() > bits) {
num = generateRandom(bits, rng2);
}
var hex = num.toString(16);
e.target.postMessage({
hex,
workLoad
});
num.dAddOffset(range, 0);
}
}
}
function generateRandom(bits, rng2) {
var num = new BigInteger(bits, rng2);
var bits1 = bits - 1;
if (!num.testBit(bits1)) {
num.bitwiseTo(BigInteger.ONE.shiftLeft(bits1), op_or, num);
}
num.dAddOffset(31 - num.mod(THIRTY).byteValue(), 0);
return num;
}
function getMillerRabinTests(bits) {
if (bits <= 100)
return 27;
if (bits <= 150)
return 18;
if (bits <= 200)
return 15;
if (bits <= 250)
return 12;
if (bits <= 300)
return 9;
if (bits <= 350)
return 8;
if (bits <= 400)
return 7;
if (bits <= 500)
return 6;
if (bits <= 600)
return 5;
if (bits <= 800)
return 4;
if (bits <= 1250)
return 3;
return 2;
}
})();
}
});
// node_modules/node-forge/lib/rsa.js
var require_rsa = __commonJS({
"node_modules/node-forge/lib/rsa.js"(exports2, module2) {
"use strict";
var forge2 = require_forge();
require_asn1();
require_jsbn();
require_oids();
require_pkcs1();
require_prime();
require_random();
require_util();
if (typeof BigInteger === "undefined") {
BigInteger = forge2.jsbn.BigInteger;
}
var BigInteger;
var _crypto = forge2.util.isNodejs ? require_crypto() : null;
var asn1 = forge2.asn1;
var util2 = forge2.util;
forge2.pki = forge2.pki || {};
module2.exports = forge2.pki.rsa = forge2.rsa = forge2.rsa || {};
var pki2 = forge2.pki;
var GCD_30_DELTA = [6, 4, 2, 4, 2, 4, 6, 2];
var privateKeyValidator = {
// PrivateKeyInfo
name: "PrivateKeyInfo",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.SEQUENCE,
constructed: true,
value: [{
// Version (INTEGER)
name: "PrivateKeyInfo.version",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.INTEGER,
constructed: false,
capture: "privateKeyVersion"
}, {
// privateKeyAlgorithm
name: "PrivateKeyInfo.privateKeyAlgorithm",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.SEQUENCE,
constructed: true,
value: [{
name: "AlgorithmIdentifier.algorithm",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.OID,
constructed: false,
capture: "privateKeyOid"
}]
}, {
// PrivateKey
name: "PrivateKeyInfo",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.OCTETSTRING,
constructed: false,
capture: "privateKey"
}]
};
var rsaPrivateKeyValidator = {
// RSAPrivateKey
name: "RSAPrivateKey",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.SEQUENCE,
constructed: true,
value: [{
// Version (INTEGER)
name: "RSAPrivateKey.version",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.INTEGER,
constructed: false,
capture: "privateKeyVersion"
}, {
// modulus (n)
name: "RSAPrivateKey.modulus",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.INTEGER,
constructed: false,
capture: "privateKeyModulus"
}, {
// publicExponent (e)
name: "RSAPrivateKey.publicExponent",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.INTEGER,
constructed: false,
capture: "privateKeyPublicExponent"
}, {
// privateExponent (d)
name: "RSAPrivateKey.privateExponent",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.INTEGER,
constructed: false,
capture: "privateKeyPrivateExponent"
}, {
// prime1 (p)
name: "RSAPrivateKey.prime1",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.INTEGER,
constructed: false,
capture: "privateKeyPrime1"
}, {
// prime2 (q)
name: "RSAPrivateKey.prime2",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.INTEGER,
constructed: false,
capture: "privateKeyPrime2"
}, {
// exponent1 (d mod (p-1))
name: "RSAPrivateKey.exponent1",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.INTEGER,
constructed: false,
capture: "privateKeyExponent1"
}, {
// exponent2 (d mod (q-1))
name: "RSAPrivateKey.exponent2",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.INTEGER,
constructed: false,
capture: "privateKeyExponent2"
}, {
// coefficient ((inverse of q) mod p)
name: "RSAPrivateKey.coefficient",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.INTEGER,
constructed: false,
capture: "privateKeyCoefficient"
}]
};
var rsaPublicKeyValidator = {
// RSAPublicKey
name: "RSAPublicKey",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.SEQUENCE,
constructed: true,
value: [{
// modulus (n)
name: "RSAPublicKey.modulus",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.INTEGER,
constructed: false,
capture: "publicKeyModulus"
}, {
// publicExponent (e)
name: "RSAPublicKey.exponent",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.INTEGER,
constructed: false,
capture: "publicKeyExponent"
}]
};
var publicKeyValidator = forge2.pki.rsa.publicKeyValidator = {
name: "SubjectPublicKeyInfo",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.SEQUENCE,
constructed: true,
captureAsn1: "subjectPublicKeyInfo",
value: [{
name: "SubjectPublicKeyInfo.AlgorithmIdentifier",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.SEQUENCE,
constructed: true,
value: [{
name: "AlgorithmIdentifier.algorithm",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.OID,
constructed: false,
capture: "publicKeyOid"
}]
}, {
// subjectPublicKey
name: "SubjectPublicKeyInfo.subjectPublicKey",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.BITSTRING,
constructed: false,
value: [{
// RSAPublicKey
name: "SubjectPublicKeyInfo.subjectPublicKey.RSAPublicKey",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.SEQUENCE,
constructed: true,
optional: true,
captureAsn1: "rsaPublicKey"
}]
}]
};
var digestInfoValidator = {
name: "DigestInfo",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.SEQUENCE,
constructed: true,
value: [{
name: "DigestInfo.DigestAlgorithm",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.SEQUENCE,
constructed: true,
value: [{
name: "DigestInfo.DigestAlgorithm.algorithmIdentifier",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.OID,
constructed: false,
capture: "algorithmIdentifier"
}, {
// NULL paramters
name: "DigestInfo.DigestAlgorithm.parameters",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.NULL,
// captured only to check existence for md2 and md5
capture: "parameters",
optional: true,
constructed: false
}]
}, {
// digest
name: "DigestInfo.digest",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.OCTETSTRING,
constructed: false,
capture: "digest"
}]
};
var emsaPkcs1v15encode = function(md) {
var oid;
if (md.algorithm in pki2.oids) {
oid = pki2.oids[md.algorithm];
} else {
var error = new Error("Unknown message digest algorithm.");
error.algorithm = md.algorithm;
throw error;
}
var oidBytes = asn1.oidToDer(oid).getBytes();
var digestInfo = asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.SEQUENCE,
true,
[]
);
var digestAlgorithm = asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.SEQUENCE,
true,
[]
);
digestAlgorithm.value.push(asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.OID,
false,
oidBytes
));
digestAlgorithm.value.push(asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.NULL,
false,
""
));
var digest = asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.OCTETSTRING,
false,
md.digest().getBytes()
);
digestInfo.value.push(digestAlgorithm);
digestInfo.value.push(digest);
return asn1.toDer(digestInfo).getBytes();
};
var _modPow = function(x, key2, pub) {
if (pub) {
return x.modPow(key2.e, key2.n);
}
if (!key2.p || !key2.q) {
return x.modPow(key2.d, key2.n);
}
if (!key2.dP) {
key2.dP = key2.d.mod(key2.p.subtract(BigInteger.ONE));
}
if (!key2.dQ) {
key2.dQ = key2.d.mod(key2.q.subtract(BigInteger.ONE));
}
if (!key2.qInv) {
key2.qInv = key2.q.modInverse(key2.p);
}
var r;
do {
r = new BigInteger(
forge2.util.bytesToHex(forge2.random.getBytes(key2.n.bitLength() / 8)),
16
);
} while (r.compareTo(key2.n) >= 0 || !r.gcd(key2.n).equals(BigInteger.ONE));
x = x.multiply(r.modPow(key2.e, key2.n)).mod(key2.n);
var xp = x.mod(key2.p).modPow(key2.dP, key2.p);
var xq = x.mod(key2.q).modPow(key2.dQ, key2.q);
while (xp.compareTo(xq) < 0) {
xp = xp.add(key2.p);
}
var y = xp.subtract(xq).multiply(key2.qInv).mod(key2.p).multiply(key2.q).add(xq);
y = y.multiply(r.modInverse(key2.n)).mod(key2.n);
return y;
};
pki2.rsa.encrypt = function(m, key2, bt) {
var pub = bt;
var eb;
var k = Math.ceil(key2.n.bitLength() / 8);
if (bt !== false && bt !== true) {
pub = bt === 2;
eb = _encodePkcs1_v1_5(m, key2, bt);
} else {
eb = forge2.util.createBuffer();
eb.putBytes(m);
}
var x = new BigInteger(eb.toHex(), 16);
var y = _modPow(x, key2, pub);
var yhex = y.toString(16);
var ed = forge2.util.createBuffer();
var zeros = k - Math.ceil(yhex.length / 2);
while (zeros > 0) {
ed.putByte(0);
--zeros;
}
ed.putBytes(forge2.util.hexToBytes(yhex));
return ed.getBytes();
};
pki2.rsa.decrypt = function(ed, key2, pub, ml) {
var k = Math.ceil(key2.n.bitLength() / 8);
if (ed.length !== k) {
var error = new Error("Encrypted message length is invalid.");
error.length = ed.length;
error.expected = k;
throw error;
}
var y = new BigInteger(forge2.util.createBuffer(ed).toHex(), 16);
if (y.compareTo(key2.n) >= 0) {
throw new Error("Encrypted message is invalid.");
}
var x = _modPow(y, key2, pub);
var xhex = x.toString(16);
var eb = forge2.util.createBuffer();
var zeros = k - Math.ceil(xhex.length / 2);
while (zeros > 0) {
eb.putByte(0);
--zeros;
}
eb.putBytes(forge2.util.hexToBytes(xhex));
if (ml !== false) {
return _decodePkcs1_v1_5(eb.getBytes(), key2, pub);
}
return eb.getBytes();
};
pki2.rsa.createKeyPairGenerationState = function(bits, e, options) {
if (typeof bits === "string") {
bits = parseInt(bits, 10);
}
bits = bits || 2048;
options = options || {};
var prng = options.prng || forge2.random;
var rng2 = {
// x is an array to fill with bytes
nextBytes: function(x) {
var b = prng.getBytesSync(x.length);
for (var i = 0; i < x.length; ++i) {
x[i] = b.charCodeAt(i);
}
}
};
var algorithm = options.algorithm || "PRIMEINC";
var rval;
if (algorithm === "PRIMEINC") {
rval = {
algorithm,
state: 0,
bits,
rng: rng2,
eInt: e || 65537,
e: new BigInteger(null),
p: null,
q: null,
qBits: bits >> 1,
pBits: bits - (bits >> 1),
pqState: 0,
num: null,
keys: null
};
rval.e.fromInt(rval.eInt);
} else {
throw new Error("Invalid key generation algorithm: " + algorithm);
}
return rval;
};
pki2.rsa.stepKeyPairGenerationState = function(state, n) {
if (!("algorithm" in state)) {
state.algorithm = "PRIMEINC";
}
var THIRTY = new BigInteger(null);
THIRTY.fromInt(30);
var deltaIdx = 0;
var op_or = function(x, y) {
return x | y;
};
var t1 = +/* @__PURE__ */ new Date();
var t2;
var total = 0;
while (state.keys === null && (n <= 0 || total < n)) {
if (state.state === 0) {
var bits = state.p === null ? state.pBits : state.qBits;
var bits1 = bits - 1;
if (state.pqState === 0) {
state.num = new BigInteger(bits, state.rng);
if (!state.num.testBit(bits1)) {
state.num.bitwiseTo(
BigInteger.ONE.shiftLeft(bits1),
op_or,
state.num
);
}
state.num.dAddOffset(31 - state.num.mod(THIRTY).byteValue(), 0);
deltaIdx = 0;
++state.pqState;
} else if (state.pqState === 1) {
if (state.num.bitLength() > bits) {
state.pqState = 0;
} else if (state.num.isProbablePrime(
_getMillerRabinTests(state.num.bitLength())
)) {
++state.pqState;
} else {
state.num.dAddOffset(GCD_30_DELTA[deltaIdx++ % 8], 0);
}
} else if (state.pqState === 2) {
state.pqState = state.num.subtract(BigInteger.ONE).gcd(state.e).compareTo(BigInteger.ONE) === 0 ? 3 : 0;
} else if (state.pqState === 3) {
state.pqState = 0;
if (state.p === null) {
state.p = state.num;
} else {
state.q = state.num;
}
if (state.p !== null && state.q !== null) {
++state.state;
}
state.num = null;
}
} else if (state.state === 1) {
if (state.p.compareTo(state.q) < 0) {
state.num = state.p;
state.p = state.q;
state.q = state.num;
}
++state.state;
} else if (state.state === 2) {
state.p1 = state.p.subtract(BigInteger.ONE);
state.q1 = state.q.subtract(BigInteger.ONE);
state.phi = state.p1.multiply(state.q1);
++state.state;
} else if (state.state === 3) {
if (state.phi.gcd(state.e).compareTo(BigInteger.ONE) === 0) {
++state.state;
} else {
state.p = null;
state.q = null;
state.state = 0;
}
} else if (state.state === 4) {
state.n = state.p.multiply(state.q);
if (state.n.bitLength() === state.bits) {
++state.state;
} else {
state.q = null;
state.state = 0;
}
} else if (state.state === 5) {
var d = state.e.modInverse(state.phi);
state.keys = {
privateKey: pki2.rsa.setPrivateKey(
state.n,
state.e,
d,
state.p,
state.q,
d.mod(state.p1),
d.mod(state.q1),
state.q.modInverse(state.p)
),
publicKey: pki2.rsa.setPublicKey(state.n, state.e)
};
}
t2 = +/* @__PURE__ */ new Date();
total += t2 - t1;
t1 = t2;
}
return state.keys !== null;
};
pki2.rsa.generateKeyPair = function(bits, e, options, callback) {
if (arguments.length === 1) {
if (typeof bits === "object") {
options = bits;
bits = void 0;
} else if (typeof bits === "function") {
callback = bits;
bits = void 0;
}
} else if (arguments.length === 2) {
if (typeof bits === "number") {
if (typeof e === "function") {
callback = e;
e = void 0;
} else if (typeof e !== "number") {
options = e;
e = void 0;
}
} else {
options = bits;
callback = e;
bits = void 0;
e = void 0;
}
} else if (arguments.length === 3) {
if (typeof e === "number") {
if (typeof options === "function") {
callback = options;
options = void 0;
}
} else {
callback = options;
options = e;
e = void 0;
}
}
options = options || {};
if (bits === void 0) {
bits = options.bits || 2048;
}
if (e === void 0) {
e = options.e || 65537;
}
if (!forge2.options.usePureJavaScript && !options.prng && bits >= 256 && bits <= 16384 && (e === 65537 || e === 3)) {
if (callback) {
if (_detectNodeCrypto("generateKeyPair")) {
return _crypto.generateKeyPair("rsa", {
modulusLength: bits,
publicExponent: e,
publicKeyEncoding: {
type: "spki",
format: "pem"
},
privateKeyEncoding: {
type: "pkcs8",
format: "pem"
}
}, function(err, pub, priv) {
if (err) {
return callback(err);
}
callback(null, {
privateKey: pki2.privateKeyFromPem(priv),
publicKey: pki2.publicKeyFromPem(pub)
});
});
}
if (_detectSubtleCrypto("generateKey") && _detectSubtleCrypto("exportKey")) {
return util2.globalScope.crypto.subtle.generateKey({
name: "RSASSA-PKCS1-v1_5",
modulusLength: bits,
publicExponent: _intToUint8Array(e),
hash: { name: "SHA-256" }
}, true, ["sign", "verify"]).then(function(pair) {
return util2.globalScope.crypto.subtle.exportKey(
"pkcs8",
pair.privateKey
);
}).then(void 0, function(err) {
callback(err);
}).then(function(pkcs8) {
if (pkcs8) {
var privateKey = pki2.privateKeyFromAsn1(
asn1.fromDer(forge2.util.createBuffer(pkcs8))
);
callback(null, {
privateKey,
publicKey: pki2.setRsaPublicKey(privateKey.n, privateKey.e)
});
}
});
}
if (_detectSubtleMsCrypto("generateKey") && _detectSubtleMsCrypto("exportKey")) {
var genOp = util2.globalScope.msCrypto.subtle.generateKey({
name: "RSASSA-PKCS1-v1_5",
modulusLength: bits,
publicExponent: _intToUint8Array(e),
hash: { name: "SHA-256" }
}, true, ["sign", "verify"]);
genOp.oncomplete = function(e2) {
var pair = e2.target.result;
var exportOp = util2.globalScope.msCrypto.subtle.exportKey(
"pkcs8",
pair.privateKey
);
exportOp.oncomplete = function(e3) {
var pkcs8 = e3.target.result;
var privateKey = pki2.privateKeyFromAsn1(
asn1.fromDer(forge2.util.createBuffer(pkcs8))
);
callback(null, {
privateKey,
publicKey: pki2.setRsaPublicKey(privateKey.n, privateKey.e)
});
};
exportOp.onerror = function(err) {
callback(err);
};
};
genOp.onerror = function(err) {
callback(err);
};
return;
}
} else {
if (_detectNodeCrypto("generateKeyPairSync")) {
var keypair = _crypto.generateKeyPairSync("rsa", {
modulusLength: bits,
publicExponent: e,
publicKeyEncoding: {
type: "spki",
format: "pem"
},
privateKeyEncoding: {
type: "pkcs8",
format: "pem"
}
});
return {
privateKey: pki2.privateKeyFromPem(keypair.privateKey),
publicKey: pki2.publicKeyFromPem(keypair.publicKey)
};
}
}
}
var state = pki2.rsa.createKeyPairGenerationState(bits, e, options);
if (!callback) {
pki2.rsa.stepKeyPairGenerationState(state, 0);
return state.keys;
}
_generateKeyPair(state, options, callback);
};
pki2.setRsaPublicKey = pki2.rsa.setPublicKey = function(n, e) {
var key2 = {
n,
e
};
key2.encrypt = function(data2, scheme, schemeOptions) {
if (typeof scheme === "string") {
scheme = scheme.toUpperCase();
} else if (scheme === void 0) {
scheme = "RSAES-PKCS1-V1_5";
}
if (scheme === "RSAES-PKCS1-V1_5") {
scheme = {
encode: function(m, key3, pub) {
return _encodePkcs1_v1_5(m, key3, 2).getBytes();
}
};
} else if (scheme === "RSA-OAEP" || scheme === "RSAES-OAEP") {
scheme = {
encode: function(m, key3) {
return forge2.pkcs1.encode_rsa_oaep(key3, m, schemeOptions);
}
};
} else if (["RAW", "NONE", "NULL", null].indexOf(scheme) !== -1) {
scheme = { encode: function(e3) {
return e3;
} };
} else if (typeof scheme === "string") {
throw new Error('Unsupported encryption scheme: "' + scheme + '".');
}
var e2 = scheme.encode(data2, key2, true);
return pki2.rsa.encrypt(e2, key2, true);
};
key2.verify = function(digest, signature, scheme, options) {
if (typeof scheme === "string") {
scheme = scheme.toUpperCase();
} else if (scheme === void 0) {
scheme = "RSASSA-PKCS1-V1_5";
}
if (options === void 0) {
options = {
_parseAllDigestBytes: true
};
}
if (!("_parseAllDigestBytes" in options)) {
options._parseAllDigestBytes = true;
}
if (scheme === "RSASSA-PKCS1-V1_5") {
scheme = {
verify: function(digest2, d2) {
d2 = _decodePkcs1_v1_5(d2, key2, true);
var obj = asn1.fromDer(d2, {
parseAllBytes: options._parseAllDigestBytes
});
var capture = {};
var errors = [];
if (!asn1.validate(obj, digestInfoValidator, capture, errors)) {
var error = new Error(
"ASN.1 object does not contain a valid RSASSA-PKCS1-v1_5 DigestInfo value."
);
error.errors = errors;
throw error;
}
var oid = asn1.derToOid(capture.algorithmIdentifier);
if (!(oid === forge2.oids.md2 || oid === forge2.oids.md5 || oid === forge2.oids.sha1 || oid === forge2.oids.sha224 || oid === forge2.oids.sha256 || oid === forge2.oids.sha384 || oid === forge2.oids.sha512 || oid === forge2.oids["sha512-224"] || oid === forge2.oids["sha512-256"])) {
var error = new Error(
"Unknown RSASSA-PKCS1-v1_5 DigestAlgorithm identifier."
);
error.oid = oid;
throw error;
}
if (oid === forge2.oids.md2 || oid === forge2.oids.md5) {
if (!("parameters" in capture)) {
throw new Error(
"ASN.1 object does not contain a valid RSASSA-PKCS1-v1_5 DigestInfo value. Missing algorithm identifer NULL parameters."
);
}
}
return digest2 === capture.digest;
}
};
} else if (scheme === "NONE" || scheme === "NULL" || scheme === null) {
scheme = {
verify: function(digest2, d2) {
d2 = _decodePkcs1_v1_5(d2, key2, true);
return digest2 === d2;
}
};
}
var d = pki2.rsa.decrypt(signature, key2, true, false);
return scheme.verify(digest, d, key2.n.bitLength());
};
return key2;
};
pki2.setRsaPrivateKey = pki2.rsa.setPrivateKey = function(n, e, d, p, q, dP, dQ, qInv) {
var key2 = {
n,
e,
d,
p,
q,
dP,
dQ,
qInv
};
key2.decrypt = function(data2, scheme, schemeOptions) {
if (typeof scheme === "string") {
scheme = scheme.toUpperCase();
} else if (scheme === void 0) {
scheme = "RSAES-PKCS1-V1_5";
}
var d2 = pki2.rsa.decrypt(data2, key2, false, false);
if (scheme === "RSAES-PKCS1-V1_5") {
scheme = { decode: _decodePkcs1_v1_5 };
} else if (scheme === "RSA-OAEP" || scheme === "RSAES-OAEP") {
scheme = {
decode: function(d3, key3) {
return forge2.pkcs1.decode_rsa_oaep(key3, d3, schemeOptions);
}
};
} else if (["RAW", "NONE", "NULL", null].indexOf(scheme) !== -1) {
scheme = { decode: function(d3) {
return d3;
} };
} else {
throw new Error('Unsupported encryption scheme: "' + scheme + '".');
}
return scheme.decode(d2, key2, false);
};
key2.sign = function(md, scheme) {
var bt = false;
if (typeof scheme === "string") {
scheme = scheme.toUpperCase();
}
if (scheme === void 0 || scheme === "RSASSA-PKCS1-V1_5") {
scheme = { encode: emsaPkcs1v15encode };
bt = 1;
} else if (scheme === "NONE" || scheme === "NULL" || scheme === null) {
scheme = { encode: function() {
return md;
} };
bt = 1;
}
var d2 = scheme.encode(md, key2.n.bitLength());
return pki2.rsa.encrypt(d2, key2, bt);
};
return key2;
};
pki2.wrapRsaPrivateKey = function(rsaKey) {
return asn1.create(asn1.Class.UNIVERSAL, asn1.Type.SEQUENCE, true, [
// version (0)
asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.INTEGER,
false,
asn1.integerToDer(0).getBytes()
),
// privateKeyAlgorithm
asn1.create(asn1.Class.UNIVERSAL, asn1.Type.SEQUENCE, true, [
asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.OID,
false,
asn1.oidToDer(pki2.oids.rsaEncryption).getBytes()
),
asn1.create(asn1.Class.UNIVERSAL, asn1.Type.NULL, false, "")
]),
// PrivateKey
asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.OCTETSTRING,
false,
asn1.toDer(rsaKey).getBytes()
)
]);
};
pki2.privateKeyFromAsn1 = function(obj) {
var capture = {};
var errors = [];
if (asn1.validate(obj, privateKeyValidator, capture, errors)) {
obj = asn1.fromDer(forge2.util.createBuffer(capture.privateKey));
}
capture = {};
errors = [];
if (!asn1.validate(obj, rsaPrivateKeyValidator, capture, errors)) {
var error = new Error("Cannot read private key. ASN.1 object does not contain an RSAPrivateKey.");
error.errors = errors;
throw error;
}
var n, e, d, p, q, dP, dQ, qInv;
n = forge2.util.createBuffer(capture.privateKeyModulus).toHex();
e = forge2.util.createBuffer(capture.privateKeyPublicExponent).toHex();
d = forge2.util.createBuffer(capture.privateKeyPrivateExponent).toHex();
p = forge2.util.createBuffer(capture.privateKeyPrime1).toHex();
q = forge2.util.createBuffer(capture.privateKeyPrime2).toHex();
dP = forge2.util.createBuffer(capture.privateKeyExponent1).toHex();
dQ = forge2.util.createBuffer(capture.privateKeyExponent2).toHex();
qInv = forge2.util.createBuffer(capture.privateKeyCoefficient).toHex();
return pki2.setRsaPrivateKey(
new BigInteger(n, 16),
new BigInteger(e, 16),
new BigInteger(d, 16),
new BigInteger(p, 16),
new BigInteger(q, 16),
new BigInteger(dP, 16),
new BigInteger(dQ, 16),
new BigInteger(qInv, 16)
);
};
pki2.privateKeyToAsn1 = pki2.privateKeyToRSAPrivateKey = function(key2) {
return asn1.create(asn1.Class.UNIVERSAL, asn1.Type.SEQUENCE, true, [
// version (0 = only 2 primes, 1 multiple primes)
asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.INTEGER,
false,
asn1.integerToDer(0).getBytes()
),
// modulus (n)
asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.INTEGER,
false,
_bnToBytes(key2.n)
),
// publicExponent (e)
asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.INTEGER,
false,
_bnToBytes(key2.e)
),
// privateExponent (d)
asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.INTEGER,
false,
_bnToBytes(key2.d)
),
// privateKeyPrime1 (p)
asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.INTEGER,
false,
_bnToBytes(key2.p)
),
// privateKeyPrime2 (q)
asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.INTEGER,
false,
_bnToBytes(key2.q)
),
// privateKeyExponent1 (dP)
asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.INTEGER,
false,
_bnToBytes(key2.dP)
),
// privateKeyExponent2 (dQ)
asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.INTEGER,
false,
_bnToBytes(key2.dQ)
),
// coefficient (qInv)
asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.INTEGER,
false,
_bnToBytes(key2.qInv)
)
]);
};
pki2.publicKeyFromAsn1 = function(obj) {
var capture = {};
var errors = [];
if (asn1.validate(obj, publicKeyValidator, capture, errors)) {
var oid = asn1.derToOid(capture.publicKeyOid);
if (oid !== pki2.oids.rsaEncryption) {
var error = new Error("Cannot read public key. Unknown OID.");
error.oid = oid;
throw error;
}
obj = capture.rsaPublicKey;
}
errors = [];
if (!asn1.validate(obj, rsaPublicKeyValidator, capture, errors)) {
var error = new Error("Cannot read public key. ASN.1 object does not contain an RSAPublicKey.");
error.errors = errors;
throw error;
}
var n = forge2.util.createBuffer(capture.publicKeyModulus).toHex();
var e = forge2.util.createBuffer(capture.publicKeyExponent).toHex();
return pki2.setRsaPublicKey(
new BigInteger(n, 16),
new BigInteger(e, 16)
);
};
pki2.publicKeyToAsn1 = pki2.publicKeyToSubjectPublicKeyInfo = function(key2) {
return asn1.create(asn1.Class.UNIVERSAL, asn1.Type.SEQUENCE, true, [
// AlgorithmIdentifier
asn1.create(asn1.Class.UNIVERSAL, asn1.Type.SEQUENCE, true, [
// algorithm
asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.OID,
false,
asn1.oidToDer(pki2.oids.rsaEncryption).getBytes()
),
// parameters (null)
asn1.create(asn1.Class.UNIVERSAL, asn1.Type.NULL, false, "")
]),
// subjectPublicKey
asn1.create(asn1.Class.UNIVERSAL, asn1.Type.BITSTRING, false, [
pki2.publicKeyToRSAPublicKey(key2)
])
]);
};
pki2.publicKeyToRSAPublicKey = function(key2) {
return asn1.create(asn1.Class.UNIVERSAL, asn1.Type.SEQUENCE, true, [
// modulus (n)
asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.INTEGER,
false,
_bnToBytes(key2.n)
),
// publicExponent (e)
asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.INTEGER,
false,
_bnToBytes(key2.e)
)
]);
};
function _encodePkcs1_v1_5(m, key2, bt) {
var eb = forge2.util.createBuffer();
var k = Math.ceil(key2.n.bitLength() / 8);
if (m.length > k - 11) {
var error = new Error("Message is too long for PKCS#1 v1.5 padding.");
error.length = m.length;
error.max = k - 11;
throw error;
}
eb.putByte(0);
eb.putByte(bt);
var padNum = k - 3 - m.length;
var padByte;
if (bt === 0 || bt === 1) {
padByte = bt === 0 ? 0 : 255;
for (var i = 0; i < padNum; ++i) {
eb.putByte(padByte);
}
} else {
while (padNum > 0) {
var numZeros = 0;
var padBytes = forge2.random.getBytes(padNum);
for (var i = 0; i < padNum; ++i) {
padByte = padBytes.charCodeAt(i);
if (padByte === 0) {
++numZeros;
} else {
eb.putByte(padByte);
}
}
padNum = numZeros;
}
}
eb.putByte(0);
eb.putBytes(m);
return eb;
}
function _decodePkcs1_v1_5(em, key2, pub, ml) {
var k = Math.ceil(key2.n.bitLength() / 8);
var eb = forge2.util.createBuffer(em);
var first2 = eb.getByte();
var bt = eb.getByte();
if (first2 !== 0 || pub && bt !== 0 && bt !== 1 || !pub && bt != 2 || pub && bt === 0 && typeof ml === "undefined") {
throw new Error("Encryption block is invalid.");
}
var padNum = 0;
if (bt === 0) {
padNum = k - 3 - ml;
for (var i = 0; i < padNum; ++i) {
if (eb.getByte() !== 0) {
throw new Error("Encryption block is invalid.");
}
}
} else if (bt === 1) {
padNum = 0;
while (eb.length() > 1) {
if (eb.getByte() !== 255) {
--eb.read;
break;
}
++padNum;
}
} else if (bt === 2) {
padNum = 0;
while (eb.length() > 1) {
if (eb.getByte() === 0) {
--eb.read;
break;
}
++padNum;
}
}
var zero = eb.getByte();
if (zero !== 0 || padNum !== k - 3 - eb.length()) {
throw new Error("Encryption block is invalid.");
}
return eb.getBytes();
}
function _generateKeyPair(state, options, callback) {
if (typeof options === "function") {
callback = options;
options = {};
}
options = options || {};
var opts = {
algorithm: {
name: options.algorithm || "PRIMEINC",
options: {
workers: options.workers || 2,
workLoad: options.workLoad || 100,
workerScript: options.workerScript
}
}
};
if ("prng" in options) {
opts.prng = options.prng;
}
generate();
function generate() {
getPrime(state.pBits, function(err, num) {
if (err) {
return callback(err);
}
state.p = num;
if (state.q !== null) {
return finish(err, state.q);
}
getPrime(state.qBits, finish);
});
}
function getPrime(bits, callback2) {
forge2.prime.generateProbablePrime(bits, opts, callback2);
}
function finish(err, num) {
if (err) {
return callback(err);
}
state.q = num;
if (state.p.compareTo(state.q) < 0) {
var tmp = state.p;
state.p = state.q;
state.q = tmp;
}
if (state.p.subtract(BigInteger.ONE).gcd(state.e).compareTo(BigInteger.ONE) !== 0) {
state.p = null;
generate();
return;
}
if (state.q.subtract(BigInteger.ONE).gcd(state.e).compareTo(BigInteger.ONE) !== 0) {
state.q = null;
getPrime(state.qBits, finish);
return;
}
state.p1 = state.p.subtract(BigInteger.ONE);
state.q1 = state.q.subtract(BigInteger.ONE);
state.phi = state.p1.multiply(state.q1);
if (state.phi.gcd(state.e).compareTo(BigInteger.ONE) !== 0) {
state.p = state.q = null;
generate();
return;
}
state.n = state.p.multiply(state.q);
if (state.n.bitLength() !== state.bits) {
state.q = null;
getPrime(state.qBits, finish);
return;
}
var d = state.e.modInverse(state.phi);
state.keys = {
privateKey: pki2.rsa.setPrivateKey(
state.n,
state.e,
d,
state.p,
state.q,
d.mod(state.p1),
d.mod(state.q1),
state.q.modInverse(state.p)
),
publicKey: pki2.rsa.setPublicKey(state.n, state.e)
};
callback(null, state.keys);
}
}
function _bnToBytes(b) {
var hex = b.toString(16);
if (hex[0] >= "8") {
hex = "00" + hex;
}
var bytes = forge2.util.hexToBytes(hex);
if (bytes.length > 1 && // leading 0x00 for positive integer
(bytes.charCodeAt(0) === 0 && (bytes.charCodeAt(1) & 128) === 0 || // leading 0xFF for negative integer
bytes.charCodeAt(0) === 255 && (bytes.charCodeAt(1) & 128) === 128)) {
return bytes.substr(1);
}
return bytes;
}
function _getMillerRabinTests(bits) {
if (bits <= 100)
return 27;
if (bits <= 150)
return 18;
if (bits <= 200)
return 15;
if (bits <= 250)
return 12;
if (bits <= 300)
return 9;
if (bits <= 350)
return 8;
if (bits <= 400)
return 7;
if (bits <= 500)
return 6;
if (bits <= 600)
return 5;
if (bits <= 800)
return 4;
if (bits <= 1250)
return 3;
return 2;
}
function _detectNodeCrypto(fn) {
return forge2.util.isNodejs && typeof _crypto[fn] === "function";
}
function _detectSubtleCrypto(fn) {
return typeof util2.globalScope !== "undefined" && typeof util2.globalScope.crypto === "object" && typeof util2.globalScope.crypto.subtle === "object" && typeof util2.globalScope.crypto.subtle[fn] === "function";
}
function _detectSubtleMsCrypto(fn) {
return typeof util2.globalScope !== "undefined" && typeof util2.globalScope.msCrypto === "object" && typeof util2.globalScope.msCrypto.subtle === "object" && typeof util2.globalScope.msCrypto.subtle[fn] === "function";
}
function _intToUint8Array(x) {
var bytes = forge2.util.hexToBytes(x.toString(16));
var buffer = new Uint8Array(bytes.length);
for (var i = 0; i < bytes.length; ++i) {
buffer[i] = bytes.charCodeAt(i);
}
return buffer;
}
}
});
// node_modules/node-forge/lib/pbe.js
var require_pbe = __commonJS({
"node_modules/node-forge/lib/pbe.js"(exports2, module2) {
"use strict";
var forge2 = require_forge();
require_aes();
require_asn1();
require_des();
require_md();
require_oids();
require_pbkdf2();
require_pem();
require_random();
require_rc2();
require_rsa();
require_util();
if (typeof BigInteger === "undefined") {
BigInteger = forge2.jsbn.BigInteger;
}
var BigInteger;
var asn1 = forge2.asn1;
var pki2 = forge2.pki = forge2.pki || {};
module2.exports = pki2.pbe = forge2.pbe = forge2.pbe || {};
var oids = pki2.oids;
var encryptedPrivateKeyValidator = {
name: "EncryptedPrivateKeyInfo",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.SEQUENCE,
constructed: true,
value: [{
name: "EncryptedPrivateKeyInfo.encryptionAlgorithm",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.SEQUENCE,
constructed: true,
value: [{
name: "AlgorithmIdentifier.algorithm",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.OID,
constructed: false,
capture: "encryptionOid"
}, {
name: "AlgorithmIdentifier.parameters",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.SEQUENCE,
constructed: true,
captureAsn1: "encryptionParams"
}]
}, {
// encryptedData
name: "EncryptedPrivateKeyInfo.encryptedData",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.OCTETSTRING,
constructed: false,
capture: "encryptedData"
}]
};
var PBES2AlgorithmsValidator = {
name: "PBES2Algorithms",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.SEQUENCE,
constructed: true,
value: [{
name: "PBES2Algorithms.keyDerivationFunc",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.SEQUENCE,
constructed: true,
value: [{
name: "PBES2Algorithms.keyDerivationFunc.oid",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.OID,
constructed: false,
capture: "kdfOid"
}, {
name: "PBES2Algorithms.params",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.SEQUENCE,
constructed: true,
value: [{
name: "PBES2Algorithms.params.salt",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.OCTETSTRING,
constructed: false,
capture: "kdfSalt"
}, {
name: "PBES2Algorithms.params.iterationCount",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.INTEGER,
constructed: false,
capture: "kdfIterationCount"
}, {
name: "PBES2Algorithms.params.keyLength",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.INTEGER,
constructed: false,
optional: true,
capture: "keyLength"
}, {
// prf
name: "PBES2Algorithms.params.prf",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.SEQUENCE,
constructed: true,
optional: true,
value: [{
name: "PBES2Algorithms.params.prf.algorithm",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.OID,
constructed: false,
capture: "prfOid"
}]
}]
}]
}, {
name: "PBES2Algorithms.encryptionScheme",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.SEQUENCE,
constructed: true,
value: [{
name: "PBES2Algorithms.encryptionScheme.oid",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.OID,
constructed: false,
capture: "encOid"
}, {
name: "PBES2Algorithms.encryptionScheme.iv",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.OCTETSTRING,
constructed: false,
capture: "encIv"
}]
}]
};
var pkcs12PbeParamsValidator = {
name: "pkcs-12PbeParams",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.SEQUENCE,
constructed: true,
value: [{
name: "pkcs-12PbeParams.salt",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.OCTETSTRING,
constructed: false,
capture: "salt"
}, {
name: "pkcs-12PbeParams.iterations",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.INTEGER,
constructed: false,
capture: "iterations"
}]
};
pki2.encryptPrivateKeyInfo = function(obj, password, options) {
options = options || {};
options.saltSize = options.saltSize || 8;
options.count = options.count || 2048;
options.algorithm = options.algorithm || "aes128";
options.prfAlgorithm = options.prfAlgorithm || "sha1";
var salt = forge2.random.getBytesSync(options.saltSize);
var count = options.count;
var countBytes = asn1.integerToDer(count);
var dkLen;
var encryptionAlgorithm;
var encryptedData;
if (options.algorithm.indexOf("aes") === 0 || options.algorithm === "des") {
var ivLen, encOid, cipherFn;
switch (options.algorithm) {
case "aes128":
dkLen = 16;
ivLen = 16;
encOid = oids["aes128-CBC"];
cipherFn = forge2.aes.createEncryptionCipher;
break;
case "aes192":
dkLen = 24;
ivLen = 16;
encOid = oids["aes192-CBC"];
cipherFn = forge2.aes.createEncryptionCipher;
break;
case "aes256":
dkLen = 32;
ivLen = 16;
encOid = oids["aes256-CBC"];
cipherFn = forge2.aes.createEncryptionCipher;
break;
case "des":
dkLen = 8;
ivLen = 8;
encOid = oids["desCBC"];
cipherFn = forge2.des.createEncryptionCipher;
break;
default:
var error = new Error("Cannot encrypt private key. Unknown encryption algorithm.");
error.algorithm = options.algorithm;
throw error;
}
var prfAlgorithm = "hmacWith" + options.prfAlgorithm.toUpperCase();
var md = prfAlgorithmToMessageDigest(prfAlgorithm);
var dk = forge2.pkcs5.pbkdf2(password, salt, count, dkLen, md);
var iv = forge2.random.getBytesSync(ivLen);
var cipher = cipherFn(dk);
cipher.start(iv);
cipher.update(asn1.toDer(obj));
cipher.finish();
encryptedData = cipher.output.getBytes();
var params = createPbkdf2Params(salt, countBytes, dkLen, prfAlgorithm);
encryptionAlgorithm = asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.SEQUENCE,
true,
[
asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.OID,
false,
asn1.oidToDer(oids["pkcs5PBES2"]).getBytes()
),
asn1.create(asn1.Class.UNIVERSAL, asn1.Type.SEQUENCE, true, [
// keyDerivationFunc
asn1.create(asn1.Class.UNIVERSAL, asn1.Type.SEQUENCE, true, [
asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.OID,
false,
asn1.oidToDer(oids["pkcs5PBKDF2"]).getBytes()
),
// PBKDF2-params
params
]),
// encryptionScheme
asn1.create(asn1.Class.UNIVERSAL, asn1.Type.SEQUENCE, true, [
asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.OID,
false,
asn1.oidToDer(encOid).getBytes()
),
// iv
asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.OCTETSTRING,
false,
iv
)
])
])
]
);
} else if (options.algorithm === "3des") {
dkLen = 24;
var saltBytes = new forge2.util.ByteBuffer(salt);
var dk = pki2.pbe.generatePkcs12Key(password, saltBytes, 1, count, dkLen);
var iv = pki2.pbe.generatePkcs12Key(password, saltBytes, 2, count, dkLen);
var cipher = forge2.des.createEncryptionCipher(dk);
cipher.start(iv);
cipher.update(asn1.toDer(obj));
cipher.finish();
encryptedData = cipher.output.getBytes();
encryptionAlgorithm = asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.SEQUENCE,
true,
[
asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.OID,
false,
asn1.oidToDer(oids["pbeWithSHAAnd3-KeyTripleDES-CBC"]).getBytes()
),
// pkcs-12PbeParams
asn1.create(asn1.Class.UNIVERSAL, asn1.Type.SEQUENCE, true, [
// salt
asn1.create(asn1.Class.UNIVERSAL, asn1.Type.OCTETSTRING, false, salt),
// iteration count
asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.INTEGER,
false,
countBytes.getBytes()
)
])
]
);
} else {
var error = new Error("Cannot encrypt private key. Unknown encryption algorithm.");
error.algorithm = options.algorithm;
throw error;
}
var rval = asn1.create(asn1.Class.UNIVERSAL, asn1.Type.SEQUENCE, true, [
// encryptionAlgorithm
encryptionAlgorithm,
// encryptedData
asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.OCTETSTRING,
false,
encryptedData
)
]);
return rval;
};
pki2.decryptPrivateKeyInfo = function(obj, password) {
var rval = null;
var capture = {};
var errors = [];
if (!asn1.validate(obj, encryptedPrivateKeyValidator, capture, errors)) {
var error = new Error("Cannot read encrypted private key. ASN.1 object is not a supported EncryptedPrivateKeyInfo.");
error.errors = errors;
throw error;
}
var oid = asn1.derToOid(capture.encryptionOid);
var cipher = pki2.pbe.getCipher(oid, capture.encryptionParams, password);
var encrypted = forge2.util.createBuffer(capture.encryptedData);
cipher.update(encrypted);
if (cipher.finish()) {
rval = asn1.fromDer(cipher.output);
}
return rval;
};
pki2.encryptedPrivateKeyToPem = function(epki, maxline) {
var msg = {
type: "ENCRYPTED PRIVATE KEY",
body: asn1.toDer(epki).getBytes()
};
return forge2.pem.encode(msg, { maxline });
};
pki2.encryptedPrivateKeyFromPem = function(pem) {
var msg = forge2.pem.decode(pem)[0];
if (msg.type !== "ENCRYPTED PRIVATE KEY") {
var error = new Error('Could not convert encrypted private key from PEM; PEM header type is "ENCRYPTED PRIVATE KEY".');
error.headerType = msg.type;
throw error;
}
if (msg.procType && msg.procType.type === "ENCRYPTED") {
throw new Error("Could not convert encrypted private key from PEM; PEM is encrypted.");
}
return asn1.fromDer(msg.body);
};
pki2.encryptRsaPrivateKey = function(rsaKey, password, options) {
options = options || {};
if (!options.legacy) {
var rval = pki2.wrapRsaPrivateKey(pki2.privateKeyToAsn1(rsaKey));
rval = pki2.encryptPrivateKeyInfo(rval, password, options);
return pki2.encryptedPrivateKeyToPem(rval);
}
var algorithm;
var iv;
var dkLen;
var cipherFn;
switch (options.algorithm) {
case "aes128":
algorithm = "AES-128-CBC";
dkLen = 16;
iv = forge2.random.getBytesSync(16);
cipherFn = forge2.aes.createEncryptionCipher;
break;
case "aes192":
algorithm = "AES-192-CBC";
dkLen = 24;
iv = forge2.random.getBytesSync(16);
cipherFn = forge2.aes.createEncryptionCipher;
break;
case "aes256":
algorithm = "AES-256-CBC";
dkLen = 32;
iv = forge2.random.getBytesSync(16);
cipherFn = forge2.aes.createEncryptionCipher;
break;
case "3des":
algorithm = "DES-EDE3-CBC";
dkLen = 24;
iv = forge2.random.getBytesSync(8);
cipherFn = forge2.des.createEncryptionCipher;
break;
case "des":
algorithm = "DES-CBC";
dkLen = 8;
iv = forge2.random.getBytesSync(8);
cipherFn = forge2.des.createEncryptionCipher;
break;
default:
var error = new Error('Could not encrypt RSA private key; unsupported encryption algorithm "' + options.algorithm + '".');
error.algorithm = options.algorithm;
throw error;
}
var dk = forge2.pbe.opensslDeriveBytes(password, iv.substr(0, 8), dkLen);
var cipher = cipherFn(dk);
cipher.start(iv);
cipher.update(asn1.toDer(pki2.privateKeyToAsn1(rsaKey)));
cipher.finish();
var msg = {
type: "RSA PRIVATE KEY",
procType: {
version: "4",
type: "ENCRYPTED"
},
dekInfo: {
algorithm,
parameters: forge2.util.bytesToHex(iv).toUpperCase()
},
body: cipher.output.getBytes()
};
return forge2.pem.encode(msg);
};
pki2.decryptRsaPrivateKey = function(pem, password) {
var rval = null;
var msg = forge2.pem.decode(pem)[0];
if (msg.type !== "ENCRYPTED PRIVATE KEY" && msg.type !== "PRIVATE KEY" && msg.type !== "RSA PRIVATE KEY") {
var error = new Error('Could not convert private key from PEM; PEM header type is not "ENCRYPTED PRIVATE KEY", "PRIVATE KEY", or "RSA PRIVATE KEY".');
error.headerType = error;
throw error;
}
if (msg.procType && msg.procType.type === "ENCRYPTED") {
var dkLen;
var cipherFn;
switch (msg.dekInfo.algorithm) {
case "DES-CBC":
dkLen = 8;
cipherFn = forge2.des.createDecryptionCipher;
break;
case "DES-EDE3-CBC":
dkLen = 24;
cipherFn = forge2.des.createDecryptionCipher;
break;
case "AES-128-CBC":
dkLen = 16;
cipherFn = forge2.aes.createDecryptionCipher;
break;
case "AES-192-CBC":
dkLen = 24;
cipherFn = forge2.aes.createDecryptionCipher;
break;
case "AES-256-CBC":
dkLen = 32;
cipherFn = forge2.aes.createDecryptionCipher;
break;
case "RC2-40-CBC":
dkLen = 5;
cipherFn = function(key2) {
return forge2.rc2.createDecryptionCipher(key2, 40);
};
break;
case "RC2-64-CBC":
dkLen = 8;
cipherFn = function(key2) {
return forge2.rc2.createDecryptionCipher(key2, 64);
};
break;
case "RC2-128-CBC":
dkLen = 16;
cipherFn = function(key2) {
return forge2.rc2.createDecryptionCipher(key2, 128);
};
break;
default:
var error = new Error('Could not decrypt private key; unsupported encryption algorithm "' + msg.dekInfo.algorithm + '".');
error.algorithm = msg.dekInfo.algorithm;
throw error;
}
var iv = forge2.util.hexToBytes(msg.dekInfo.parameters);
var dk = forge2.pbe.opensslDeriveBytes(password, iv.substr(0, 8), dkLen);
var cipher = cipherFn(dk);
cipher.start(iv);
cipher.update(forge2.util.createBuffer(msg.body));
if (cipher.finish()) {
rval = cipher.output.getBytes();
} else {
return rval;
}
} else {
rval = msg.body;
}
if (msg.type === "ENCRYPTED PRIVATE KEY") {
rval = pki2.decryptPrivateKeyInfo(asn1.fromDer(rval), password);
} else {
rval = asn1.fromDer(rval);
}
if (rval !== null) {
rval = pki2.privateKeyFromAsn1(rval);
}
return rval;
};
pki2.pbe.generatePkcs12Key = function(password, salt, id, iter, n, md) {
var j, l;
if (typeof md === "undefined" || md === null) {
if (!("sha1" in forge2.md)) {
throw new Error('"sha1" hash algorithm unavailable.');
}
md = forge2.md.sha1.create();
}
var u2 = md.digestLength;
var v = md.blockLength;
var result = new forge2.util.ByteBuffer();
var passBuf = new forge2.util.ByteBuffer();
if (password !== null && password !== void 0) {
for (l = 0; l < password.length; l++) {
passBuf.putInt16(password.charCodeAt(l));
}
passBuf.putInt16(0);
}
var p = passBuf.length();
var s = salt.length();
var D = new forge2.util.ByteBuffer();
D.fillWithByte(id, v);
var Slen = v * Math.ceil(s / v);
var S = new forge2.util.ByteBuffer();
for (l = 0; l < Slen; l++) {
S.putByte(salt.at(l % s));
}
var Plen = v * Math.ceil(p / v);
var P = new forge2.util.ByteBuffer();
for (l = 0; l < Plen; l++) {
P.putByte(passBuf.at(l % p));
}
var I = S;
I.putBuffer(P);
var c = Math.ceil(n / u2);
for (var i = 1; i <= c; i++) {
var buf = new forge2.util.ByteBuffer();
buf.putBytes(D.bytes());
buf.putBytes(I.bytes());
for (var round2 = 0; round2 < iter; round2++) {
md.start();
md.update(buf.getBytes());
buf = md.digest();
}
var B = new forge2.util.ByteBuffer();
for (l = 0; l < v; l++) {
B.putByte(buf.at(l % u2));
}
var k = Math.ceil(s / v) + Math.ceil(p / v);
var Inew = new forge2.util.ByteBuffer();
for (j = 0; j < k; j++) {
var chunk = new forge2.util.ByteBuffer(I.getBytes(v));
var x = 511;
for (l = B.length() - 1; l >= 0; l--) {
x = x >> 8;
x += B.at(l) + chunk.at(l);
chunk.setAt(l, x & 255);
}
Inew.putBuffer(chunk);
}
I = Inew;
result.putBuffer(buf);
}
result.truncate(result.length() - n);
return result;
};
pki2.pbe.getCipher = function(oid, params, password) {
switch (oid) {
case pki2.oids["pkcs5PBES2"]:
return pki2.pbe.getCipherForPBES2(oid, params, password);
case pki2.oids["pbeWithSHAAnd3-KeyTripleDES-CBC"]:
case pki2.oids["pbewithSHAAnd40BitRC2-CBC"]:
return pki2.pbe.getCipherForPKCS12PBE(oid, params, password);
default:
var error = new Error("Cannot read encrypted PBE data block. Unsupported OID.");
error.oid = oid;
error.supportedOids = [
"pkcs5PBES2",
"pbeWithSHAAnd3-KeyTripleDES-CBC",
"pbewithSHAAnd40BitRC2-CBC"
];
throw error;
}
};
pki2.pbe.getCipherForPBES2 = function(oid, params, password) {
var capture = {};
var errors = [];
if (!asn1.validate(params, PBES2AlgorithmsValidator, capture, errors)) {
var error = new Error("Cannot read password-based-encryption algorithm parameters. ASN.1 object is not a supported EncryptedPrivateKeyInfo.");
error.errors = errors;
throw error;
}
oid = asn1.derToOid(capture.kdfOid);
if (oid !== pki2.oids["pkcs5PBKDF2"]) {
var error = new Error("Cannot read encrypted private key. Unsupported key derivation function OID.");
error.oid = oid;
error.supportedOids = ["pkcs5PBKDF2"];
throw error;
}
oid = asn1.derToOid(capture.encOid);
if (oid !== pki2.oids["aes128-CBC"] && oid !== pki2.oids["aes192-CBC"] && oid !== pki2.oids["aes256-CBC"] && oid !== pki2.oids["des-EDE3-CBC"] && oid !== pki2.oids["desCBC"]) {
var error = new Error("Cannot read encrypted private key. Unsupported encryption scheme OID.");
error.oid = oid;
error.supportedOids = [
"aes128-CBC",
"aes192-CBC",
"aes256-CBC",
"des-EDE3-CBC",
"desCBC"
];
throw error;
}
var salt = capture.kdfSalt;
var count = forge2.util.createBuffer(capture.kdfIterationCount);
count = count.getInt(count.length() << 3);
var dkLen;
var cipherFn;
switch (pki2.oids[oid]) {
case "aes128-CBC":
dkLen = 16;
cipherFn = forge2.aes.createDecryptionCipher;
break;
case "aes192-CBC":
dkLen = 24;
cipherFn = forge2.aes.createDecryptionCipher;
break;
case "aes256-CBC":
dkLen = 32;
cipherFn = forge2.aes.createDecryptionCipher;
break;
case "des-EDE3-CBC":
dkLen = 24;
cipherFn = forge2.des.createDecryptionCipher;
break;
case "desCBC":
dkLen = 8;
cipherFn = forge2.des.createDecryptionCipher;
break;
}
var md = prfOidToMessageDigest(capture.prfOid);
var dk = forge2.pkcs5.pbkdf2(password, salt, count, dkLen, md);
var iv = capture.encIv;
var cipher = cipherFn(dk);
cipher.start(iv);
return cipher;
};
pki2.pbe.getCipherForPKCS12PBE = function(oid, params, password) {
var capture = {};
var errors = [];
if (!asn1.validate(params, pkcs12PbeParamsValidator, capture, errors)) {
var error = new Error("Cannot read password-based-encryption algorithm parameters. ASN.1 object is not a supported EncryptedPrivateKeyInfo.");
error.errors = errors;
throw error;
}
var salt = forge2.util.createBuffer(capture.salt);
var count = forge2.util.createBuffer(capture.iterations);
count = count.getInt(count.length() << 3);
var dkLen, dIvLen, cipherFn;
switch (oid) {
case pki2.oids["pbeWithSHAAnd3-KeyTripleDES-CBC"]:
dkLen = 24;
dIvLen = 8;
cipherFn = forge2.des.startDecrypting;
break;
case pki2.oids["pbewithSHAAnd40BitRC2-CBC"]:
dkLen = 5;
dIvLen = 8;
cipherFn = function(key3, iv2) {
var cipher = forge2.rc2.createDecryptionCipher(key3, 40);
cipher.start(iv2, null);
return cipher;
};
break;
default:
var error = new Error("Cannot read PKCS #12 PBE data block. Unsupported OID.");
error.oid = oid;
throw error;
}
var md = prfOidToMessageDigest(capture.prfOid);
var key2 = pki2.pbe.generatePkcs12Key(password, salt, 1, count, dkLen, md);
md.start();
var iv = pki2.pbe.generatePkcs12Key(password, salt, 2, count, dIvLen, md);
return cipherFn(key2, iv);
};
pki2.pbe.opensslDeriveBytes = function(password, salt, dkLen, md) {
if (typeof md === "undefined" || md === null) {
if (!("md5" in forge2.md)) {
throw new Error('"md5" hash algorithm unavailable.');
}
md = forge2.md.md5.create();
}
if (salt === null) {
salt = "";
}
var digests = [hash(md, password + salt)];
for (var length2 = 16, i = 1; length2 < dkLen; ++i, length2 += 16) {
digests.push(hash(md, digests[i - 1] + password + salt));
}
return digests.join("").substr(0, dkLen);
};
function hash(md, bytes) {
return md.start().update(bytes).digest().getBytes();
}
function prfOidToMessageDigest(prfOid) {
var prfAlgorithm;
if (!prfOid) {
prfAlgorithm = "hmacWithSHA1";
} else {
prfAlgorithm = pki2.oids[asn1.derToOid(prfOid)];
if (!prfAlgorithm) {
var error = new Error("Unsupported PRF OID.");
error.oid = prfOid;
error.supported = [
"hmacWithSHA1",
"hmacWithSHA224",
"hmacWithSHA256",
"hmacWithSHA384",
"hmacWithSHA512"
];
throw error;
}
}
return prfAlgorithmToMessageDigest(prfAlgorithm);
}
function prfAlgorithmToMessageDigest(prfAlgorithm) {
var factory = forge2.md;
switch (prfAlgorithm) {
case "hmacWithSHA224":
factory = forge2.md.sha512;
case "hmacWithSHA1":
case "hmacWithSHA256":
case "hmacWithSHA384":
case "hmacWithSHA512":
prfAlgorithm = prfAlgorithm.substr(8).toLowerCase();
break;
default:
var error = new Error("Unsupported PRF algorithm.");
error.algorithm = prfAlgorithm;
error.supported = [
"hmacWithSHA1",
"hmacWithSHA224",
"hmacWithSHA256",
"hmacWithSHA384",
"hmacWithSHA512"
];
throw error;
}
if (!factory || !(prfAlgorithm in factory)) {
throw new Error("Unknown hash algorithm: " + prfAlgorithm);
}
return factory[prfAlgorithm].create();
}
function createPbkdf2Params(salt, countBytes, dkLen, prfAlgorithm) {
var params = asn1.create(asn1.Class.UNIVERSAL, asn1.Type.SEQUENCE, true, [
// salt
asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.OCTETSTRING,
false,
salt
),
// iteration count
asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.INTEGER,
false,
countBytes.getBytes()
)
]);
if (prfAlgorithm !== "hmacWithSHA1") {
params.value.push(
// key length
asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.INTEGER,
false,
forge2.util.hexToBytes(dkLen.toString(16))
),
// AlgorithmIdentifier
asn1.create(asn1.Class.UNIVERSAL, asn1.Type.SEQUENCE, true, [
// algorithm
asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.OID,
false,
asn1.oidToDer(pki2.oids[prfAlgorithm]).getBytes()
),
// parameters (null)
asn1.create(asn1.Class.UNIVERSAL, asn1.Type.NULL, false, "")
])
);
}
return params;
}
}
});
// node_modules/node-forge/lib/pkcs7asn1.js
var require_pkcs7asn1 = __commonJS({
"node_modules/node-forge/lib/pkcs7asn1.js"(exports2, module2) {
"use strict";
var forge2 = require_forge();
require_asn1();
require_util();
var asn1 = forge2.asn1;
var p7v = module2.exports = forge2.pkcs7asn1 = forge2.pkcs7asn1 || {};
forge2.pkcs7 = forge2.pkcs7 || {};
forge2.pkcs7.asn1 = p7v;
var contentInfoValidator = {
name: "ContentInfo",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.SEQUENCE,
constructed: true,
value: [{
name: "ContentInfo.ContentType",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.OID,
constructed: false,
capture: "contentType"
}, {
name: "ContentInfo.content",
tagClass: asn1.Class.CONTEXT_SPECIFIC,
type: 0,
constructed: true,
optional: true,
captureAsn1: "content"
}]
};
p7v.contentInfoValidator = contentInfoValidator;
var encryptedContentInfoValidator = {
name: "EncryptedContentInfo",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.SEQUENCE,
constructed: true,
value: [{
name: "EncryptedContentInfo.contentType",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.OID,
constructed: false,
capture: "contentType"
}, {
name: "EncryptedContentInfo.contentEncryptionAlgorithm",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.SEQUENCE,
constructed: true,
value: [{
name: "EncryptedContentInfo.contentEncryptionAlgorithm.algorithm",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.OID,
constructed: false,
capture: "encAlgorithm"
}, {
name: "EncryptedContentInfo.contentEncryptionAlgorithm.parameter",
tagClass: asn1.Class.UNIVERSAL,
captureAsn1: "encParameter"
}]
}, {
name: "EncryptedContentInfo.encryptedContent",
tagClass: asn1.Class.CONTEXT_SPECIFIC,
type: 0,
/* The PKCS#7 structure output by OpenSSL somewhat differs from what
* other implementations do generate.
*
* OpenSSL generates a structure like this:
* SEQUENCE {
* ...
* [0]
* 26 DA 67 D2 17 9C 45 3C B1 2A A8 59 2F 29 33 38
* C3 C3 DF 86 71 74 7A 19 9F 40 D0 29 BE 85 90 45
* ...
* }
*
* Whereas other implementations (and this PKCS#7 module) generate:
* SEQUENCE {
* ...
* [0] {
* OCTET STRING
* 26 DA 67 D2 17 9C 45 3C B1 2A A8 59 2F 29 33 38
* C3 C3 DF 86 71 74 7A 19 9F 40 D0 29 BE 85 90 45
* ...
* }
* }
*
* In order to support both, we just capture the context specific
* field here. The OCTET STRING bit is removed below.
*/
capture: "encryptedContent",
captureAsn1: "encryptedContentAsn1"
}]
};
p7v.envelopedDataValidator = {
name: "EnvelopedData",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.SEQUENCE,
constructed: true,
value: [{
name: "EnvelopedData.Version",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.INTEGER,
constructed: false,
capture: "version"
}, {
name: "EnvelopedData.RecipientInfos",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.SET,
constructed: true,
captureAsn1: "recipientInfos"
}].concat(encryptedContentInfoValidator)
};
p7v.encryptedDataValidator = {
name: "EncryptedData",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.SEQUENCE,
constructed: true,
value: [{
name: "EncryptedData.Version",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.INTEGER,
constructed: false,
capture: "version"
}].concat(encryptedContentInfoValidator)
};
var signerValidator = {
name: "SignerInfo",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.SEQUENCE,
constructed: true,
value: [{
name: "SignerInfo.version",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.INTEGER,
constructed: false
}, {
name: "SignerInfo.issuerAndSerialNumber",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.SEQUENCE,
constructed: true,
value: [{
name: "SignerInfo.issuerAndSerialNumber.issuer",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.SEQUENCE,
constructed: true,
captureAsn1: "issuer"
}, {
name: "SignerInfo.issuerAndSerialNumber.serialNumber",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.INTEGER,
constructed: false,
capture: "serial"
}]
}, {
name: "SignerInfo.digestAlgorithm",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.SEQUENCE,
constructed: true,
value: [{
name: "SignerInfo.digestAlgorithm.algorithm",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.OID,
constructed: false,
capture: "digestAlgorithm"
}, {
name: "SignerInfo.digestAlgorithm.parameter",
tagClass: asn1.Class.UNIVERSAL,
constructed: false,
captureAsn1: "digestParameter",
optional: true
}]
}, {
name: "SignerInfo.authenticatedAttributes",
tagClass: asn1.Class.CONTEXT_SPECIFIC,
type: 0,
constructed: true,
optional: true,
capture: "authenticatedAttributes"
}, {
name: "SignerInfo.digestEncryptionAlgorithm",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.SEQUENCE,
constructed: true,
capture: "signatureAlgorithm"
}, {
name: "SignerInfo.encryptedDigest",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.OCTETSTRING,
constructed: false,
capture: "signature"
}, {
name: "SignerInfo.unauthenticatedAttributes",
tagClass: asn1.Class.CONTEXT_SPECIFIC,
type: 1,
constructed: true,
optional: true,
capture: "unauthenticatedAttributes"
}]
};
p7v.signedDataValidator = {
name: "SignedData",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.SEQUENCE,
constructed: true,
value: [
{
name: "SignedData.Version",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.INTEGER,
constructed: false,
capture: "version"
},
{
name: "SignedData.DigestAlgorithms",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.SET,
constructed: true,
captureAsn1: "digestAlgorithms"
},
contentInfoValidator,
{
name: "SignedData.Certificates",
tagClass: asn1.Class.CONTEXT_SPECIFIC,
type: 0,
optional: true,
captureAsn1: "certificates"
},
{
name: "SignedData.CertificateRevocationLists",
tagClass: asn1.Class.CONTEXT_SPECIFIC,
type: 1,
optional: true,
captureAsn1: "crls"
},
{
name: "SignedData.SignerInfos",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.SET,
capture: "signerInfos",
optional: true,
value: [signerValidator]
}
]
};
p7v.recipientInfoValidator = {
name: "RecipientInfo",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.SEQUENCE,
constructed: true,
value: [{
name: "RecipientInfo.version",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.INTEGER,
constructed: false,
capture: "version"
}, {
name: "RecipientInfo.issuerAndSerial",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.SEQUENCE,
constructed: true,
value: [{
name: "RecipientInfo.issuerAndSerial.issuer",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.SEQUENCE,
constructed: true,
captureAsn1: "issuer"
}, {
name: "RecipientInfo.issuerAndSerial.serialNumber",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.INTEGER,
constructed: false,
capture: "serial"
}]
}, {
name: "RecipientInfo.keyEncryptionAlgorithm",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.SEQUENCE,
constructed: true,
value: [{
name: "RecipientInfo.keyEncryptionAlgorithm.algorithm",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.OID,
constructed: false,
capture: "encAlgorithm"
}, {
name: "RecipientInfo.keyEncryptionAlgorithm.parameter",
tagClass: asn1.Class.UNIVERSAL,
constructed: false,
captureAsn1: "encParameter",
optional: true
}]
}, {
name: "RecipientInfo.encryptedKey",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.OCTETSTRING,
constructed: false,
capture: "encKey"
}]
};
}
});
// node_modules/node-forge/lib/mgf1.js
var require_mgf1 = __commonJS({
"node_modules/node-forge/lib/mgf1.js"(exports2, module2) {
"use strict";
var forge2 = require_forge();
require_util();
forge2.mgf = forge2.mgf || {};
var mgf1 = module2.exports = forge2.mgf.mgf1 = forge2.mgf1 = forge2.mgf1 || {};
mgf1.create = function(md) {
var mgf = {
/**
* Generate mask of specified length.
*
* @param {String} seed The seed for mask generation.
* @param maskLen Number of bytes to generate.
* @return {String} The generated mask.
*/
generate: function(seed, maskLen) {
var t = new forge2.util.ByteBuffer();
var len = Math.ceil(maskLen / md.digestLength);
for (var i = 0; i < len; i++) {
var c = new forge2.util.ByteBuffer();
c.putInt32(i);
md.start();
md.update(seed + c.getBytes());
t.putBuffer(md.digest());
}
t.truncate(t.length() - maskLen);
return t.getBytes();
}
};
return mgf;
};
}
});
// node_modules/node-forge/lib/mgf.js
var require_mgf = __commonJS({
"node_modules/node-forge/lib/mgf.js"(exports2, module2) {
"use strict";
var forge2 = require_forge();
require_mgf1();
module2.exports = forge2.mgf = forge2.mgf || {};
forge2.mgf.mgf1 = forge2.mgf1;
}
});
// node_modules/node-forge/lib/pss.js
var require_pss = __commonJS({
"node_modules/node-forge/lib/pss.js"(exports2, module2) {
"use strict";
var forge2 = require_forge();
require_random();
require_util();
var pss = module2.exports = forge2.pss = forge2.pss || {};
pss.create = function(options) {
if (arguments.length === 3) {
options = {
md: arguments[0],
mgf: arguments[1],
saltLength: arguments[2]
};
}
var hash = options.md;
var mgf = options.mgf;
var hLen = hash.digestLength;
var salt_ = options.salt || null;
if (typeof salt_ === "string") {
salt_ = forge2.util.createBuffer(salt_);
}
var sLen;
if ("saltLength" in options) {
sLen = options.saltLength;
} else if (salt_ !== null) {
sLen = salt_.length();
} else {
throw new Error("Salt length not specified or specific salt not given.");
}
if (salt_ !== null && salt_.length() !== sLen) {
throw new Error("Given salt length does not match length of given salt.");
}
var prng = options.prng || forge2.random;
var pssobj = {};
pssobj.encode = function(md, modBits) {
var i;
var emBits = modBits - 1;
var emLen = Math.ceil(emBits / 8);
var mHash = md.digest().getBytes();
if (emLen < hLen + sLen + 2) {
throw new Error("Message is too long to encrypt.");
}
var salt;
if (salt_ === null) {
salt = prng.getBytesSync(sLen);
} else {
salt = salt_.bytes();
}
var m_ = new forge2.util.ByteBuffer();
m_.fillWithByte(0, 8);
m_.putBytes(mHash);
m_.putBytes(salt);
hash.start();
hash.update(m_.getBytes());
var h = hash.digest().getBytes();
var ps = new forge2.util.ByteBuffer();
ps.fillWithByte(0, emLen - sLen - hLen - 2);
ps.putByte(1);
ps.putBytes(salt);
var db = ps.getBytes();
var maskLen = emLen - hLen - 1;
var dbMask = mgf.generate(h, maskLen);
var maskedDB = "";
for (i = 0; i < maskLen; i++) {
maskedDB += String.fromCharCode(db.charCodeAt(i) ^ dbMask.charCodeAt(i));
}
var mask2 = 65280 >> 8 * emLen - emBits & 255;
maskedDB = String.fromCharCode(maskedDB.charCodeAt(0) & ~mask2) + maskedDB.substr(1);
return maskedDB + h + String.fromCharCode(188);
};
pssobj.verify = function(mHash, em, modBits) {
var i;
var emBits = modBits - 1;
var emLen = Math.ceil(emBits / 8);
em = em.substr(-emLen);
if (emLen < hLen + sLen + 2) {
throw new Error("Inconsistent parameters to PSS signature verification.");
}
if (em.charCodeAt(emLen - 1) !== 188) {
throw new Error("Encoded message does not end in 0xBC.");
}
var maskLen = emLen - hLen - 1;
var maskedDB = em.substr(0, maskLen);
var h = em.substr(maskLen, hLen);
var mask2 = 65280 >> 8 * emLen - emBits & 255;
if ((maskedDB.charCodeAt(0) & mask2) !== 0) {
throw new Error("Bits beyond keysize not zero as expected.");
}
var dbMask = mgf.generate(h, maskLen);
var db = "";
for (i = 0; i < maskLen; i++) {
db += String.fromCharCode(maskedDB.charCodeAt(i) ^ dbMask.charCodeAt(i));
}
db = String.fromCharCode(db.charCodeAt(0) & ~mask2) + db.substr(1);
var checkLen = emLen - hLen - sLen - 2;
for (i = 0; i < checkLen; i++) {
if (db.charCodeAt(i) !== 0) {
throw new Error("Leftmost octets not zero as expected");
}
}
if (db.charCodeAt(checkLen) !== 1) {
throw new Error("Inconsistent PSS signature, 0x01 marker not found");
}
var salt = db.substr(-sLen);
var m_ = new forge2.util.ByteBuffer();
m_.fillWithByte(0, 8);
m_.putBytes(mHash);
m_.putBytes(salt);
hash.start();
hash.update(m_.getBytes());
var h_ = hash.digest().getBytes();
return h === h_;
};
return pssobj;
};
}
});
// node_modules/node-forge/lib/x509.js
var require_x509 = __commonJS({
"node_modules/node-forge/lib/x509.js"(exports2, module2) {
"use strict";
var forge2 = require_forge();
require_aes();
require_asn1();
require_des();
require_md();
require_mgf();
require_oids();
require_pem();
require_pss();
require_rsa();
require_util();
var asn1 = forge2.asn1;
var pki2 = module2.exports = forge2.pki = forge2.pki || {};
var oids = pki2.oids;
var _shortNames = {};
_shortNames["CN"] = oids["commonName"];
_shortNames["commonName"] = "CN";
_shortNames["C"] = oids["countryName"];
_shortNames["countryName"] = "C";
_shortNames["L"] = oids["localityName"];
_shortNames["localityName"] = "L";
_shortNames["ST"] = oids["stateOrProvinceName"];
_shortNames["stateOrProvinceName"] = "ST";
_shortNames["O"] = oids["organizationName"];
_shortNames["organizationName"] = "O";
_shortNames["OU"] = oids["organizationalUnitName"];
_shortNames["organizationalUnitName"] = "OU";
_shortNames["E"] = oids["emailAddress"];
_shortNames["emailAddress"] = "E";
var publicKeyValidator = forge2.pki.rsa.publicKeyValidator;
var x509CertificateValidator = {
name: "Certificate",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.SEQUENCE,
constructed: true,
value: [{
name: "Certificate.TBSCertificate",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.SEQUENCE,
constructed: true,
captureAsn1: "tbsCertificate",
value: [
{
name: "Certificate.TBSCertificate.version",
tagClass: asn1.Class.CONTEXT_SPECIFIC,
type: 0,
constructed: true,
optional: true,
value: [{
name: "Certificate.TBSCertificate.version.integer",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.INTEGER,
constructed: false,
capture: "certVersion"
}]
},
{
name: "Certificate.TBSCertificate.serialNumber",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.INTEGER,
constructed: false,
capture: "certSerialNumber"
},
{
name: "Certificate.TBSCertificate.signature",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.SEQUENCE,
constructed: true,
value: [{
name: "Certificate.TBSCertificate.signature.algorithm",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.OID,
constructed: false,
capture: "certinfoSignatureOid"
}, {
name: "Certificate.TBSCertificate.signature.parameters",
tagClass: asn1.Class.UNIVERSAL,
optional: true,
captureAsn1: "certinfoSignatureParams"
}]
},
{
name: "Certificate.TBSCertificate.issuer",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.SEQUENCE,
constructed: true,
captureAsn1: "certIssuer"
},
{
name: "Certificate.TBSCertificate.validity",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.SEQUENCE,
constructed: true,
// Note: UTC and generalized times may both appear so the capture
// names are based on their detected order, the names used below
// are only for the common case, which validity time really means
// "notBefore" and which means "notAfter" will be determined by order
value: [{
// notBefore (Time) (UTC time case)
name: "Certificate.TBSCertificate.validity.notBefore (utc)",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.UTCTIME,
constructed: false,
optional: true,
capture: "certValidity1UTCTime"
}, {
// notBefore (Time) (generalized time case)
name: "Certificate.TBSCertificate.validity.notBefore (generalized)",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.GENERALIZEDTIME,
constructed: false,
optional: true,
capture: "certValidity2GeneralizedTime"
}, {
// notAfter (Time) (only UTC time is supported)
name: "Certificate.TBSCertificate.validity.notAfter (utc)",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.UTCTIME,
constructed: false,
optional: true,
capture: "certValidity3UTCTime"
}, {
// notAfter (Time) (only UTC time is supported)
name: "Certificate.TBSCertificate.validity.notAfter (generalized)",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.GENERALIZEDTIME,
constructed: false,
optional: true,
capture: "certValidity4GeneralizedTime"
}]
},
{
// Name (subject) (RDNSequence)
name: "Certificate.TBSCertificate.subject",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.SEQUENCE,
constructed: true,
captureAsn1: "certSubject"
},
// SubjectPublicKeyInfo
publicKeyValidator,
{
// issuerUniqueID (optional)
name: "Certificate.TBSCertificate.issuerUniqueID",
tagClass: asn1.Class.CONTEXT_SPECIFIC,
type: 1,
constructed: true,
optional: true,
value: [{
name: "Certificate.TBSCertificate.issuerUniqueID.id",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.BITSTRING,
constructed: false,
// TODO: support arbitrary bit length ids
captureBitStringValue: "certIssuerUniqueId"
}]
},
{
// subjectUniqueID (optional)
name: "Certificate.TBSCertificate.subjectUniqueID",
tagClass: asn1.Class.CONTEXT_SPECIFIC,
type: 2,
constructed: true,
optional: true,
value: [{
name: "Certificate.TBSCertificate.subjectUniqueID.id",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.BITSTRING,
constructed: false,
// TODO: support arbitrary bit length ids
captureBitStringValue: "certSubjectUniqueId"
}]
},
{
// Extensions (optional)
name: "Certificate.TBSCertificate.extensions",
tagClass: asn1.Class.CONTEXT_SPECIFIC,
type: 3,
constructed: true,
captureAsn1: "certExtensions",
optional: true
}
]
}, {
// AlgorithmIdentifier (signature algorithm)
name: "Certificate.signatureAlgorithm",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.SEQUENCE,
constructed: true,
value: [{
// algorithm
name: "Certificate.signatureAlgorithm.algorithm",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.OID,
constructed: false,
capture: "certSignatureOid"
}, {
name: "Certificate.TBSCertificate.signature.parameters",
tagClass: asn1.Class.UNIVERSAL,
optional: true,
captureAsn1: "certSignatureParams"
}]
}, {
// SignatureValue
name: "Certificate.signatureValue",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.BITSTRING,
constructed: false,
captureBitStringValue: "certSignature"
}]
};
var rsassaPssParameterValidator = {
name: "rsapss",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.SEQUENCE,
constructed: true,
value: [{
name: "rsapss.hashAlgorithm",
tagClass: asn1.Class.CONTEXT_SPECIFIC,
type: 0,
constructed: true,
value: [{
name: "rsapss.hashAlgorithm.AlgorithmIdentifier",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Class.SEQUENCE,
constructed: true,
optional: true,
value: [{
name: "rsapss.hashAlgorithm.AlgorithmIdentifier.algorithm",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.OID,
constructed: false,
capture: "hashOid"
/* parameter block omitted, for SHA1 NULL anyhow. */
}]
}]
}, {
name: "rsapss.maskGenAlgorithm",
tagClass: asn1.Class.CONTEXT_SPECIFIC,
type: 1,
constructed: true,
value: [{
name: "rsapss.maskGenAlgorithm.AlgorithmIdentifier",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Class.SEQUENCE,
constructed: true,
optional: true,
value: [{
name: "rsapss.maskGenAlgorithm.AlgorithmIdentifier.algorithm",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.OID,
constructed: false,
capture: "maskGenOid"
}, {
name: "rsapss.maskGenAlgorithm.AlgorithmIdentifier.params",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.SEQUENCE,
constructed: true,
value: [{
name: "rsapss.maskGenAlgorithm.AlgorithmIdentifier.params.algorithm",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.OID,
constructed: false,
capture: "maskGenHashOid"
/* parameter block omitted, for SHA1 NULL anyhow. */
}]
}]
}]
}, {
name: "rsapss.saltLength",
tagClass: asn1.Class.CONTEXT_SPECIFIC,
type: 2,
optional: true,
value: [{
name: "rsapss.saltLength.saltLength",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Class.INTEGER,
constructed: false,
capture: "saltLength"
}]
}, {
name: "rsapss.trailerField",
tagClass: asn1.Class.CONTEXT_SPECIFIC,
type: 3,
optional: true,
value: [{
name: "rsapss.trailer.trailer",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Class.INTEGER,
constructed: false,
capture: "trailer"
}]
}]
};
var certificationRequestInfoValidator = {
name: "CertificationRequestInfo",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.SEQUENCE,
constructed: true,
captureAsn1: "certificationRequestInfo",
value: [
{
name: "CertificationRequestInfo.integer",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.INTEGER,
constructed: false,
capture: "certificationRequestInfoVersion"
},
{
// Name (subject) (RDNSequence)
name: "CertificationRequestInfo.subject",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.SEQUENCE,
constructed: true,
captureAsn1: "certificationRequestInfoSubject"
},
// SubjectPublicKeyInfo
publicKeyValidator,
{
name: "CertificationRequestInfo.attributes",
tagClass: asn1.Class.CONTEXT_SPECIFIC,
type: 0,
constructed: true,
optional: true,
capture: "certificationRequestInfoAttributes",
value: [{
name: "CertificationRequestInfo.attributes",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.SEQUENCE,
constructed: true,
value: [{
name: "CertificationRequestInfo.attributes.type",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.OID,
constructed: false
}, {
name: "CertificationRequestInfo.attributes.value",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.SET,
constructed: true
}]
}]
}
]
};
var certificationRequestValidator = {
name: "CertificationRequest",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.SEQUENCE,
constructed: true,
captureAsn1: "csr",
value: [
certificationRequestInfoValidator,
{
// AlgorithmIdentifier (signature algorithm)
name: "CertificationRequest.signatureAlgorithm",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.SEQUENCE,
constructed: true,
value: [{
// algorithm
name: "CertificationRequest.signatureAlgorithm.algorithm",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.OID,
constructed: false,
capture: "csrSignatureOid"
}, {
name: "CertificationRequest.signatureAlgorithm.parameters",
tagClass: asn1.Class.UNIVERSAL,
optional: true,
captureAsn1: "csrSignatureParams"
}]
},
{
// signature
name: "CertificationRequest.signature",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.BITSTRING,
constructed: false,
captureBitStringValue: "csrSignature"
}
]
};
pki2.RDNAttributesAsArray = function(rdn, md) {
var rval = [];
var set, attr, obj;
for (var si = 0; si < rdn.value.length; ++si) {
set = rdn.value[si];
for (var i = 0; i < set.value.length; ++i) {
obj = {};
attr = set.value[i];
obj.type = asn1.derToOid(attr.value[0].value);
obj.value = attr.value[1].value;
obj.valueTagClass = attr.value[1].type;
if (obj.type in oids) {
obj.name = oids[obj.type];
if (obj.name in _shortNames) {
obj.shortName = _shortNames[obj.name];
}
}
if (md) {
md.update(obj.type);
md.update(obj.value);
}
rval.push(obj);
}
}
return rval;
};
pki2.CRIAttributesAsArray = function(attributes) {
var rval = [];
for (var si = 0; si < attributes.length; ++si) {
var seq = attributes[si];
var type = asn1.derToOid(seq.value[0].value);
var values = seq.value[1].value;
for (var vi = 0; vi < values.length; ++vi) {
var obj = {};
obj.type = type;
obj.value = values[vi].value;
obj.valueTagClass = values[vi].type;
if (obj.type in oids) {
obj.name = oids[obj.type];
if (obj.name in _shortNames) {
obj.shortName = _shortNames[obj.name];
}
}
if (obj.type === oids.extensionRequest) {
obj.extensions = [];
for (var ei = 0; ei < obj.value.length; ++ei) {
obj.extensions.push(pki2.certificateExtensionFromAsn1(obj.value[ei]));
}
}
rval.push(obj);
}
}
return rval;
};
function _getAttribute(obj, options) {
if (typeof options === "string") {
options = { shortName: options };
}
var rval = null;
var attr;
for (var i = 0; rval === null && i < obj.attributes.length; ++i) {
attr = obj.attributes[i];
if (options.type && options.type === attr.type) {
rval = attr;
} else if (options.name && options.name === attr.name) {
rval = attr;
} else if (options.shortName && options.shortName === attr.shortName) {
rval = attr;
}
}
return rval;
}
var _readSignatureParameters = function(oid, obj, fillDefaults) {
var params = {};
if (oid !== oids["RSASSA-PSS"]) {
return params;
}
if (fillDefaults) {
params = {
hash: {
algorithmOid: oids["sha1"]
},
mgf: {
algorithmOid: oids["mgf1"],
hash: {
algorithmOid: oids["sha1"]
}
},
saltLength: 20
};
}
var capture = {};
var errors = [];
if (!asn1.validate(obj, rsassaPssParameterValidator, capture, errors)) {
var error = new Error("Cannot read RSASSA-PSS parameter block.");
error.errors = errors;
throw error;
}
if (capture.hashOid !== void 0) {
params.hash = params.hash || {};
params.hash.algorithmOid = asn1.derToOid(capture.hashOid);
}
if (capture.maskGenOid !== void 0) {
params.mgf = params.mgf || {};
params.mgf.algorithmOid = asn1.derToOid(capture.maskGenOid);
params.mgf.hash = params.mgf.hash || {};
params.mgf.hash.algorithmOid = asn1.derToOid(capture.maskGenHashOid);
}
if (capture.saltLength !== void 0) {
params.saltLength = capture.saltLength.charCodeAt(0);
}
return params;
};
var _createSignatureDigest = function(options) {
switch (oids[options.signatureOid]) {
case "sha1WithRSAEncryption":
case "sha1WithRSASignature":
return forge2.md.sha1.create();
case "md5WithRSAEncryption":
return forge2.md.md5.create();
case "sha256WithRSAEncryption":
return forge2.md.sha256.create();
case "sha384WithRSAEncryption":
return forge2.md.sha384.create();
case "sha512WithRSAEncryption":
return forge2.md.sha512.create();
case "RSASSA-PSS":
return forge2.md.sha256.create();
default:
var error = new Error(
"Could not compute " + options.type + " digest. Unknown signature OID."
);
error.signatureOid = options.signatureOid;
throw error;
}
};
var _verifySignature = function(options) {
var cert = options.certificate;
var scheme;
switch (cert.signatureOid) {
case oids.sha1WithRSAEncryption:
case oids.sha1WithRSASignature:
break;
case oids["RSASSA-PSS"]:
var hash, mgf;
hash = oids[cert.signatureParameters.mgf.hash.algorithmOid];
if (hash === void 0 || forge2.md[hash] === void 0) {
var error = new Error("Unsupported MGF hash function.");
error.oid = cert.signatureParameters.mgf.hash.algorithmOid;
error.name = hash;
throw error;
}
mgf = oids[cert.signatureParameters.mgf.algorithmOid];
if (mgf === void 0 || forge2.mgf[mgf] === void 0) {
var error = new Error("Unsupported MGF function.");
error.oid = cert.signatureParameters.mgf.algorithmOid;
error.name = mgf;
throw error;
}
mgf = forge2.mgf[mgf].create(forge2.md[hash].create());
hash = oids[cert.signatureParameters.hash.algorithmOid];
if (hash === void 0 || forge2.md[hash] === void 0) {
var error = new Error("Unsupported RSASSA-PSS hash function.");
error.oid = cert.signatureParameters.hash.algorithmOid;
error.name = hash;
throw error;
}
scheme = forge2.pss.create(
forge2.md[hash].create(),
mgf,
cert.signatureParameters.saltLength
);
break;
}
return cert.publicKey.verify(
options.md.digest().getBytes(),
options.signature,
scheme
);
};
pki2.certificateFromPem = function(pem, computeHash, strict) {
var msg = forge2.pem.decode(pem)[0];
if (msg.type !== "CERTIFICATE" && msg.type !== "X509 CERTIFICATE" && msg.type !== "TRUSTED CERTIFICATE") {
var error = new Error(
'Could not convert certificate from PEM; PEM header type is not "CERTIFICATE", "X509 CERTIFICATE", or "TRUSTED CERTIFICATE".'
);
error.headerType = msg.type;
throw error;
}
if (msg.procType && msg.procType.type === "ENCRYPTED") {
throw new Error(
"Could not convert certificate from PEM; PEM is encrypted."
);
}
var obj = asn1.fromDer(msg.body, strict);
return pki2.certificateFromAsn1(obj, computeHash);
};
pki2.certificateToPem = function(cert, maxline) {
var msg = {
type: "CERTIFICATE",
body: asn1.toDer(pki2.certificateToAsn1(cert)).getBytes()
};
return forge2.pem.encode(msg, { maxline });
};
pki2.publicKeyFromPem = function(pem) {
var msg = forge2.pem.decode(pem)[0];
if (msg.type !== "PUBLIC KEY" && msg.type !== "RSA PUBLIC KEY") {
var error = new Error('Could not convert public key from PEM; PEM header type is not "PUBLIC KEY" or "RSA PUBLIC KEY".');
error.headerType = msg.type;
throw error;
}
if (msg.procType && msg.procType.type === "ENCRYPTED") {
throw new Error("Could not convert public key from PEM; PEM is encrypted.");
}
var obj = asn1.fromDer(msg.body);
return pki2.publicKeyFromAsn1(obj);
};
pki2.publicKeyToPem = function(key2, maxline) {
var msg = {
type: "PUBLIC KEY",
body: asn1.toDer(pki2.publicKeyToAsn1(key2)).getBytes()
};
return forge2.pem.encode(msg, { maxline });
};
pki2.publicKeyToRSAPublicKeyPem = function(key2, maxline) {
var msg = {
type: "RSA PUBLIC KEY",
body: asn1.toDer(pki2.publicKeyToRSAPublicKey(key2)).getBytes()
};
return forge2.pem.encode(msg, { maxline });
};
pki2.getPublicKeyFingerprint = function(key2, options) {
options = options || {};
var md = options.md || forge2.md.sha1.create();
var type = options.type || "RSAPublicKey";
var bytes;
switch (type) {
case "RSAPublicKey":
bytes = asn1.toDer(pki2.publicKeyToRSAPublicKey(key2)).getBytes();
break;
case "SubjectPublicKeyInfo":
bytes = asn1.toDer(pki2.publicKeyToAsn1(key2)).getBytes();
break;
default:
throw new Error('Unknown fingerprint type "' + options.type + '".');
}
md.start();
md.update(bytes);
var digest = md.digest();
if (options.encoding === "hex") {
var hex = digest.toHex();
if (options.delimiter) {
return hex.match(/.{2}/g).join(options.delimiter);
}
return hex;
} else if (options.encoding === "binary") {
return digest.getBytes();
} else if (options.encoding) {
throw new Error('Unknown encoding "' + options.encoding + '".');
}
return digest;
};
pki2.certificationRequestFromPem = function(pem, computeHash, strict) {
var msg = forge2.pem.decode(pem)[0];
if (msg.type !== "CERTIFICATE REQUEST") {
var error = new Error('Could not convert certification request from PEM; PEM header type is not "CERTIFICATE REQUEST".');
error.headerType = msg.type;
throw error;
}
if (msg.procType && msg.procType.type === "ENCRYPTED") {
throw new Error("Could not convert certification request from PEM; PEM is encrypted.");
}
var obj = asn1.fromDer(msg.body, strict);
return pki2.certificationRequestFromAsn1(obj, computeHash);
};
pki2.certificationRequestToPem = function(csr, maxline) {
var msg = {
type: "CERTIFICATE REQUEST",
body: asn1.toDer(pki2.certificationRequestToAsn1(csr)).getBytes()
};
return forge2.pem.encode(msg, { maxline });
};
pki2.createCertificate = function() {
var cert = {};
cert.version = 2;
cert.serialNumber = "00";
cert.signatureOid = null;
cert.signature = null;
cert.siginfo = {};
cert.siginfo.algorithmOid = null;
cert.validity = {};
cert.validity.notBefore = /* @__PURE__ */ new Date();
cert.validity.notAfter = /* @__PURE__ */ new Date();
cert.issuer = {};
cert.issuer.getField = function(sn) {
return _getAttribute(cert.issuer, sn);
};
cert.issuer.addField = function(attr) {
_fillMissingFields([attr]);
cert.issuer.attributes.push(attr);
};
cert.issuer.attributes = [];
cert.issuer.hash = null;
cert.subject = {};
cert.subject.getField = function(sn) {
return _getAttribute(cert.subject, sn);
};
cert.subject.addField = function(attr) {
_fillMissingFields([attr]);
cert.subject.attributes.push(attr);
};
cert.subject.attributes = [];
cert.subject.hash = null;
cert.extensions = [];
cert.publicKey = null;
cert.md = null;
cert.setSubject = function(attrs, uniqueId) {
_fillMissingFields(attrs);
cert.subject.attributes = attrs;
delete cert.subject.uniqueId;
if (uniqueId) {
cert.subject.uniqueId = uniqueId;
}
cert.subject.hash = null;
};
cert.setIssuer = function(attrs, uniqueId) {
_fillMissingFields(attrs);
cert.issuer.attributes = attrs;
delete cert.issuer.uniqueId;
if (uniqueId) {
cert.issuer.uniqueId = uniqueId;
}
cert.issuer.hash = null;
};
cert.setExtensions = function(exts) {
for (var i = 0; i < exts.length; ++i) {
_fillMissingExtensionFields(exts[i], { cert });
}
cert.extensions = exts;
};
cert.getExtension = function(options) {
if (typeof options === "string") {
options = { name: options };
}
var rval = null;
var ext;
for (var i = 0; rval === null && i < cert.extensions.length; ++i) {
ext = cert.extensions[i];
if (options.id && ext.id === options.id) {
rval = ext;
} else if (options.name && ext.name === options.name) {
rval = ext;
}
}
return rval;
};
cert.sign = function(key2, md) {
cert.md = md || forge2.md.sha1.create();
var algorithmOid = oids[cert.md.algorithm + "WithRSAEncryption"];
if (!algorithmOid) {
var error = new Error("Could not compute certificate digest. Unknown message digest algorithm OID.");
error.algorithm = cert.md.algorithm;
throw error;
}
cert.signatureOid = cert.siginfo.algorithmOid = algorithmOid;
cert.tbsCertificate = pki2.getTBSCertificate(cert);
var bytes = asn1.toDer(cert.tbsCertificate);
cert.md.update(bytes.getBytes());
cert.signature = key2.sign(cert.md);
};
cert.verify = function(child) {
var rval = false;
if (!cert.issued(child)) {
var issuer = child.issuer;
var subject = cert.subject;
var error = new Error(
"The parent certificate did not issue the given child certificate; the child certificate's issuer does not match the parent's subject."
);
error.expectedIssuer = subject.attributes;
error.actualIssuer = issuer.attributes;
throw error;
}
var md = child.md;
if (md === null) {
md = _createSignatureDigest({
signatureOid: child.signatureOid,
type: "certificate"
});
var tbsCertificate = child.tbsCertificate || pki2.getTBSCertificate(child);
var bytes = asn1.toDer(tbsCertificate);
md.update(bytes.getBytes());
}
if (md !== null) {
rval = _verifySignature({
certificate: cert,
md,
signature: child.signature
});
}
return rval;
};
cert.isIssuer = function(parent2) {
var rval = false;
var i = cert.issuer;
var s = parent2.subject;
if (i.hash && s.hash) {
rval = i.hash === s.hash;
} else if (i.attributes.length === s.attributes.length) {
rval = true;
var iattr, sattr;
for (var n = 0; rval && n < i.attributes.length; ++n) {
iattr = i.attributes[n];
sattr = s.attributes[n];
if (iattr.type !== sattr.type || iattr.value !== sattr.value) {
rval = false;
}
}
}
return rval;
};
cert.issued = function(child) {
return child.isIssuer(cert);
};
cert.generateSubjectKeyIdentifier = function() {
return pki2.getPublicKeyFingerprint(cert.publicKey, { type: "RSAPublicKey" });
};
cert.verifySubjectKeyIdentifier = function() {
var oid = oids["subjectKeyIdentifier"];
for (var i = 0; i < cert.extensions.length; ++i) {
var ext = cert.extensions[i];
if (ext.id === oid) {
var ski = cert.generateSubjectKeyIdentifier().getBytes();
return forge2.util.hexToBytes(ext.subjectKeyIdentifier) === ski;
}
}
return false;
};
return cert;
};
pki2.certificateFromAsn1 = function(obj, computeHash) {
var capture = {};
var errors = [];
if (!asn1.validate(obj, x509CertificateValidator, capture, errors)) {
var error = new Error("Cannot read X.509 certificate. ASN.1 object is not an X509v3 Certificate.");
error.errors = errors;
throw error;
}
var oid = asn1.derToOid(capture.publicKeyOid);
if (oid !== pki2.oids.rsaEncryption) {
throw new Error("Cannot read public key. OID is not RSA.");
}
var cert = pki2.createCertificate();
cert.version = capture.certVersion ? capture.certVersion.charCodeAt(0) : 0;
var serial = forge2.util.createBuffer(capture.certSerialNumber);
cert.serialNumber = serial.toHex();
cert.signatureOid = forge2.asn1.derToOid(capture.certSignatureOid);
cert.signatureParameters = _readSignatureParameters(
cert.signatureOid,
capture.certSignatureParams,
true
);
cert.siginfo.algorithmOid = forge2.asn1.derToOid(capture.certinfoSignatureOid);
cert.siginfo.parameters = _readSignatureParameters(
cert.siginfo.algorithmOid,
capture.certinfoSignatureParams,
false
);
cert.signature = capture.certSignature;
var validity = [];
if (capture.certValidity1UTCTime !== void 0) {
validity.push(asn1.utcTimeToDate(capture.certValidity1UTCTime));
}
if (capture.certValidity2GeneralizedTime !== void 0) {
validity.push(asn1.generalizedTimeToDate(
capture.certValidity2GeneralizedTime
));
}
if (capture.certValidity3UTCTime !== void 0) {
validity.push(asn1.utcTimeToDate(capture.certValidity3UTCTime));
}
if (capture.certValidity4GeneralizedTime !== void 0) {
validity.push(asn1.generalizedTimeToDate(
capture.certValidity4GeneralizedTime
));
}
if (validity.length > 2) {
throw new Error("Cannot read notBefore/notAfter validity times; more than two times were provided in the certificate.");
}
if (validity.length < 2) {
throw new Error("Cannot read notBefore/notAfter validity times; they were not provided as either UTCTime or GeneralizedTime.");
}
cert.validity.notBefore = validity[0];
cert.validity.notAfter = validity[1];
cert.tbsCertificate = capture.tbsCertificate;
if (computeHash) {
cert.md = _createSignatureDigest({
signatureOid: cert.signatureOid,
type: "certificate"
});
var bytes = asn1.toDer(cert.tbsCertificate);
cert.md.update(bytes.getBytes());
}
var imd = forge2.md.sha1.create();
var ibytes = asn1.toDer(capture.certIssuer);
imd.update(ibytes.getBytes());
cert.issuer.getField = function(sn) {
return _getAttribute(cert.issuer, sn);
};
cert.issuer.addField = function(attr) {
_fillMissingFields([attr]);
cert.issuer.attributes.push(attr);
};
cert.issuer.attributes = pki2.RDNAttributesAsArray(capture.certIssuer);
if (capture.certIssuerUniqueId) {
cert.issuer.uniqueId = capture.certIssuerUniqueId;
}
cert.issuer.hash = imd.digest().toHex();
var smd = forge2.md.sha1.create();
var sbytes = asn1.toDer(capture.certSubject);
smd.update(sbytes.getBytes());
cert.subject.getField = function(sn) {
return _getAttribute(cert.subject, sn);
};
cert.subject.addField = function(attr) {
_fillMissingFields([attr]);
cert.subject.attributes.push(attr);
};
cert.subject.attributes = pki2.RDNAttributesAsArray(capture.certSubject);
if (capture.certSubjectUniqueId) {
cert.subject.uniqueId = capture.certSubjectUniqueId;
}
cert.subject.hash = smd.digest().toHex();
if (capture.certExtensions) {
cert.extensions = pki2.certificateExtensionsFromAsn1(capture.certExtensions);
} else {
cert.extensions = [];
}
cert.publicKey = pki2.publicKeyFromAsn1(capture.subjectPublicKeyInfo);
return cert;
};
pki2.certificateExtensionsFromAsn1 = function(exts) {
var rval = [];
for (var i = 0; i < exts.value.length; ++i) {
var extseq = exts.value[i];
for (var ei = 0; ei < extseq.value.length; ++ei) {
rval.push(pki2.certificateExtensionFromAsn1(extseq.value[ei]));
}
}
return rval;
};
pki2.certificateExtensionFromAsn1 = function(ext) {
var e = {};
e.id = asn1.derToOid(ext.value[0].value);
e.critical = false;
if (ext.value[1].type === asn1.Type.BOOLEAN) {
e.critical = ext.value[1].value.charCodeAt(0) !== 0;
e.value = ext.value[2].value;
} else {
e.value = ext.value[1].value;
}
if (e.id in oids) {
e.name = oids[e.id];
if (e.name === "keyUsage") {
var ev = asn1.fromDer(e.value);
var b2 = 0;
var b3 = 0;
if (ev.value.length > 1) {
b2 = ev.value.charCodeAt(1);
b3 = ev.value.length > 2 ? ev.value.charCodeAt(2) : 0;
}
e.digitalSignature = (b2 & 128) === 128;
e.nonRepudiation = (b2 & 64) === 64;
e.keyEncipherment = (b2 & 32) === 32;
e.dataEncipherment = (b2 & 16) === 16;
e.keyAgreement = (b2 & 8) === 8;
e.keyCertSign = (b2 & 4) === 4;
e.cRLSign = (b2 & 2) === 2;
e.encipherOnly = (b2 & 1) === 1;
e.decipherOnly = (b3 & 128) === 128;
} else if (e.name === "basicConstraints") {
var ev = asn1.fromDer(e.value);
if (ev.value.length > 0 && ev.value[0].type === asn1.Type.BOOLEAN) {
e.cA = ev.value[0].value.charCodeAt(0) !== 0;
} else {
e.cA = false;
}
var value2 = null;
if (ev.value.length > 0 && ev.value[0].type === asn1.Type.INTEGER) {
value2 = ev.value[0].value;
} else if (ev.value.length > 1) {
value2 = ev.value[1].value;
}
if (value2 !== null) {
e.pathLenConstraint = asn1.derToInteger(value2);
}
} else if (e.name === "extKeyUsage") {
var ev = asn1.fromDer(e.value);
for (var vi = 0; vi < ev.value.length; ++vi) {
var oid = asn1.derToOid(ev.value[vi].value);
if (oid in oids) {
e[oids[oid]] = true;
} else {
e[oid] = true;
}
}
} else if (e.name === "nsCertType") {
var ev = asn1.fromDer(e.value);
var b2 = 0;
if (ev.value.length > 1) {
b2 = ev.value.charCodeAt(1);
}
e.client = (b2 & 128) === 128;
e.server = (b2 & 64) === 64;
e.email = (b2 & 32) === 32;
e.objsign = (b2 & 16) === 16;
e.reserved = (b2 & 8) === 8;
e.sslCA = (b2 & 4) === 4;
e.emailCA = (b2 & 2) === 2;
e.objCA = (b2 & 1) === 1;
} else if (e.name === "subjectAltName" || e.name === "issuerAltName") {
e.altNames = [];
var gn;
var ev = asn1.fromDer(e.value);
for (var n = 0; n < ev.value.length; ++n) {
gn = ev.value[n];
var altName = {
type: gn.type,
value: gn.value
};
e.altNames.push(altName);
switch (gn.type) {
case 1:
case 2:
case 6:
break;
case 7:
altName.ip = forge2.util.bytesToIP(gn.value);
break;
case 8:
altName.oid = asn1.derToOid(gn.value);
break;
default:
}
}
} else if (e.name === "subjectKeyIdentifier") {
var ev = asn1.fromDer(e.value);
e.subjectKeyIdentifier = forge2.util.bytesToHex(ev.value);
}
}
return e;
};
pki2.certificationRequestFromAsn1 = function(obj, computeHash) {
var capture = {};
var errors = [];
if (!asn1.validate(obj, certificationRequestValidator, capture, errors)) {
var error = new Error("Cannot read PKCS#10 certificate request. ASN.1 object is not a PKCS#10 CertificationRequest.");
error.errors = errors;
throw error;
}
var oid = asn1.derToOid(capture.publicKeyOid);
if (oid !== pki2.oids.rsaEncryption) {
throw new Error("Cannot read public key. OID is not RSA.");
}
var csr = pki2.createCertificationRequest();
csr.version = capture.csrVersion ? capture.csrVersion.charCodeAt(0) : 0;
csr.signatureOid = forge2.asn1.derToOid(capture.csrSignatureOid);
csr.signatureParameters = _readSignatureParameters(
csr.signatureOid,
capture.csrSignatureParams,
true
);
csr.siginfo.algorithmOid = forge2.asn1.derToOid(capture.csrSignatureOid);
csr.siginfo.parameters = _readSignatureParameters(
csr.siginfo.algorithmOid,
capture.csrSignatureParams,
false
);
csr.signature = capture.csrSignature;
csr.certificationRequestInfo = capture.certificationRequestInfo;
if (computeHash) {
csr.md = _createSignatureDigest({
signatureOid: csr.signatureOid,
type: "certification request"
});
var bytes = asn1.toDer(csr.certificationRequestInfo);
csr.md.update(bytes.getBytes());
}
var smd = forge2.md.sha1.create();
csr.subject.getField = function(sn) {
return _getAttribute(csr.subject, sn);
};
csr.subject.addField = function(attr) {
_fillMissingFields([attr]);
csr.subject.attributes.push(attr);
};
csr.subject.attributes = pki2.RDNAttributesAsArray(
capture.certificationRequestInfoSubject,
smd
);
csr.subject.hash = smd.digest().toHex();
csr.publicKey = pki2.publicKeyFromAsn1(capture.subjectPublicKeyInfo);
csr.getAttribute = function(sn) {
return _getAttribute(csr, sn);
};
csr.addAttribute = function(attr) {
_fillMissingFields([attr]);
csr.attributes.push(attr);
};
csr.attributes = pki2.CRIAttributesAsArray(
capture.certificationRequestInfoAttributes || []
);
return csr;
};
pki2.createCertificationRequest = function() {
var csr = {};
csr.version = 0;
csr.signatureOid = null;
csr.signature = null;
csr.siginfo = {};
csr.siginfo.algorithmOid = null;
csr.subject = {};
csr.subject.getField = function(sn) {
return _getAttribute(csr.subject, sn);
};
csr.subject.addField = function(attr) {
_fillMissingFields([attr]);
csr.subject.attributes.push(attr);
};
csr.subject.attributes = [];
csr.subject.hash = null;
csr.publicKey = null;
csr.attributes = [];
csr.getAttribute = function(sn) {
return _getAttribute(csr, sn);
};
csr.addAttribute = function(attr) {
_fillMissingFields([attr]);
csr.attributes.push(attr);
};
csr.md = null;
csr.setSubject = function(attrs) {
_fillMissingFields(attrs);
csr.subject.attributes = attrs;
csr.subject.hash = null;
};
csr.setAttributes = function(attrs) {
_fillMissingFields(attrs);
csr.attributes = attrs;
};
csr.sign = function(key2, md) {
csr.md = md || forge2.md.sha1.create();
var algorithmOid = oids[csr.md.algorithm + "WithRSAEncryption"];
if (!algorithmOid) {
var error = new Error("Could not compute certification request digest. Unknown message digest algorithm OID.");
error.algorithm = csr.md.algorithm;
throw error;
}
csr.signatureOid = csr.siginfo.algorithmOid = algorithmOid;
csr.certificationRequestInfo = pki2.getCertificationRequestInfo(csr);
var bytes = asn1.toDer(csr.certificationRequestInfo);
csr.md.update(bytes.getBytes());
csr.signature = key2.sign(csr.md);
};
csr.verify = function() {
var rval = false;
var md = csr.md;
if (md === null) {
md = _createSignatureDigest({
signatureOid: csr.signatureOid,
type: "certification request"
});
var cri = csr.certificationRequestInfo || pki2.getCertificationRequestInfo(csr);
var bytes = asn1.toDer(cri);
md.update(bytes.getBytes());
}
if (md !== null) {
rval = _verifySignature({
certificate: csr,
md,
signature: csr.signature
});
}
return rval;
};
return csr;
};
function _dnToAsn1(obj) {
var rval = asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.SEQUENCE,
true,
[]
);
var attr, set;
var attrs = obj.attributes;
for (var i = 0; i < attrs.length; ++i) {
attr = attrs[i];
var value2 = attr.value;
var valueTagClass = asn1.Type.PRINTABLESTRING;
if ("valueTagClass" in attr) {
valueTagClass = attr.valueTagClass;
if (valueTagClass === asn1.Type.UTF8) {
value2 = forge2.util.encodeUtf8(value2);
}
}
set = asn1.create(asn1.Class.UNIVERSAL, asn1.Type.SET, true, [
asn1.create(asn1.Class.UNIVERSAL, asn1.Type.SEQUENCE, true, [
// AttributeType
asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.OID,
false,
asn1.oidToDer(attr.type).getBytes()
),
// AttributeValue
asn1.create(asn1.Class.UNIVERSAL, valueTagClass, false, value2)
])
]);
rval.value.push(set);
}
return rval;
}
function _fillMissingFields(attrs) {
var attr;
for (var i = 0; i < attrs.length; ++i) {
attr = attrs[i];
if (typeof attr.name === "undefined") {
if (attr.type && attr.type in pki2.oids) {
attr.name = pki2.oids[attr.type];
} else if (attr.shortName && attr.shortName in _shortNames) {
attr.name = pki2.oids[_shortNames[attr.shortName]];
}
}
if (typeof attr.type === "undefined") {
if (attr.name && attr.name in pki2.oids) {
attr.type = pki2.oids[attr.name];
} else {
var error = new Error("Attribute type not specified.");
error.attribute = attr;
throw error;
}
}
if (typeof attr.shortName === "undefined") {
if (attr.name && attr.name in _shortNames) {
attr.shortName = _shortNames[attr.name];
}
}
if (attr.type === oids.extensionRequest) {
attr.valueConstructed = true;
attr.valueTagClass = asn1.Type.SEQUENCE;
if (!attr.value && attr.extensions) {
attr.value = [];
for (var ei = 0; ei < attr.extensions.length; ++ei) {
attr.value.push(pki2.certificateExtensionToAsn1(
_fillMissingExtensionFields(attr.extensions[ei])
));
}
}
}
if (typeof attr.value === "undefined") {
var error = new Error("Attribute value not specified.");
error.attribute = attr;
throw error;
}
}
}
function _fillMissingExtensionFields(e, options) {
options = options || {};
if (typeof e.name === "undefined") {
if (e.id && e.id in pki2.oids) {
e.name = pki2.oids[e.id];
}
}
if (typeof e.id === "undefined") {
if (e.name && e.name in pki2.oids) {
e.id = pki2.oids[e.name];
} else {
var error = new Error("Extension ID not specified.");
error.extension = e;
throw error;
}
}
if (typeof e.value !== "undefined") {
return e;
}
if (e.name === "keyUsage") {
var unused = 0;
var b2 = 0;
var b3 = 0;
if (e.digitalSignature) {
b2 |= 128;
unused = 7;
}
if (e.nonRepudiation) {
b2 |= 64;
unused = 6;
}
if (e.keyEncipherment) {
b2 |= 32;
unused = 5;
}
if (e.dataEncipherment) {
b2 |= 16;
unused = 4;
}
if (e.keyAgreement) {
b2 |= 8;
unused = 3;
}
if (e.keyCertSign) {
b2 |= 4;
unused = 2;
}
if (e.cRLSign) {
b2 |= 2;
unused = 1;
}
if (e.encipherOnly) {
b2 |= 1;
unused = 0;
}
if (e.decipherOnly) {
b3 |= 128;
unused = 7;
}
var value2 = String.fromCharCode(unused);
if (b3 !== 0) {
value2 += String.fromCharCode(b2) + String.fromCharCode(b3);
} else if (b2 !== 0) {
value2 += String.fromCharCode(b2);
}
e.value = asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.BITSTRING,
false,
value2
);
} else if (e.name === "basicConstraints") {
e.value = asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.SEQUENCE,
true,
[]
);
if (e.cA) {
e.value.value.push(asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.BOOLEAN,
false,
String.fromCharCode(255)
));
}
if ("pathLenConstraint" in e) {
e.value.value.push(asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.INTEGER,
false,
asn1.integerToDer(e.pathLenConstraint).getBytes()
));
}
} else if (e.name === "extKeyUsage") {
e.value = asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.SEQUENCE,
true,
[]
);
var seq = e.value.value;
for (var key2 in e) {
if (e[key2] !== true) {
continue;
}
if (key2 in oids) {
seq.push(asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.OID,
false,
asn1.oidToDer(oids[key2]).getBytes()
));
} else if (key2.indexOf(".") !== -1) {
seq.push(asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.OID,
false,
asn1.oidToDer(key2).getBytes()
));
}
}
} else if (e.name === "nsCertType") {
var unused = 0;
var b2 = 0;
if (e.client) {
b2 |= 128;
unused = 7;
}
if (e.server) {
b2 |= 64;
unused = 6;
}
if (e.email) {
b2 |= 32;
unused = 5;
}
if (e.objsign) {
b2 |= 16;
unused = 4;
}
if (e.reserved) {
b2 |= 8;
unused = 3;
}
if (e.sslCA) {
b2 |= 4;
unused = 2;
}
if (e.emailCA) {
b2 |= 2;
unused = 1;
}
if (e.objCA) {
b2 |= 1;
unused = 0;
}
var value2 = String.fromCharCode(unused);
if (b2 !== 0) {
value2 += String.fromCharCode(b2);
}
e.value = asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.BITSTRING,
false,
value2
);
} else if (e.name === "subjectAltName" || e.name === "issuerAltName") {
e.value = asn1.create(asn1.Class.UNIVERSAL, asn1.Type.SEQUENCE, true, []);
var altName;
for (var n = 0; n < e.altNames.length; ++n) {
altName = e.altNames[n];
var value2 = altName.value;
if (altName.type === 7 && altName.ip) {
value2 = forge2.util.bytesFromIP(altName.ip);
if (value2 === null) {
var error = new Error(
'Extension "ip" value is not a valid IPv4 or IPv6 address.'
);
error.extension = e;
throw error;
}
} else if (altName.type === 8) {
if (altName.oid) {
value2 = asn1.oidToDer(asn1.oidToDer(altName.oid));
} else {
value2 = asn1.oidToDer(value2);
}
}
e.value.value.push(asn1.create(
asn1.Class.CONTEXT_SPECIFIC,
altName.type,
false,
value2
));
}
} else if (e.name === "nsComment" && options.cert) {
if (!/^[\x00-\x7F]*$/.test(e.comment) || e.comment.length < 1 || e.comment.length > 128) {
throw new Error('Invalid "nsComment" content.');
}
e.value = asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.IA5STRING,
false,
e.comment
);
} else if (e.name === "subjectKeyIdentifier" && options.cert) {
var ski = options.cert.generateSubjectKeyIdentifier();
e.subjectKeyIdentifier = ski.toHex();
e.value = asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.OCTETSTRING,
false,
ski.getBytes()
);
} else if (e.name === "authorityKeyIdentifier" && options.cert) {
e.value = asn1.create(asn1.Class.UNIVERSAL, asn1.Type.SEQUENCE, true, []);
var seq = e.value.value;
if (e.keyIdentifier) {
var keyIdentifier = e.keyIdentifier === true ? options.cert.generateSubjectKeyIdentifier().getBytes() : e.keyIdentifier;
seq.push(
asn1.create(asn1.Class.CONTEXT_SPECIFIC, 0, false, keyIdentifier)
);
}
if (e.authorityCertIssuer) {
var authorityCertIssuer = [
asn1.create(asn1.Class.CONTEXT_SPECIFIC, 4, true, [
_dnToAsn1(e.authorityCertIssuer === true ? options.cert.issuer : e.authorityCertIssuer)
])
];
seq.push(
asn1.create(asn1.Class.CONTEXT_SPECIFIC, 1, true, authorityCertIssuer)
);
}
if (e.serialNumber) {
var serialNumber = forge2.util.hexToBytes(e.serialNumber === true ? options.cert.serialNumber : e.serialNumber);
seq.push(
asn1.create(asn1.Class.CONTEXT_SPECIFIC, 2, false, serialNumber)
);
}
} else if (e.name === "cRLDistributionPoints") {
e.value = asn1.create(asn1.Class.UNIVERSAL, asn1.Type.SEQUENCE, true, []);
var seq = e.value.value;
var subSeq = asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.SEQUENCE,
true,
[]
);
var fullNameGeneralNames = asn1.create(
asn1.Class.CONTEXT_SPECIFIC,
0,
true,
[]
);
var altName;
for (var n = 0; n < e.altNames.length; ++n) {
altName = e.altNames[n];
var value2 = altName.value;
if (altName.type === 7 && altName.ip) {
value2 = forge2.util.bytesFromIP(altName.ip);
if (value2 === null) {
var error = new Error(
'Extension "ip" value is not a valid IPv4 or IPv6 address.'
);
error.extension = e;
throw error;
}
} else if (altName.type === 8) {
if (altName.oid) {
value2 = asn1.oidToDer(asn1.oidToDer(altName.oid));
} else {
value2 = asn1.oidToDer(value2);
}
}
fullNameGeneralNames.value.push(asn1.create(
asn1.Class.CONTEXT_SPECIFIC,
altName.type,
false,
value2
));
}
subSeq.value.push(asn1.create(
asn1.Class.CONTEXT_SPECIFIC,
0,
true,
[fullNameGeneralNames]
));
seq.push(subSeq);
}
if (typeof e.value === "undefined") {
var error = new Error("Extension value not specified.");
error.extension = e;
throw error;
}
return e;
}
function _signatureParametersToAsn1(oid, params) {
switch (oid) {
case oids["RSASSA-PSS"]:
var parts = [];
if (params.hash.algorithmOid !== void 0) {
parts.push(asn1.create(asn1.Class.CONTEXT_SPECIFIC, 0, true, [
asn1.create(asn1.Class.UNIVERSAL, asn1.Type.SEQUENCE, true, [
asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.OID,
false,
asn1.oidToDer(params.hash.algorithmOid).getBytes()
),
asn1.create(asn1.Class.UNIVERSAL, asn1.Type.NULL, false, "")
])
]));
}
if (params.mgf.algorithmOid !== void 0) {
parts.push(asn1.create(asn1.Class.CONTEXT_SPECIFIC, 1, true, [
asn1.create(asn1.Class.UNIVERSAL, asn1.Type.SEQUENCE, true, [
asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.OID,
false,
asn1.oidToDer(params.mgf.algorithmOid).getBytes()
),
asn1.create(asn1.Class.UNIVERSAL, asn1.Type.SEQUENCE, true, [
asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.OID,
false,
asn1.oidToDer(params.mgf.hash.algorithmOid).getBytes()
),
asn1.create(asn1.Class.UNIVERSAL, asn1.Type.NULL, false, "")
])
])
]));
}
if (params.saltLength !== void 0) {
parts.push(asn1.create(asn1.Class.CONTEXT_SPECIFIC, 2, true, [
asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.INTEGER,
false,
asn1.integerToDer(params.saltLength).getBytes()
)
]));
}
return asn1.create(asn1.Class.UNIVERSAL, asn1.Type.SEQUENCE, true, parts);
default:
return asn1.create(asn1.Class.UNIVERSAL, asn1.Type.NULL, false, "");
}
}
function _CRIAttributesToAsn1(csr) {
var rval = asn1.create(asn1.Class.CONTEXT_SPECIFIC, 0, true, []);
if (csr.attributes.length === 0) {
return rval;
}
var attrs = csr.attributes;
for (var i = 0; i < attrs.length; ++i) {
var attr = attrs[i];
var value2 = attr.value;
var valueTagClass = asn1.Type.UTF8;
if ("valueTagClass" in attr) {
valueTagClass = attr.valueTagClass;
}
if (valueTagClass === asn1.Type.UTF8) {
value2 = forge2.util.encodeUtf8(value2);
}
var valueConstructed = false;
if ("valueConstructed" in attr) {
valueConstructed = attr.valueConstructed;
}
var seq = asn1.create(asn1.Class.UNIVERSAL, asn1.Type.SEQUENCE, true, [
// AttributeType
asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.OID,
false,
asn1.oidToDer(attr.type).getBytes()
),
asn1.create(asn1.Class.UNIVERSAL, asn1.Type.SET, true, [
// AttributeValue
asn1.create(
asn1.Class.UNIVERSAL,
valueTagClass,
valueConstructed,
value2
)
])
]);
rval.value.push(seq);
}
return rval;
}
var jan_1_1950 = /* @__PURE__ */ new Date("1950-01-01T00:00:00Z");
var jan_1_2050 = /* @__PURE__ */ new Date("2050-01-01T00:00:00Z");
function _dateToAsn1(date) {
if (date >= jan_1_1950 && date < jan_1_2050) {
return asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.UTCTIME,
false,
asn1.dateToUtcTime(date)
);
} else {
return asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.GENERALIZEDTIME,
false,
asn1.dateToGeneralizedTime(date)
);
}
}
pki2.getTBSCertificate = function(cert) {
var notBefore = _dateToAsn1(cert.validity.notBefore);
var notAfter = _dateToAsn1(cert.validity.notAfter);
var tbs = asn1.create(asn1.Class.UNIVERSAL, asn1.Type.SEQUENCE, true, [
// version
asn1.create(asn1.Class.CONTEXT_SPECIFIC, 0, true, [
// integer
asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.INTEGER,
false,
asn1.integerToDer(cert.version).getBytes()
)
]),
// serialNumber
asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.INTEGER,
false,
forge2.util.hexToBytes(cert.serialNumber)
),
// signature
asn1.create(asn1.Class.UNIVERSAL, asn1.Type.SEQUENCE, true, [
// algorithm
asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.OID,
false,
asn1.oidToDer(cert.siginfo.algorithmOid).getBytes()
),
// parameters
_signatureParametersToAsn1(
cert.siginfo.algorithmOid,
cert.siginfo.parameters
)
]),
// issuer
_dnToAsn1(cert.issuer),
// validity
asn1.create(asn1.Class.UNIVERSAL, asn1.Type.SEQUENCE, true, [
notBefore,
notAfter
]),
// subject
_dnToAsn1(cert.subject),
// SubjectPublicKeyInfo
pki2.publicKeyToAsn1(cert.publicKey)
]);
if (cert.issuer.uniqueId) {
tbs.value.push(
asn1.create(asn1.Class.CONTEXT_SPECIFIC, 1, true, [
asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.BITSTRING,
false,
// TODO: support arbitrary bit length ids
String.fromCharCode(0) + cert.issuer.uniqueId
)
])
);
}
if (cert.subject.uniqueId) {
tbs.value.push(
asn1.create(asn1.Class.CONTEXT_SPECIFIC, 2, true, [
asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.BITSTRING,
false,
// TODO: support arbitrary bit length ids
String.fromCharCode(0) + cert.subject.uniqueId
)
])
);
}
if (cert.extensions.length > 0) {
tbs.value.push(pki2.certificateExtensionsToAsn1(cert.extensions));
}
return tbs;
};
pki2.getCertificationRequestInfo = function(csr) {
var cri = asn1.create(asn1.Class.UNIVERSAL, asn1.Type.SEQUENCE, true, [
// version
asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.INTEGER,
false,
asn1.integerToDer(csr.version).getBytes()
),
// subject
_dnToAsn1(csr.subject),
// SubjectPublicKeyInfo
pki2.publicKeyToAsn1(csr.publicKey),
// attributes
_CRIAttributesToAsn1(csr)
]);
return cri;
};
pki2.distinguishedNameToAsn1 = function(dn) {
return _dnToAsn1(dn);
};
pki2.certificateToAsn1 = function(cert) {
var tbsCertificate = cert.tbsCertificate || pki2.getTBSCertificate(cert);
return asn1.create(asn1.Class.UNIVERSAL, asn1.Type.SEQUENCE, true, [
// TBSCertificate
tbsCertificate,
// AlgorithmIdentifier (signature algorithm)
asn1.create(asn1.Class.UNIVERSAL, asn1.Type.SEQUENCE, true, [
// algorithm
asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.OID,
false,
asn1.oidToDer(cert.signatureOid).getBytes()
),
// parameters
_signatureParametersToAsn1(cert.signatureOid, cert.signatureParameters)
]),
// SignatureValue
asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.BITSTRING,
false,
String.fromCharCode(0) + cert.signature
)
]);
};
pki2.certificateExtensionsToAsn1 = function(exts) {
var rval = asn1.create(asn1.Class.CONTEXT_SPECIFIC, 3, true, []);
var seq = asn1.create(asn1.Class.UNIVERSAL, asn1.Type.SEQUENCE, true, []);
rval.value.push(seq);
for (var i = 0; i < exts.length; ++i) {
seq.value.push(pki2.certificateExtensionToAsn1(exts[i]));
}
return rval;
};
pki2.certificateExtensionToAsn1 = function(ext) {
var extseq = asn1.create(asn1.Class.UNIVERSAL, asn1.Type.SEQUENCE, true, []);
extseq.value.push(asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.OID,
false,
asn1.oidToDer(ext.id).getBytes()
));
if (ext.critical) {
extseq.value.push(asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.BOOLEAN,
false,
String.fromCharCode(255)
));
}
var value2 = ext.value;
if (typeof ext.value !== "string") {
value2 = asn1.toDer(value2).getBytes();
}
extseq.value.push(asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.OCTETSTRING,
false,
value2
));
return extseq;
};
pki2.certificationRequestToAsn1 = function(csr) {
var cri = csr.certificationRequestInfo || pki2.getCertificationRequestInfo(csr);
return asn1.create(asn1.Class.UNIVERSAL, asn1.Type.SEQUENCE, true, [
// CertificationRequestInfo
cri,
// AlgorithmIdentifier (signature algorithm)
asn1.create(asn1.Class.UNIVERSAL, asn1.Type.SEQUENCE, true, [
// algorithm
asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.OID,
false,
asn1.oidToDer(csr.signatureOid).getBytes()
),
// parameters
_signatureParametersToAsn1(csr.signatureOid, csr.signatureParameters)
]),
// signature
asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.BITSTRING,
false,
String.fromCharCode(0) + csr.signature
)
]);
};
pki2.createCaStore = function(certs) {
var caStore = {
// stored certificates
certs: {}
};
caStore.getIssuer = function(cert2) {
var rval = getBySubject(cert2.issuer);
return rval;
};
caStore.addCertificate = function(cert2) {
if (typeof cert2 === "string") {
cert2 = forge2.pki.certificateFromPem(cert2);
}
ensureSubjectHasHash(cert2.subject);
if (!caStore.hasCertificate(cert2)) {
if (cert2.subject.hash in caStore.certs) {
var tmp = caStore.certs[cert2.subject.hash];
if (!forge2.util.isArray(tmp)) {
tmp = [tmp];
}
tmp.push(cert2);
caStore.certs[cert2.subject.hash] = tmp;
} else {
caStore.certs[cert2.subject.hash] = cert2;
}
}
};
caStore.hasCertificate = function(cert2) {
if (typeof cert2 === "string") {
cert2 = forge2.pki.certificateFromPem(cert2);
}
var match2 = getBySubject(cert2.subject);
if (!match2) {
return false;
}
if (!forge2.util.isArray(match2)) {
match2 = [match2];
}
var der1 = asn1.toDer(pki2.certificateToAsn1(cert2)).getBytes();
for (var i2 = 0; i2 < match2.length; ++i2) {
var der2 = asn1.toDer(pki2.certificateToAsn1(match2[i2])).getBytes();
if (der1 === der2) {
return true;
}
}
return false;
};
caStore.listAllCertificates = function() {
var certList = [];
for (var hash in caStore.certs) {
if (caStore.certs.hasOwnProperty(hash)) {
var value2 = caStore.certs[hash];
if (!forge2.util.isArray(value2)) {
certList.push(value2);
} else {
for (var i2 = 0; i2 < value2.length; ++i2) {
certList.push(value2[i2]);
}
}
}
}
return certList;
};
caStore.removeCertificate = function(cert2) {
var result;
if (typeof cert2 === "string") {
cert2 = forge2.pki.certificateFromPem(cert2);
}
ensureSubjectHasHash(cert2.subject);
if (!caStore.hasCertificate(cert2)) {
return null;
}
var match2 = getBySubject(cert2.subject);
if (!forge2.util.isArray(match2)) {
result = caStore.certs[cert2.subject.hash];
delete caStore.certs[cert2.subject.hash];
return result;
}
var der1 = asn1.toDer(pki2.certificateToAsn1(cert2)).getBytes();
for (var i2 = 0; i2 < match2.length; ++i2) {
var der2 = asn1.toDer(pki2.certificateToAsn1(match2[i2])).getBytes();
if (der1 === der2) {
result = match2[i2];
match2.splice(i2, 1);
}
}
if (match2.length === 0) {
delete caStore.certs[cert2.subject.hash];
}
return result;
};
function getBySubject(subject) {
ensureSubjectHasHash(subject);
return caStore.certs[subject.hash] || null;
}
function ensureSubjectHasHash(subject) {
if (!subject.hash) {
var md = forge2.md.sha1.create();
subject.attributes = pki2.RDNAttributesAsArray(_dnToAsn1(subject), md);
subject.hash = md.digest().toHex();
}
}
if (certs) {
for (var i = 0; i < certs.length; ++i) {
var cert = certs[i];
caStore.addCertificate(cert);
}
}
return caStore;
};
pki2.certificateError = {
bad_certificate: "forge.pki.BadCertificate",
unsupported_certificate: "forge.pki.UnsupportedCertificate",
certificate_revoked: "forge.pki.CertificateRevoked",
certificate_expired: "forge.pki.CertificateExpired",
certificate_unknown: "forge.pki.CertificateUnknown",
unknown_ca: "forge.pki.UnknownCertificateAuthority"
};
pki2.verifyCertificateChain = function(caStore, chain, options) {
if (typeof options === "function") {
options = { verify: options };
}
options = options || {};
chain = chain.slice(0);
var certs = chain.slice(0);
var validityCheckDate = options.validityCheckDate;
if (typeof validityCheckDate === "undefined") {
validityCheckDate = /* @__PURE__ */ new Date();
}
var first2 = true;
var error = null;
var depth = 0;
do {
var cert = chain.shift();
var parent2 = null;
var selfSigned = false;
if (validityCheckDate) {
if (validityCheckDate < cert.validity.notBefore || validityCheckDate > cert.validity.notAfter) {
error = {
message: "Certificate is not valid yet or has expired.",
error: pki2.certificateError.certificate_expired,
notBefore: cert.validity.notBefore,
notAfter: cert.validity.notAfter,
// TODO: we might want to reconsider renaming 'now' to
// 'validityCheckDate' should this API be changed in the future.
now: validityCheckDate
};
}
}
if (error === null) {
parent2 = chain[0] || caStore.getIssuer(cert);
if (parent2 === null) {
if (cert.isIssuer(cert)) {
selfSigned = true;
parent2 = cert;
}
}
if (parent2) {
var parents = parent2;
if (!forge2.util.isArray(parents)) {
parents = [parents];
}
var verified = false;
while (!verified && parents.length > 0) {
parent2 = parents.shift();
try {
verified = parent2.verify(cert);
} catch (ex) {
}
}
if (!verified) {
error = {
message: "Certificate signature is invalid.",
error: pki2.certificateError.bad_certificate
};
}
}
if (error === null && (!parent2 || selfSigned) && !caStore.hasCertificate(cert)) {
error = {
message: "Certificate is not trusted.",
error: pki2.certificateError.unknown_ca
};
}
}
if (error === null && parent2 && !cert.isIssuer(parent2)) {
error = {
message: "Certificate issuer is invalid.",
error: pki2.certificateError.bad_certificate
};
}
if (error === null) {
var se = {
keyUsage: true,
basicConstraints: true
};
for (var i = 0; error === null && i < cert.extensions.length; ++i) {
var ext = cert.extensions[i];
if (ext.critical && !(ext.name in se)) {
error = {
message: "Certificate has an unsupported critical extension.",
error: pki2.certificateError.unsupported_certificate
};
}
}
}
if (error === null && (!first2 || chain.length === 0 && (!parent2 || selfSigned))) {
var bcExt = cert.getExtension("basicConstraints");
var keyUsageExt = cert.getExtension("keyUsage");
if (keyUsageExt !== null) {
if (!keyUsageExt.keyCertSign || bcExt === null) {
error = {
message: "Certificate keyUsage or basicConstraints conflict or indicate that the certificate is not a CA. If the certificate is the only one in the chain or isn't the first then the certificate must be a valid CA.",
error: pki2.certificateError.bad_certificate
};
}
}
if (error === null && bcExt !== null && !bcExt.cA) {
error = {
message: "Certificate basicConstraints indicates the certificate is not a CA.",
error: pki2.certificateError.bad_certificate
};
}
if (error === null && keyUsageExt !== null && "pathLenConstraint" in bcExt) {
var pathLen = depth - 1;
if (pathLen > bcExt.pathLenConstraint) {
error = {
message: "Certificate basicConstraints pathLenConstraint violated.",
error: pki2.certificateError.bad_certificate
};
}
}
}
var vfd = error === null ? true : error.error;
var ret = options.verify ? options.verify(vfd, depth, certs) : vfd;
if (ret === true) {
error = null;
} else {
if (vfd === true) {
error = {
message: "The application rejected the certificate.",
error: pki2.certificateError.bad_certificate
};
}
if (ret || ret === 0) {
if (typeof ret === "object" && !forge2.util.isArray(ret)) {
if (ret.message) {
error.message = ret.message;
}
if (ret.error) {
error.error = ret.error;
}
} else if (typeof ret === "string") {
error.error = ret;
}
}
throw error;
}
first2 = false;
++depth;
} while (chain.length > 0);
return true;
};
}
});
// node_modules/node-forge/lib/pkcs12.js
var require_pkcs12 = __commonJS({
"node_modules/node-forge/lib/pkcs12.js"(exports2, module2) {
"use strict";
var forge2 = require_forge();
require_asn1();
require_hmac();
require_oids();
require_pkcs7asn1();
require_pbe();
require_random();
require_rsa();
require_sha1();
require_util();
require_x509();
var asn1 = forge2.asn1;
var pki2 = forge2.pki;
var p12 = module2.exports = forge2.pkcs12 = forge2.pkcs12 || {};
var contentInfoValidator = {
name: "ContentInfo",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.SEQUENCE,
// a ContentInfo
constructed: true,
value: [{
name: "ContentInfo.contentType",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.OID,
constructed: false,
capture: "contentType"
}, {
name: "ContentInfo.content",
tagClass: asn1.Class.CONTEXT_SPECIFIC,
constructed: true,
captureAsn1: "content"
}]
};
var pfxValidator = {
name: "PFX",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.SEQUENCE,
constructed: true,
value: [
{
name: "PFX.version",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.INTEGER,
constructed: false,
capture: "version"
},
contentInfoValidator,
{
name: "PFX.macData",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.SEQUENCE,
constructed: true,
optional: true,
captureAsn1: "mac",
value: [{
name: "PFX.macData.mac",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.SEQUENCE,
// DigestInfo
constructed: true,
value: [{
name: "PFX.macData.mac.digestAlgorithm",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.SEQUENCE,
// DigestAlgorithmIdentifier
constructed: true,
value: [{
name: "PFX.macData.mac.digestAlgorithm.algorithm",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.OID,
constructed: false,
capture: "macAlgorithm"
}, {
name: "PFX.macData.mac.digestAlgorithm.parameters",
tagClass: asn1.Class.UNIVERSAL,
captureAsn1: "macAlgorithmParameters"
}]
}, {
name: "PFX.macData.mac.digest",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.OCTETSTRING,
constructed: false,
capture: "macDigest"
}]
}, {
name: "PFX.macData.macSalt",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.OCTETSTRING,
constructed: false,
capture: "macSalt"
}, {
name: "PFX.macData.iterations",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.INTEGER,
constructed: false,
optional: true,
capture: "macIterations"
}]
}
]
};
var safeBagValidator = {
name: "SafeBag",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.SEQUENCE,
constructed: true,
value: [{
name: "SafeBag.bagId",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.OID,
constructed: false,
capture: "bagId"
}, {
name: "SafeBag.bagValue",
tagClass: asn1.Class.CONTEXT_SPECIFIC,
constructed: true,
captureAsn1: "bagValue"
}, {
name: "SafeBag.bagAttributes",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.SET,
constructed: true,
optional: true,
capture: "bagAttributes"
}]
};
var attributeValidator = {
name: "Attribute",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.SEQUENCE,
constructed: true,
value: [{
name: "Attribute.attrId",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.OID,
constructed: false,
capture: "oid"
}, {
name: "Attribute.attrValues",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.SET,
constructed: true,
capture: "values"
}]
};
var certBagValidator = {
name: "CertBag",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.SEQUENCE,
constructed: true,
value: [{
name: "CertBag.certId",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.OID,
constructed: false,
capture: "certId"
}, {
name: "CertBag.certValue",
tagClass: asn1.Class.CONTEXT_SPECIFIC,
constructed: true,
/* So far we only support X.509 certificates (which are wrapped in
an OCTET STRING, hence hard code that here). */
value: [{
name: "CertBag.certValue[0]",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Class.OCTETSTRING,
constructed: false,
capture: "cert"
}]
}]
};
function _getBagsByAttribute(safeContents, attrName, attrValue, bagType) {
var result = [];
for (var i = 0; i < safeContents.length; i++) {
for (var j = 0; j < safeContents[i].safeBags.length; j++) {
var bag = safeContents[i].safeBags[j];
if (bagType !== void 0 && bag.type !== bagType) {
continue;
}
if (attrName === null) {
result.push(bag);
continue;
}
if (bag.attributes[attrName] !== void 0 && bag.attributes[attrName].indexOf(attrValue) >= 0) {
result.push(bag);
}
}
}
return result;
}
p12.pkcs12FromAsn1 = function(obj, strict, password) {
if (typeof strict === "string") {
password = strict;
strict = true;
} else if (strict === void 0) {
strict = true;
}
var capture = {};
var errors = [];
if (!asn1.validate(obj, pfxValidator, capture, errors)) {
var error = new Error("Cannot read PKCS#12 PFX. ASN.1 object is not an PKCS#12 PFX.");
error.errors = error;
throw error;
}
var pfx = {
version: capture.version.charCodeAt(0),
safeContents: [],
/**
* Gets bags with matching attributes.
*
* @param filter the attributes to filter by:
* [localKeyId] the localKeyId to search for.
* [localKeyIdHex] the localKeyId in hex to search for.
* [friendlyName] the friendly name to search for.
* [bagType] bag type to narrow each attribute search by.
*
* @return a map of attribute type to an array of matching bags or, if no
* attribute was given but a bag type, the map key will be the
* bag type.
*/
getBags: function(filter2) {
var rval = {};
var localKeyId;
if ("localKeyId" in filter2) {
localKeyId = filter2.localKeyId;
} else if ("localKeyIdHex" in filter2) {
localKeyId = forge2.util.hexToBytes(filter2.localKeyIdHex);
}
if (localKeyId === void 0 && !("friendlyName" in filter2) && "bagType" in filter2) {
rval[filter2.bagType] = _getBagsByAttribute(
pfx.safeContents,
null,
null,
filter2.bagType
);
}
if (localKeyId !== void 0) {
rval.localKeyId = _getBagsByAttribute(
pfx.safeContents,
"localKeyId",
localKeyId,
filter2.bagType
);
}
if ("friendlyName" in filter2) {
rval.friendlyName = _getBagsByAttribute(
pfx.safeContents,
"friendlyName",
filter2.friendlyName,
filter2.bagType
);
}
return rval;
},
/**
* DEPRECATED: use getBags() instead.
*
* Get bags with matching friendlyName attribute.
*
* @param friendlyName the friendly name to search for.
* @param [bagType] bag type to narrow search by.
*
* @return an array of bags with matching friendlyName attribute.
*/
getBagsByFriendlyName: function(friendlyName, bagType) {
return _getBagsByAttribute(
pfx.safeContents,
"friendlyName",
friendlyName,
bagType
);
},
/**
* DEPRECATED: use getBags() instead.
*
* Get bags with matching localKeyId attribute.
*
* @param localKeyId the localKeyId to search for.
* @param [bagType] bag type to narrow search by.
*
* @return an array of bags with matching localKeyId attribute.
*/
getBagsByLocalKeyId: function(localKeyId, bagType) {
return _getBagsByAttribute(
pfx.safeContents,
"localKeyId",
localKeyId,
bagType
);
}
};
if (capture.version.charCodeAt(0) !== 3) {
var error = new Error("PKCS#12 PFX of version other than 3 not supported.");
error.version = capture.version.charCodeAt(0);
throw error;
}
if (asn1.derToOid(capture.contentType) !== pki2.oids.data) {
var error = new Error("Only PKCS#12 PFX in password integrity mode supported.");
error.oid = asn1.derToOid(capture.contentType);
throw error;
}
var data2 = capture.content.value[0];
if (data2.tagClass !== asn1.Class.UNIVERSAL || data2.type !== asn1.Type.OCTETSTRING) {
throw new Error("PKCS#12 authSafe content data is not an OCTET STRING.");
}
data2 = _decodePkcs7Data(data2);
if (capture.mac) {
var md = null;
var macKeyBytes = 0;
var macAlgorithm = asn1.derToOid(capture.macAlgorithm);
switch (macAlgorithm) {
case pki2.oids.sha1:
md = forge2.md.sha1.create();
macKeyBytes = 20;
break;
case pki2.oids.sha256:
md = forge2.md.sha256.create();
macKeyBytes = 32;
break;
case pki2.oids.sha384:
md = forge2.md.sha384.create();
macKeyBytes = 48;
break;
case pki2.oids.sha512:
md = forge2.md.sha512.create();
macKeyBytes = 64;
break;
case pki2.oids.md5:
md = forge2.md.md5.create();
macKeyBytes = 16;
break;
}
if (md === null) {
throw new Error("PKCS#12 uses unsupported MAC algorithm: " + macAlgorithm);
}
var macSalt = new forge2.util.ByteBuffer(capture.macSalt);
var macIterations = "macIterations" in capture ? parseInt(forge2.util.bytesToHex(capture.macIterations), 16) : 1;
var macKey = p12.generateKey(
password,
macSalt,
3,
macIterations,
macKeyBytes,
md
);
var mac = forge2.hmac.create();
mac.start(md, macKey);
mac.update(data2.value);
var macValue = mac.getMac();
if (macValue.getBytes() !== capture.macDigest) {
throw new Error("PKCS#12 MAC could not be verified. Invalid password?");
}
}
_decodeAuthenticatedSafe(pfx, data2.value, strict, password);
return pfx;
};
function _decodePkcs7Data(data2) {
if (data2.composed || data2.constructed) {
var value2 = forge2.util.createBuffer();
for (var i = 0; i < data2.value.length; ++i) {
value2.putBytes(data2.value[i].value);
}
data2.composed = data2.constructed = false;
data2.value = value2.getBytes();
}
return data2;
}
function _decodeAuthenticatedSafe(pfx, authSafe, strict, password) {
authSafe = asn1.fromDer(authSafe, strict);
if (authSafe.tagClass !== asn1.Class.UNIVERSAL || authSafe.type !== asn1.Type.SEQUENCE || authSafe.constructed !== true) {
throw new Error("PKCS#12 AuthenticatedSafe expected to be a SEQUENCE OF ContentInfo");
}
for (var i = 0; i < authSafe.value.length; i++) {
var contentInfo = authSafe.value[i];
var capture = {};
var errors = [];
if (!asn1.validate(contentInfo, contentInfoValidator, capture, errors)) {
var error = new Error("Cannot read ContentInfo.");
error.errors = errors;
throw error;
}
var obj = {
encrypted: false
};
var safeContents = null;
var data2 = capture.content.value[0];
switch (asn1.derToOid(capture.contentType)) {
case pki2.oids.data:
if (data2.tagClass !== asn1.Class.UNIVERSAL || data2.type !== asn1.Type.OCTETSTRING) {
throw new Error("PKCS#12 SafeContents Data is not an OCTET STRING.");
}
safeContents = _decodePkcs7Data(data2).value;
break;
case pki2.oids.encryptedData:
safeContents = _decryptSafeContents(data2, password);
obj.encrypted = true;
break;
default:
var error = new Error("Unsupported PKCS#12 contentType.");
error.contentType = asn1.derToOid(capture.contentType);
throw error;
}
obj.safeBags = _decodeSafeContents(safeContents, strict, password);
pfx.safeContents.push(obj);
}
}
function _decryptSafeContents(data2, password) {
var capture = {};
var errors = [];
if (!asn1.validate(
data2,
forge2.pkcs7.asn1.encryptedDataValidator,
capture,
errors
)) {
var error = new Error("Cannot read EncryptedContentInfo.");
error.errors = errors;
throw error;
}
var oid = asn1.derToOid(capture.contentType);
if (oid !== pki2.oids.data) {
var error = new Error(
"PKCS#12 EncryptedContentInfo ContentType is not Data."
);
error.oid = oid;
throw error;
}
oid = asn1.derToOid(capture.encAlgorithm);
var cipher = pki2.pbe.getCipher(oid, capture.encParameter, password);
var encryptedContentAsn1 = _decodePkcs7Data(capture.encryptedContentAsn1);
var encrypted = forge2.util.createBuffer(encryptedContentAsn1.value);
cipher.update(encrypted);
if (!cipher.finish()) {
throw new Error("Failed to decrypt PKCS#12 SafeContents.");
}
return cipher.output.getBytes();
}
function _decodeSafeContents(safeContents, strict, password) {
if (!strict && safeContents.length === 0) {
return [];
}
safeContents = asn1.fromDer(safeContents, strict);
if (safeContents.tagClass !== asn1.Class.UNIVERSAL || safeContents.type !== asn1.Type.SEQUENCE || safeContents.constructed !== true) {
throw new Error(
"PKCS#12 SafeContents expected to be a SEQUENCE OF SafeBag."
);
}
var res = [];
for (var i = 0; i < safeContents.value.length; i++) {
var safeBag = safeContents.value[i];
var capture = {};
var errors = [];
if (!asn1.validate(safeBag, safeBagValidator, capture, errors)) {
var error = new Error("Cannot read SafeBag.");
error.errors = errors;
throw error;
}
var bag = {
type: asn1.derToOid(capture.bagId),
attributes: _decodeBagAttributes(capture.bagAttributes)
};
res.push(bag);
var validator, decoder;
var bagAsn1 = capture.bagValue.value[0];
switch (bag.type) {
case pki2.oids.pkcs8ShroudedKeyBag:
bagAsn1 = pki2.decryptPrivateKeyInfo(bagAsn1, password);
if (bagAsn1 === null) {
throw new Error(
"Unable to decrypt PKCS#8 ShroudedKeyBag, wrong password?"
);
}
case pki2.oids.keyBag:
try {
bag.key = pki2.privateKeyFromAsn1(bagAsn1);
} catch (e) {
bag.key = null;
bag.asn1 = bagAsn1;
}
continue;
case pki2.oids.certBag:
validator = certBagValidator;
decoder = function() {
if (asn1.derToOid(capture.certId) !== pki2.oids.x509Certificate) {
var error2 = new Error(
"Unsupported certificate type, only X.509 supported."
);
error2.oid = asn1.derToOid(capture.certId);
throw error2;
}
var certAsn1 = asn1.fromDer(capture.cert, strict);
try {
bag.cert = pki2.certificateFromAsn1(certAsn1, true);
} catch (e) {
bag.cert = null;
bag.asn1 = certAsn1;
}
};
break;
default:
var error = new Error("Unsupported PKCS#12 SafeBag type.");
error.oid = bag.type;
throw error;
}
if (validator !== void 0 && !asn1.validate(bagAsn1, validator, capture, errors)) {
var error = new Error("Cannot read PKCS#12 " + validator.name);
error.errors = errors;
throw error;
}
decoder();
}
return res;
}
function _decodeBagAttributes(attributes) {
var decodedAttrs = {};
if (attributes !== void 0) {
for (var i = 0; i < attributes.length; ++i) {
var capture = {};
var errors = [];
if (!asn1.validate(attributes[i], attributeValidator, capture, errors)) {
var error = new Error("Cannot read PKCS#12 BagAttribute.");
error.errors = errors;
throw error;
}
var oid = asn1.derToOid(capture.oid);
if (pki2.oids[oid] === void 0) {
continue;
}
decodedAttrs[pki2.oids[oid]] = [];
for (var j = 0; j < capture.values.length; ++j) {
decodedAttrs[pki2.oids[oid]].push(capture.values[j].value);
}
}
}
return decodedAttrs;
}
p12.toPkcs12Asn1 = function(key2, cert, password, options) {
options = options || {};
options.saltSize = options.saltSize || 8;
options.count = options.count || 2048;
options.algorithm = options.algorithm || options.encAlgorithm || "aes128";
if (!("useMac" in options)) {
options.useMac = true;
}
if (!("localKeyId" in options)) {
options.localKeyId = null;
}
if (!("generateLocalKeyId" in options)) {
options.generateLocalKeyId = true;
}
var localKeyId = options.localKeyId;
var bagAttrs;
if (localKeyId !== null) {
localKeyId = forge2.util.hexToBytes(localKeyId);
} else if (options.generateLocalKeyId) {
if (cert) {
var pairedCert = forge2.util.isArray(cert) ? cert[0] : cert;
if (typeof pairedCert === "string") {
pairedCert = pki2.certificateFromPem(pairedCert);
}
var sha1 = forge2.md.sha1.create();
sha1.update(asn1.toDer(pki2.certificateToAsn1(pairedCert)).getBytes());
localKeyId = sha1.digest().getBytes();
} else {
localKeyId = forge2.random.getBytes(20);
}
}
var attrs = [];
if (localKeyId !== null) {
attrs.push(
// localKeyID
asn1.create(asn1.Class.UNIVERSAL, asn1.Type.SEQUENCE, true, [
// attrId
asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.OID,
false,
asn1.oidToDer(pki2.oids.localKeyId).getBytes()
),
// attrValues
asn1.create(asn1.Class.UNIVERSAL, asn1.Type.SET, true, [
asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.OCTETSTRING,
false,
localKeyId
)
])
])
);
}
if ("friendlyName" in options) {
attrs.push(
// friendlyName
asn1.create(asn1.Class.UNIVERSAL, asn1.Type.SEQUENCE, true, [
// attrId
asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.OID,
false,
asn1.oidToDer(pki2.oids.friendlyName).getBytes()
),
// attrValues
asn1.create(asn1.Class.UNIVERSAL, asn1.Type.SET, true, [
asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.BMPSTRING,
false,
options.friendlyName
)
])
])
);
}
if (attrs.length > 0) {
bagAttrs = asn1.create(asn1.Class.UNIVERSAL, asn1.Type.SET, true, attrs);
}
var contents = [];
var chain = [];
if (cert !== null) {
if (forge2.util.isArray(cert)) {
chain = cert;
} else {
chain = [cert];
}
}
var certSafeBags = [];
for (var i = 0; i < chain.length; ++i) {
cert = chain[i];
if (typeof cert === "string") {
cert = pki2.certificateFromPem(cert);
}
var certBagAttrs = i === 0 ? bagAttrs : void 0;
var certAsn1 = pki2.certificateToAsn1(cert);
var certSafeBag = asn1.create(asn1.Class.UNIVERSAL, asn1.Type.SEQUENCE, true, [
// bagId
asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.OID,
false,
asn1.oidToDer(pki2.oids.certBag).getBytes()
),
// bagValue
asn1.create(asn1.Class.CONTEXT_SPECIFIC, 0, true, [
// CertBag
asn1.create(asn1.Class.UNIVERSAL, asn1.Type.SEQUENCE, true, [
// certId
asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.OID,
false,
asn1.oidToDer(pki2.oids.x509Certificate).getBytes()
),
// certValue (x509Certificate)
asn1.create(asn1.Class.CONTEXT_SPECIFIC, 0, true, [
asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.OCTETSTRING,
false,
asn1.toDer(certAsn1).getBytes()
)
])
])
]),
// bagAttributes (OPTIONAL)
certBagAttrs
]);
certSafeBags.push(certSafeBag);
}
if (certSafeBags.length > 0) {
var certSafeContents = asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.SEQUENCE,
true,
certSafeBags
);
var certCI = (
// PKCS#7 ContentInfo
asn1.create(asn1.Class.UNIVERSAL, asn1.Type.SEQUENCE, true, [
// contentType
asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.OID,
false,
// OID for the content type is 'data'
asn1.oidToDer(pki2.oids.data).getBytes()
),
// content
asn1.create(asn1.Class.CONTEXT_SPECIFIC, 0, true, [
asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.OCTETSTRING,
false,
asn1.toDer(certSafeContents).getBytes()
)
])
])
);
contents.push(certCI);
}
var keyBag = null;
if (key2 !== null) {
var pkAsn1 = pki2.wrapRsaPrivateKey(pki2.privateKeyToAsn1(key2));
if (password === null) {
keyBag = asn1.create(asn1.Class.UNIVERSAL, asn1.Type.SEQUENCE, true, [
// bagId
asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.OID,
false,
asn1.oidToDer(pki2.oids.keyBag).getBytes()
),
// bagValue
asn1.create(asn1.Class.CONTEXT_SPECIFIC, 0, true, [
// PrivateKeyInfo
pkAsn1
]),
// bagAttributes (OPTIONAL)
bagAttrs
]);
} else {
keyBag = asn1.create(asn1.Class.UNIVERSAL, asn1.Type.SEQUENCE, true, [
// bagId
asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.OID,
false,
asn1.oidToDer(pki2.oids.pkcs8ShroudedKeyBag).getBytes()
),
// bagValue
asn1.create(asn1.Class.CONTEXT_SPECIFIC, 0, true, [
// EncryptedPrivateKeyInfo
pki2.encryptPrivateKeyInfo(pkAsn1, password, options)
]),
// bagAttributes (OPTIONAL)
bagAttrs
]);
}
var keySafeContents = asn1.create(asn1.Class.UNIVERSAL, asn1.Type.SEQUENCE, true, [keyBag]);
var keyCI = (
// PKCS#7 ContentInfo
asn1.create(asn1.Class.UNIVERSAL, asn1.Type.SEQUENCE, true, [
// contentType
asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.OID,
false,
// OID for the content type is 'data'
asn1.oidToDer(pki2.oids.data).getBytes()
),
// content
asn1.create(asn1.Class.CONTEXT_SPECIFIC, 0, true, [
asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.OCTETSTRING,
false,
asn1.toDer(keySafeContents).getBytes()
)
])
])
);
contents.push(keyCI);
}
var safe = asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.SEQUENCE,
true,
contents
);
var macData;
if (options.useMac) {
var sha1 = forge2.md.sha1.create();
var macSalt = new forge2.util.ByteBuffer(
forge2.random.getBytes(options.saltSize)
);
var count = options.count;
var key2 = p12.generateKey(password, macSalt, 3, count, 20);
var mac = forge2.hmac.create();
mac.start(sha1, key2);
mac.update(asn1.toDer(safe).getBytes());
var macValue = mac.getMac();
macData = asn1.create(asn1.Class.UNIVERSAL, asn1.Type.SEQUENCE, true, [
// mac DigestInfo
asn1.create(asn1.Class.UNIVERSAL, asn1.Type.SEQUENCE, true, [
// digestAlgorithm
asn1.create(asn1.Class.UNIVERSAL, asn1.Type.SEQUENCE, true, [
// algorithm = SHA-1
asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.OID,
false,
asn1.oidToDer(pki2.oids.sha1).getBytes()
),
// parameters = Null
asn1.create(asn1.Class.UNIVERSAL, asn1.Type.NULL, false, "")
]),
// digest
asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.OCTETSTRING,
false,
macValue.getBytes()
)
]),
// macSalt OCTET STRING
asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.OCTETSTRING,
false,
macSalt.getBytes()
),
// iterations INTEGER (XXX: Only support count < 65536)
asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.INTEGER,
false,
asn1.integerToDer(count).getBytes()
)
]);
}
return asn1.create(asn1.Class.UNIVERSAL, asn1.Type.SEQUENCE, true, [
// version (3)
asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.INTEGER,
false,
asn1.integerToDer(3).getBytes()
),
// PKCS#7 ContentInfo
asn1.create(asn1.Class.UNIVERSAL, asn1.Type.SEQUENCE, true, [
// contentType
asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.OID,
false,
// OID for the content type is 'data'
asn1.oidToDer(pki2.oids.data).getBytes()
),
// content
asn1.create(asn1.Class.CONTEXT_SPECIFIC, 0, true, [
asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.OCTETSTRING,
false,
asn1.toDer(safe).getBytes()
)
])
]),
macData
]);
};
p12.generateKey = forge2.pbe.generatePkcs12Key;
}
});
// node_modules/node-forge/lib/pki.js
var require_pki = __commonJS({
"node_modules/node-forge/lib/pki.js"(exports2, module2) {
"use strict";
var forge2 = require_forge();
require_asn1();
require_oids();
require_pbe();
require_pem();
require_pbkdf2();
require_pkcs12();
require_pss();
require_rsa();
require_util();
require_x509();
var asn1 = forge2.asn1;
var pki2 = module2.exports = forge2.pki = forge2.pki || {};
pki2.pemToDer = function(pem) {
var msg = forge2.pem.decode(pem)[0];
if (msg.procType && msg.procType.type === "ENCRYPTED") {
throw new Error("Could not convert PEM to DER; PEM is encrypted.");
}
return forge2.util.createBuffer(msg.body);
};
pki2.privateKeyFromPem = function(pem) {
var msg = forge2.pem.decode(pem)[0];
if (msg.type !== "PRIVATE KEY" && msg.type !== "RSA PRIVATE KEY") {
var error = new Error('Could not convert private key from PEM; PEM header type is not "PRIVATE KEY" or "RSA PRIVATE KEY".');
error.headerType = msg.type;
throw error;
}
if (msg.procType && msg.procType.type === "ENCRYPTED") {
throw new Error("Could not convert private key from PEM; PEM is encrypted.");
}
var obj = asn1.fromDer(msg.body);
return pki2.privateKeyFromAsn1(obj);
};
pki2.privateKeyToPem = function(key2, maxline) {
var msg = {
type: "RSA PRIVATE KEY",
body: asn1.toDer(pki2.privateKeyToAsn1(key2)).getBytes()
};
return forge2.pem.encode(msg, { maxline });
};
pki2.privateKeyInfoToPem = function(pki3, maxline) {
var msg = {
type: "PRIVATE KEY",
body: asn1.toDer(pki3).getBytes()
};
return forge2.pem.encode(msg, { maxline });
};
}
});
// node_modules/node-forge/lib/tls.js
var require_tls = __commonJS({
"node_modules/node-forge/lib/tls.js"(exports2, module2) {
"use strict";
var forge2 = require_forge();
require_asn1();
require_hmac();
require_md5();
require_pem();
require_pki();
require_random();
require_sha1();
require_util();
var prf_TLS1 = function(secret, label, seed, length2) {
var rval = forge2.util.createBuffer();
var idx = secret.length >> 1;
var slen = idx + (secret.length & 1);
var s1 = secret.substr(0, slen);
var s2 = secret.substr(idx, slen);
var ai = forge2.util.createBuffer();
var hmac = forge2.hmac.create();
seed = label + seed;
var md5itr = Math.ceil(length2 / 16);
var sha1itr = Math.ceil(length2 / 20);
hmac.start("MD5", s1);
var md5bytes = forge2.util.createBuffer();
ai.putBytes(seed);
for (var i = 0; i < md5itr; ++i) {
hmac.start(null, null);
hmac.update(ai.getBytes());
ai.putBuffer(hmac.digest());
hmac.start(null, null);
hmac.update(ai.bytes() + seed);
md5bytes.putBuffer(hmac.digest());
}
hmac.start("SHA1", s2);
var sha1bytes = forge2.util.createBuffer();
ai.clear();
ai.putBytes(seed);
for (var i = 0; i < sha1itr; ++i) {
hmac.start(null, null);
hmac.update(ai.getBytes());
ai.putBuffer(hmac.digest());
hmac.start(null, null);
hmac.update(ai.bytes() + seed);
sha1bytes.putBuffer(hmac.digest());
}
rval.putBytes(forge2.util.xorBytes(
md5bytes.getBytes(),
sha1bytes.getBytes(),
length2
));
return rval;
};
var hmac_sha1 = function(key3, seqNum, record) {
var hmac = forge2.hmac.create();
hmac.start("SHA1", key3);
var b = forge2.util.createBuffer();
b.putInt32(seqNum[0]);
b.putInt32(seqNum[1]);
b.putByte(record.type);
b.putByte(record.version.major);
b.putByte(record.version.minor);
b.putInt16(record.length);
b.putBytes(record.fragment.bytes());
hmac.update(b.getBytes());
return hmac.digest().getBytes();
};
var deflate = function(c, record, s) {
var rval = false;
try {
var bytes = c.deflate(record.fragment.getBytes());
record.fragment = forge2.util.createBuffer(bytes);
record.length = bytes.length;
rval = true;
} catch (ex) {
}
return rval;
};
var inflate = function(c, record, s) {
var rval = false;
try {
var bytes = c.inflate(record.fragment.getBytes());
record.fragment = forge2.util.createBuffer(bytes);
record.length = bytes.length;
rval = true;
} catch (ex) {
}
return rval;
};
var readVector = function(b, lenBytes) {
var len = 0;
switch (lenBytes) {
case 1:
len = b.getByte();
break;
case 2:
len = b.getInt16();
break;
case 3:
len = b.getInt24();
break;
case 4:
len = b.getInt32();
break;
}
return forge2.util.createBuffer(b.getBytes(len));
};
var writeVector = function(b, lenBytes, v) {
b.putInt(v.length(), lenBytes << 3);
b.putBuffer(v);
};
var tls = {};
tls.Versions = {
TLS_1_0: { major: 3, minor: 1 },
TLS_1_1: { major: 3, minor: 2 },
TLS_1_2: { major: 3, minor: 3 }
};
tls.SupportedVersions = [
tls.Versions.TLS_1_1,
tls.Versions.TLS_1_0
];
tls.Version = tls.SupportedVersions[0];
tls.MaxFragment = 16384 - 1024;
tls.ConnectionEnd = {
server: 0,
client: 1
};
tls.PRFAlgorithm = {
tls_prf_sha256: 0
};
tls.BulkCipherAlgorithm = {
none: null,
rc4: 0,
des3: 1,
aes: 2
};
tls.CipherType = {
stream: 0,
block: 1,
aead: 2
};
tls.MACAlgorithm = {
none: null,
hmac_md5: 0,
hmac_sha1: 1,
hmac_sha256: 2,
hmac_sha384: 3,
hmac_sha512: 4
};
tls.CompressionMethod = {
none: 0,
deflate: 1
};
tls.ContentType = {
change_cipher_spec: 20,
alert: 21,
handshake: 22,
application_data: 23,
heartbeat: 24
};
tls.HandshakeType = {
hello_request: 0,
client_hello: 1,
server_hello: 2,
certificate: 11,
server_key_exchange: 12,
certificate_request: 13,
server_hello_done: 14,
certificate_verify: 15,
client_key_exchange: 16,
finished: 20
};
tls.Alert = {};
tls.Alert.Level = {
warning: 1,
fatal: 2
};
tls.Alert.Description = {
close_notify: 0,
unexpected_message: 10,
bad_record_mac: 20,
decryption_failed: 21,
record_overflow: 22,
decompression_failure: 30,
handshake_failure: 40,
bad_certificate: 42,
unsupported_certificate: 43,
certificate_revoked: 44,
certificate_expired: 45,
certificate_unknown: 46,
illegal_parameter: 47,
unknown_ca: 48,
access_denied: 49,
decode_error: 50,
decrypt_error: 51,
export_restriction: 60,
protocol_version: 70,
insufficient_security: 71,
internal_error: 80,
user_canceled: 90,
no_renegotiation: 100
};
tls.HeartbeatMessageType = {
heartbeat_request: 1,
heartbeat_response: 2
};
tls.CipherSuites = {};
tls.getCipherSuite = function(twoBytes) {
var rval = null;
for (var key3 in tls.CipherSuites) {
var cs = tls.CipherSuites[key3];
if (cs.id[0] === twoBytes.charCodeAt(0) && cs.id[1] === twoBytes.charCodeAt(1)) {
rval = cs;
break;
}
}
return rval;
};
tls.handleUnexpected = function(c, record) {
var ignore = !c.open && c.entity === tls.ConnectionEnd.client;
if (!ignore) {
c.error(c, {
message: "Unexpected message. Received TLS record out of order.",
send: true,
alert: {
level: tls.Alert.Level.fatal,
description: tls.Alert.Description.unexpected_message
}
});
}
};
tls.handleHelloRequest = function(c, record, length2) {
if (!c.handshaking && c.handshakes > 0) {
tls.queue(c, tls.createAlert(c, {
level: tls.Alert.Level.warning,
description: tls.Alert.Description.no_renegotiation
}));
tls.flush(c);
}
c.process();
};
tls.parseHelloMessage = function(c, record, length2) {
var msg = null;
var client = c.entity === tls.ConnectionEnd.client;
if (length2 < 38) {
c.error(c, {
message: client ? "Invalid ServerHello message. Message too short." : "Invalid ClientHello message. Message too short.",
send: true,
alert: {
level: tls.Alert.Level.fatal,
description: tls.Alert.Description.illegal_parameter
}
});
} else {
var b = record.fragment;
var remaining = b.length();
msg = {
version: {
major: b.getByte(),
minor: b.getByte()
},
random: forge2.util.createBuffer(b.getBytes(32)),
session_id: readVector(b, 1),
extensions: []
};
if (client) {
msg.cipher_suite = b.getBytes(2);
msg.compression_method = b.getByte();
} else {
msg.cipher_suites = readVector(b, 2);
msg.compression_methods = readVector(b, 1);
}
remaining = length2 - (remaining - b.length());
if (remaining > 0) {
var exts = readVector(b, 2);
while (exts.length() > 0) {
msg.extensions.push({
type: [exts.getByte(), exts.getByte()],
data: readVector(exts, 2)
});
}
if (!client) {
for (var i = 0; i < msg.extensions.length; ++i) {
var ext = msg.extensions[i];
if (ext.type[0] === 0 && ext.type[1] === 0) {
var snl = readVector(ext.data, 2);
while (snl.length() > 0) {
var snType = snl.getByte();
if (snType !== 0) {
break;
}
c.session.extensions.server_name.serverNameList.push(
readVector(snl, 2).getBytes()
);
}
}
}
}
}
if (c.session.version) {
if (msg.version.major !== c.session.version.major || msg.version.minor !== c.session.version.minor) {
return c.error(c, {
message: "TLS version change is disallowed during renegotiation.",
send: true,
alert: {
level: tls.Alert.Level.fatal,
description: tls.Alert.Description.protocol_version
}
});
}
}
if (client) {
c.session.cipherSuite = tls.getCipherSuite(msg.cipher_suite);
} else {
var tmp = forge2.util.createBuffer(msg.cipher_suites.bytes());
while (tmp.length() > 0) {
c.session.cipherSuite = tls.getCipherSuite(tmp.getBytes(2));
if (c.session.cipherSuite !== null) {
break;
}
}
}
if (c.session.cipherSuite === null) {
return c.error(c, {
message: "No cipher suites in common.",
send: true,
alert: {
level: tls.Alert.Level.fatal,
description: tls.Alert.Description.handshake_failure
},
cipherSuite: forge2.util.bytesToHex(msg.cipher_suite)
});
}
if (client) {
c.session.compressionMethod = msg.compression_method;
} else {
c.session.compressionMethod = tls.CompressionMethod.none;
}
}
return msg;
};
tls.createSecurityParameters = function(c, msg) {
var client = c.entity === tls.ConnectionEnd.client;
var msgRandom = msg.random.bytes();
var cRandom = client ? c.session.sp.client_random : msgRandom;
var sRandom = client ? msgRandom : tls.createRandom().getBytes();
c.session.sp = {
entity: c.entity,
prf_algorithm: tls.PRFAlgorithm.tls_prf_sha256,
bulk_cipher_algorithm: null,
cipher_type: null,
enc_key_length: null,
block_length: null,
fixed_iv_length: null,
record_iv_length: null,
mac_algorithm: null,
mac_length: null,
mac_key_length: null,
compression_algorithm: c.session.compressionMethod,
pre_master_secret: null,
master_secret: null,
client_random: cRandom,
server_random: sRandom
};
};
tls.handleServerHello = function(c, record, length2) {
var msg = tls.parseHelloMessage(c, record, length2);
if (c.fail) {
return;
}
if (msg.version.minor <= c.version.minor) {
c.version.minor = msg.version.minor;
} else {
return c.error(c, {
message: "Incompatible TLS version.",
send: true,
alert: {
level: tls.Alert.Level.fatal,
description: tls.Alert.Description.protocol_version
}
});
}
c.session.version = c.version;
var sessionId = msg.session_id.bytes();
if (sessionId.length > 0 && sessionId === c.session.id) {
c.expect = SCC;
c.session.resuming = true;
c.session.sp.server_random = msg.random.bytes();
} else {
c.expect = SCE;
c.session.resuming = false;
tls.createSecurityParameters(c, msg);
}
c.session.id = sessionId;
c.process();
};
tls.handleClientHello = function(c, record, length2) {
var msg = tls.parseHelloMessage(c, record, length2);
if (c.fail) {
return;
}
var sessionId = msg.session_id.bytes();
var session = null;
if (c.sessionCache) {
session = c.sessionCache.getSession(sessionId);
if (session === null) {
sessionId = "";
} else if (session.version.major !== msg.version.major || session.version.minor > msg.version.minor) {
session = null;
sessionId = "";
}
}
if (sessionId.length === 0) {
sessionId = forge2.random.getBytes(32);
}
c.session.id = sessionId;
c.session.clientHelloVersion = msg.version;
c.session.sp = {};
if (session) {
c.version = c.session.version = session.version;
c.session.sp = session.sp;
} else {
var version;
for (var i = 1; i < tls.SupportedVersions.length; ++i) {
version = tls.SupportedVersions[i];
if (version.minor <= msg.version.minor) {
break;
}
}
c.version = { major: version.major, minor: version.minor };
c.session.version = c.version;
}
if (session !== null) {
c.expect = CCC;
c.session.resuming = true;
c.session.sp.client_random = msg.random.bytes();
} else {
c.expect = c.verifyClient !== false ? CCE : CKE;
c.session.resuming = false;
tls.createSecurityParameters(c, msg);
}
c.open = true;
tls.queue(c, tls.createRecord(c, {
type: tls.ContentType.handshake,
data: tls.createServerHello(c)
}));
if (c.session.resuming) {
tls.queue(c, tls.createRecord(c, {
type: tls.ContentType.change_cipher_spec,
data: tls.createChangeCipherSpec()
}));
c.state.pending = tls.createConnectionState(c);
c.state.current.write = c.state.pending.write;
tls.queue(c, tls.createRecord(c, {
type: tls.ContentType.handshake,
data: tls.createFinished(c)
}));
} else {
tls.queue(c, tls.createRecord(c, {
type: tls.ContentType.handshake,
data: tls.createCertificate(c)
}));
if (!c.fail) {
tls.queue(c, tls.createRecord(c, {
type: tls.ContentType.handshake,
data: tls.createServerKeyExchange(c)
}));
if (c.verifyClient !== false) {
tls.queue(c, tls.createRecord(c, {
type: tls.ContentType.handshake,
data: tls.createCertificateRequest(c)
}));
}
tls.queue(c, tls.createRecord(c, {
type: tls.ContentType.handshake,
data: tls.createServerHelloDone(c)
}));
}
}
tls.flush(c);
c.process();
};
tls.handleCertificate = function(c, record, length2) {
if (length2 < 3) {
return c.error(c, {
message: "Invalid Certificate message. Message too short.",
send: true,
alert: {
level: tls.Alert.Level.fatal,
description: tls.Alert.Description.illegal_parameter
}
});
}
var b = record.fragment;
var msg = {
certificate_list: readVector(b, 3)
};
var cert, asn1;
var certs = [];
try {
while (msg.certificate_list.length() > 0) {
cert = readVector(msg.certificate_list, 3);
asn1 = forge2.asn1.fromDer(cert);
cert = forge2.pki.certificateFromAsn1(asn1, true);
certs.push(cert);
}
} catch (ex) {
return c.error(c, {
message: "Could not parse certificate list.",
cause: ex,
send: true,
alert: {
level: tls.Alert.Level.fatal,
description: tls.Alert.Description.bad_certificate
}
});
}
var client = c.entity === tls.ConnectionEnd.client;
if ((client || c.verifyClient === true) && certs.length === 0) {
c.error(c, {
message: client ? "No server certificate provided." : "No client certificate provided.",
send: true,
alert: {
level: tls.Alert.Level.fatal,
description: tls.Alert.Description.illegal_parameter
}
});
} else if (certs.length === 0) {
c.expect = client ? SKE : CKE;
} else {
if (client) {
c.session.serverCertificate = certs[0];
} else {
c.session.clientCertificate = certs[0];
}
if (tls.verifyCertificateChain(c, certs)) {
c.expect = client ? SKE : CKE;
}
}
c.process();
};
tls.handleServerKeyExchange = function(c, record, length2) {
if (length2 > 0) {
return c.error(c, {
message: "Invalid key parameters. Only RSA is supported.",
send: true,
alert: {
level: tls.Alert.Level.fatal,
description: tls.Alert.Description.unsupported_certificate
}
});
}
c.expect = SCR;
c.process();
};
tls.handleClientKeyExchange = function(c, record, length2) {
if (length2 < 48) {
return c.error(c, {
message: "Invalid key parameters. Only RSA is supported.",
send: true,
alert: {
level: tls.Alert.Level.fatal,
description: tls.Alert.Description.unsupported_certificate
}
});
}
var b = record.fragment;
var msg = {
enc_pre_master_secret: readVector(b, 2).getBytes()
};
var privateKey = null;
if (c.getPrivateKey) {
try {
privateKey = c.getPrivateKey(c, c.session.serverCertificate);
privateKey = forge2.pki.privateKeyFromPem(privateKey);
} catch (ex) {
c.error(c, {
message: "Could not get private key.",
cause: ex,
send: true,
alert: {
level: tls.Alert.Level.fatal,
description: tls.Alert.Description.internal_error
}
});
}
}
if (privateKey === null) {
return c.error(c, {
message: "No private key set.",
send: true,
alert: {
level: tls.Alert.Level.fatal,
description: tls.Alert.Description.internal_error
}
});
}
try {
var sp = c.session.sp;
sp.pre_master_secret = privateKey.decrypt(msg.enc_pre_master_secret);
var version = c.session.clientHelloVersion;
if (version.major !== sp.pre_master_secret.charCodeAt(0) || version.minor !== sp.pre_master_secret.charCodeAt(1)) {
throw new Error("TLS version rollback attack detected.");
}
} catch (ex) {
sp.pre_master_secret = forge2.random.getBytes(48);
}
c.expect = CCC;
if (c.session.clientCertificate !== null) {
c.expect = CCV;
}
c.process();
};
tls.handleCertificateRequest = function(c, record, length2) {
if (length2 < 3) {
return c.error(c, {
message: "Invalid CertificateRequest. Message too short.",
send: true,
alert: {
level: tls.Alert.Level.fatal,
description: tls.Alert.Description.illegal_parameter
}
});
}
var b = record.fragment;
var msg = {
certificate_types: readVector(b, 1),
certificate_authorities: readVector(b, 2)
};
c.session.certificateRequest = msg;
c.expect = SHD;
c.process();
};
tls.handleCertificateVerify = function(c, record, length2) {
if (length2 < 2) {
return c.error(c, {
message: "Invalid CertificateVerify. Message too short.",
send: true,
alert: {
level: tls.Alert.Level.fatal,
description: tls.Alert.Description.illegal_parameter
}
});
}
var b = record.fragment;
b.read -= 4;
var msgBytes = b.bytes();
b.read += 4;
var msg = {
signature: readVector(b, 2).getBytes()
};
var verify = forge2.util.createBuffer();
verify.putBuffer(c.session.md5.digest());
verify.putBuffer(c.session.sha1.digest());
verify = verify.getBytes();
try {
var cert = c.session.clientCertificate;
if (!cert.publicKey.verify(verify, msg.signature, "NONE")) {
throw new Error("CertificateVerify signature does not match.");
}
c.session.md5.update(msgBytes);
c.session.sha1.update(msgBytes);
} catch (ex) {
return c.error(c, {
message: "Bad signature in CertificateVerify.",
send: true,
alert: {
level: tls.Alert.Level.fatal,
description: tls.Alert.Description.handshake_failure
}
});
}
c.expect = CCC;
c.process();
};
tls.handleServerHelloDone = function(c, record, length2) {
if (length2 > 0) {
return c.error(c, {
message: "Invalid ServerHelloDone message. Invalid length.",
send: true,
alert: {
level: tls.Alert.Level.fatal,
description: tls.Alert.Description.record_overflow
}
});
}
if (c.serverCertificate === null) {
var error = {
message: "No server certificate provided. Not enough security.",
send: true,
alert: {
level: tls.Alert.Level.fatal,
description: tls.Alert.Description.insufficient_security
}
};
var depth = 0;
var ret = c.verify(c, error.alert.description, depth, []);
if (ret !== true) {
if (ret || ret === 0) {
if (typeof ret === "object" && !forge2.util.isArray(ret)) {
if (ret.message) {
error.message = ret.message;
}
if (ret.alert) {
error.alert.description = ret.alert;
}
} else if (typeof ret === "number") {
error.alert.description = ret;
}
}
return c.error(c, error);
}
}
if (c.session.certificateRequest !== null) {
record = tls.createRecord(c, {
type: tls.ContentType.handshake,
data: tls.createCertificate(c)
});
tls.queue(c, record);
}
record = tls.createRecord(c, {
type: tls.ContentType.handshake,
data: tls.createClientKeyExchange(c)
});
tls.queue(c, record);
c.expect = SER;
var callback = function(c2, signature) {
if (c2.session.certificateRequest !== null && c2.session.clientCertificate !== null) {
tls.queue(c2, tls.createRecord(c2, {
type: tls.ContentType.handshake,
data: tls.createCertificateVerify(c2, signature)
}));
}
tls.queue(c2, tls.createRecord(c2, {
type: tls.ContentType.change_cipher_spec,
data: tls.createChangeCipherSpec()
}));
c2.state.pending = tls.createConnectionState(c2);
c2.state.current.write = c2.state.pending.write;
tls.queue(c2, tls.createRecord(c2, {
type: tls.ContentType.handshake,
data: tls.createFinished(c2)
}));
c2.expect = SCC;
tls.flush(c2);
c2.process();
};
if (c.session.certificateRequest === null || c.session.clientCertificate === null) {
return callback(c, null);
}
tls.getClientSignature(c, callback);
};
tls.handleChangeCipherSpec = function(c, record) {
if (record.fragment.getByte() !== 1) {
return c.error(c, {
message: "Invalid ChangeCipherSpec message received.",
send: true,
alert: {
level: tls.Alert.Level.fatal,
description: tls.Alert.Description.illegal_parameter
}
});
}
var client = c.entity === tls.ConnectionEnd.client;
if (c.session.resuming && client || !c.session.resuming && !client) {
c.state.pending = tls.createConnectionState(c);
}
c.state.current.read = c.state.pending.read;
if (!c.session.resuming && client || c.session.resuming && !client) {
c.state.pending = null;
}
c.expect = client ? SFI : CFI;
c.process();
};
tls.handleFinished = function(c, record, length2) {
var b = record.fragment;
b.read -= 4;
var msgBytes = b.bytes();
b.read += 4;
var vd = record.fragment.getBytes();
b = forge2.util.createBuffer();
b.putBuffer(c.session.md5.digest());
b.putBuffer(c.session.sha1.digest());
var client = c.entity === tls.ConnectionEnd.client;
var label = client ? "server finished" : "client finished";
var sp = c.session.sp;
var vdl = 12;
var prf = prf_TLS1;
b = prf(sp.master_secret, label, b.getBytes(), vdl);
if (b.getBytes() !== vd) {
return c.error(c, {
message: "Invalid verify_data in Finished message.",
send: true,
alert: {
level: tls.Alert.Level.fatal,
description: tls.Alert.Description.decrypt_error
}
});
}
c.session.md5.update(msgBytes);
c.session.sha1.update(msgBytes);
if (c.session.resuming && client || !c.session.resuming && !client) {
tls.queue(c, tls.createRecord(c, {
type: tls.ContentType.change_cipher_spec,
data: tls.createChangeCipherSpec()
}));
c.state.current.write = c.state.pending.write;
c.state.pending = null;
tls.queue(c, tls.createRecord(c, {
type: tls.ContentType.handshake,
data: tls.createFinished(c)
}));
}
c.expect = client ? SAD : CAD;
c.handshaking = false;
++c.handshakes;
c.peerCertificate = client ? c.session.serverCertificate : c.session.clientCertificate;
tls.flush(c);
c.isConnected = true;
c.connected(c);
c.process();
};
tls.handleAlert = function(c, record) {
var b = record.fragment;
var alert = {
level: b.getByte(),
description: b.getByte()
};
var msg;
switch (alert.description) {
case tls.Alert.Description.close_notify:
msg = "Connection closed.";
break;
case tls.Alert.Description.unexpected_message:
msg = "Unexpected message.";
break;
case tls.Alert.Description.bad_record_mac:
msg = "Bad record MAC.";
break;
case tls.Alert.Description.decryption_failed:
msg = "Decryption failed.";
break;
case tls.Alert.Description.record_overflow:
msg = "Record overflow.";
break;
case tls.Alert.Description.decompression_failure:
msg = "Decompression failed.";
break;
case tls.Alert.Description.handshake_failure:
msg = "Handshake failure.";
break;
case tls.Alert.Description.bad_certificate:
msg = "Bad certificate.";
break;
case tls.Alert.Description.unsupported_certificate:
msg = "Unsupported certificate.";
break;
case tls.Alert.Description.certificate_revoked:
msg = "Certificate revoked.";
break;
case tls.Alert.Description.certificate_expired:
msg = "Certificate expired.";
break;
case tls.Alert.Description.certificate_unknown:
msg = "Certificate unknown.";
break;
case tls.Alert.Description.illegal_parameter:
msg = "Illegal parameter.";
break;
case tls.Alert.Description.unknown_ca:
msg = "Unknown certificate authority.";
break;
case tls.Alert.Description.access_denied:
msg = "Access denied.";
break;
case tls.Alert.Description.decode_error:
msg = "Decode error.";
break;
case tls.Alert.Description.decrypt_error:
msg = "Decrypt error.";
break;
case tls.Alert.Description.export_restriction:
msg = "Export restriction.";
break;
case tls.Alert.Description.protocol_version:
msg = "Unsupported protocol version.";
break;
case tls.Alert.Description.insufficient_security:
msg = "Insufficient security.";
break;
case tls.Alert.Description.internal_error:
msg = "Internal error.";
break;
case tls.Alert.Description.user_canceled:
msg = "User canceled.";
break;
case tls.Alert.Description.no_renegotiation:
msg = "Renegotiation not supported.";
break;
default:
msg = "Unknown error.";
break;
}
if (alert.description === tls.Alert.Description.close_notify) {
return c.close();
}
c.error(c, {
message: msg,
send: false,
// origin is the opposite end
origin: c.entity === tls.ConnectionEnd.client ? "server" : "client",
alert
});
c.process();
};
tls.handleHandshake = function(c, record) {
var b = record.fragment;
var type = b.getByte();
var length2 = b.getInt24();
if (length2 > b.length()) {
c.fragmented = record;
record.fragment = forge2.util.createBuffer();
b.read -= 4;
return c.process();
}
c.fragmented = null;
b.read -= 4;
var bytes = b.bytes(length2 + 4);
b.read += 4;
if (type in hsTable[c.entity][c.expect]) {
if (c.entity === tls.ConnectionEnd.server && !c.open && !c.fail) {
c.handshaking = true;
c.session = {
version: null,
extensions: {
server_name: {
serverNameList: []
}
},
cipherSuite: null,
compressionMethod: null,
serverCertificate: null,
clientCertificate: null,
md5: forge2.md.md5.create(),
sha1: forge2.md.sha1.create()
};
}
if (type !== tls.HandshakeType.hello_request && type !== tls.HandshakeType.certificate_verify && type !== tls.HandshakeType.finished) {
c.session.md5.update(bytes);
c.session.sha1.update(bytes);
}
hsTable[c.entity][c.expect][type](c, record, length2);
} else {
tls.handleUnexpected(c, record);
}
};
tls.handleApplicationData = function(c, record) {
c.data.putBuffer(record.fragment);
c.dataReady(c);
c.process();
};
tls.handleHeartbeat = function(c, record) {
var b = record.fragment;
var type = b.getByte();
var length2 = b.getInt16();
var payload = b.getBytes(length2);
if (type === tls.HeartbeatMessageType.heartbeat_request) {
if (c.handshaking || length2 > payload.length) {
return c.process();
}
tls.queue(c, tls.createRecord(c, {
type: tls.ContentType.heartbeat,
data: tls.createHeartbeat(
tls.HeartbeatMessageType.heartbeat_response,
payload
)
}));
tls.flush(c);
} else if (type === tls.HeartbeatMessageType.heartbeat_response) {
if (payload !== c.expectedHeartbeatPayload) {
return c.process();
}
if (c.heartbeatReceived) {
c.heartbeatReceived(c, forge2.util.createBuffer(payload));
}
}
c.process();
};
var SHE = 0;
var SCE = 1;
var SKE = 2;
var SCR = 3;
var SHD = 4;
var SCC = 5;
var SFI = 6;
var SAD = 7;
var SER = 8;
var CHE = 0;
var CCE = 1;
var CKE = 2;
var CCV = 3;
var CCC = 4;
var CFI = 5;
var CAD = 6;
var __ = tls.handleUnexpected;
var R0 = tls.handleChangeCipherSpec;
var R1 = tls.handleAlert;
var R2 = tls.handleHandshake;
var R3 = tls.handleApplicationData;
var R4 = tls.handleHeartbeat;
var ctTable = [];
ctTable[tls.ConnectionEnd.client] = [
// CC,AL,HS,AD,HB
/*SHE*/
[__, R1, R2, __, R4],
/*SCE*/
[__, R1, R2, __, R4],
/*SKE*/
[__, R1, R2, __, R4],
/*SCR*/
[__, R1, R2, __, R4],
/*SHD*/
[__, R1, R2, __, R4],
/*SCC*/
[R0, R1, __, __, R4],
/*SFI*/
[__, R1, R2, __, R4],
/*SAD*/
[__, R1, R2, R3, R4],
/*SER*/
[__, R1, R2, __, R4]
];
ctTable[tls.ConnectionEnd.server] = [
// CC,AL,HS,AD
/*CHE*/
[__, R1, R2, __, R4],
/*CCE*/
[__, R1, R2, __, R4],
/*CKE*/
[__, R1, R2, __, R4],
/*CCV*/
[__, R1, R2, __, R4],
/*CCC*/
[R0, R1, __, __, R4],
/*CFI*/
[__, R1, R2, __, R4],
/*CAD*/
[__, R1, R2, R3, R4],
/*CER*/
[__, R1, R2, __, R4]
];
var H0 = tls.handleHelloRequest;
var H1 = tls.handleServerHello;
var H2 = tls.handleCertificate;
var H3 = tls.handleServerKeyExchange;
var H4 = tls.handleCertificateRequest;
var H5 = tls.handleServerHelloDone;
var H6 = tls.handleFinished;
var hsTable = [];
hsTable[tls.ConnectionEnd.client] = [
// HR,01,SH,03,04,05,06,07,08,09,10,SC,SK,CR,HD,15,CK,17,18,19,FI
/*SHE*/
[__, __, H1, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __],
/*SCE*/
[H0, __, __, __, __, __, __, __, __, __, __, H2, H3, H4, H5, __, __, __, __, __, __],
/*SKE*/
[H0, __, __, __, __, __, __, __, __, __, __, __, H3, H4, H5, __, __, __, __, __, __],
/*SCR*/
[H0, __, __, __, __, __, __, __, __, __, __, __, __, H4, H5, __, __, __, __, __, __],
/*SHD*/
[H0, __, __, __, __, __, __, __, __, __, __, __, __, __, H5, __, __, __, __, __, __],
/*SCC*/
[H0, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __],
/*SFI*/
[H0, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, H6],
/*SAD*/
[H0, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __],
/*SER*/
[H0, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __]
];
var H7 = tls.handleClientHello;
var H8 = tls.handleClientKeyExchange;
var H9 = tls.handleCertificateVerify;
hsTable[tls.ConnectionEnd.server] = [
// 01,CH,02,03,04,05,06,07,08,09,10,CC,12,13,14,CV,CK,17,18,19,FI
/*CHE*/
[__, H7, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __],
/*CCE*/
[__, __, __, __, __, __, __, __, __, __, __, H2, __, __, __, __, __, __, __, __, __],
/*CKE*/
[__, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, H8, __, __, __, __],
/*CCV*/
[__, __, __, __, __, __, __, __, __, __, __, __, __, __, __, H9, __, __, __, __, __],
/*CCC*/
[__, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __],
/*CFI*/
[__, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, H6],
/*CAD*/
[__, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __],
/*CER*/
[__, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __]
];
tls.generateKeys = function(c, sp) {
var prf = prf_TLS1;
var random2 = sp.client_random + sp.server_random;
if (!c.session.resuming) {
sp.master_secret = prf(
sp.pre_master_secret,
"master secret",
random2,
48
).bytes();
sp.pre_master_secret = null;
}
random2 = sp.server_random + sp.client_random;
var length2 = 2 * sp.mac_key_length + 2 * sp.enc_key_length;
var tls10 = c.version.major === tls.Versions.TLS_1_0.major && c.version.minor === tls.Versions.TLS_1_0.minor;
if (tls10) {
length2 += 2 * sp.fixed_iv_length;
}
var km = prf(sp.master_secret, "key expansion", random2, length2);
var rval = {
client_write_MAC_key: km.getBytes(sp.mac_key_length),
server_write_MAC_key: km.getBytes(sp.mac_key_length),
client_write_key: km.getBytes(sp.enc_key_length),
server_write_key: km.getBytes(sp.enc_key_length)
};
if (tls10) {
rval.client_write_IV = km.getBytes(sp.fixed_iv_length);
rval.server_write_IV = km.getBytes(sp.fixed_iv_length);
}
return rval;
};
tls.createConnectionState = function(c) {
var client = c.entity === tls.ConnectionEnd.client;
var createMode = function() {
var mode = {
// two 32-bit numbers, first is most significant
sequenceNumber: [0, 0],
macKey: null,
macLength: 0,
macFunction: null,
cipherState: null,
cipherFunction: function(record) {
return true;
},
compressionState: null,
compressFunction: function(record) {
return true;
},
updateSequenceNumber: function() {
if (mode.sequenceNumber[1] === 4294967295) {
mode.sequenceNumber[1] = 0;
++mode.sequenceNumber[0];
} else {
++mode.sequenceNumber[1];
}
}
};
return mode;
};
var state = {
read: createMode(),
write: createMode()
};
state.read.update = function(c2, record) {
if (!state.read.cipherFunction(record, state.read)) {
c2.error(c2, {
message: "Could not decrypt record or bad MAC.",
send: true,
alert: {
level: tls.Alert.Level.fatal,
// doesn't matter if decryption failed or MAC was
// invalid, return the same error so as not to reveal
// which one occurred
description: tls.Alert.Description.bad_record_mac
}
});
} else if (!state.read.compressFunction(c2, record, state.read)) {
c2.error(c2, {
message: "Could not decompress record.",
send: true,
alert: {
level: tls.Alert.Level.fatal,
description: tls.Alert.Description.decompression_failure
}
});
}
return !c2.fail;
};
state.write.update = function(c2, record) {
if (!state.write.compressFunction(c2, record, state.write)) {
c2.error(c2, {
message: "Could not compress record.",
send: false,
alert: {
level: tls.Alert.Level.fatal,
description: tls.Alert.Description.internal_error
}
});
} else if (!state.write.cipherFunction(record, state.write)) {
c2.error(c2, {
message: "Could not encrypt record.",
send: false,
alert: {
level: tls.Alert.Level.fatal,
description: tls.Alert.Description.internal_error
}
});
}
return !c2.fail;
};
if (c.session) {
var sp = c.session.sp;
c.session.cipherSuite.initSecurityParameters(sp);
sp.keys = tls.generateKeys(c, sp);
state.read.macKey = client ? sp.keys.server_write_MAC_key : sp.keys.client_write_MAC_key;
state.write.macKey = client ? sp.keys.client_write_MAC_key : sp.keys.server_write_MAC_key;
c.session.cipherSuite.initConnectionState(state, c, sp);
switch (sp.compression_algorithm) {
case tls.CompressionMethod.none:
break;
case tls.CompressionMethod.deflate:
state.read.compressFunction = inflate;
state.write.compressFunction = deflate;
break;
default:
throw new Error("Unsupported compression algorithm.");
}
}
return state;
};
tls.createRandom = function() {
var d = /* @__PURE__ */ new Date();
var utc = +d + d.getTimezoneOffset() * 6e4;
var rval = forge2.util.createBuffer();
rval.putInt32(utc);
rval.putBytes(forge2.random.getBytes(28));
return rval;
};
tls.createRecord = function(c, options) {
if (!options.data) {
return null;
}
var record = {
type: options.type,
version: {
major: c.version.major,
minor: c.version.minor
},
length: options.data.length(),
fragment: options.data
};
return record;
};
tls.createAlert = function(c, alert) {
var b = forge2.util.createBuffer();
b.putByte(alert.level);
b.putByte(alert.description);
return tls.createRecord(c, {
type: tls.ContentType.alert,
data: b
});
};
tls.createClientHello = function(c) {
c.session.clientHelloVersion = {
major: c.version.major,
minor: c.version.minor
};
var cipherSuites = forge2.util.createBuffer();
for (var i = 0; i < c.cipherSuites.length; ++i) {
var cs = c.cipherSuites[i];
cipherSuites.putByte(cs.id[0]);
cipherSuites.putByte(cs.id[1]);
}
var cSuites = cipherSuites.length();
var compressionMethods = forge2.util.createBuffer();
compressionMethods.putByte(tls.CompressionMethod.none);
var cMethods = compressionMethods.length();
var extensions = forge2.util.createBuffer();
if (c.virtualHost) {
var ext = forge2.util.createBuffer();
ext.putByte(0);
ext.putByte(0);
var serverName = forge2.util.createBuffer();
serverName.putByte(0);
writeVector(serverName, 2, forge2.util.createBuffer(c.virtualHost));
var snList = forge2.util.createBuffer();
writeVector(snList, 2, serverName);
writeVector(ext, 2, snList);
extensions.putBuffer(ext);
}
var extLength = extensions.length();
if (extLength > 0) {
extLength += 2;
}
var sessionId = c.session.id;
var length2 = sessionId.length + 1 + // session ID vector
2 + // version (major + minor)
4 + 28 + // random time and random bytes
2 + cSuites + // cipher suites vector
1 + cMethods + // compression methods vector
extLength;
var rval = forge2.util.createBuffer();
rval.putByte(tls.HandshakeType.client_hello);
rval.putInt24(length2);
rval.putByte(c.version.major);
rval.putByte(c.version.minor);
rval.putBytes(c.session.sp.client_random);
writeVector(rval, 1, forge2.util.createBuffer(sessionId));
writeVector(rval, 2, cipherSuites);
writeVector(rval, 1, compressionMethods);
if (extLength > 0) {
writeVector(rval, 2, extensions);
}
return rval;
};
tls.createServerHello = function(c) {
var sessionId = c.session.id;
var length2 = sessionId.length + 1 + // session ID vector
2 + // version (major + minor)
4 + 28 + // random time and random bytes
2 + // chosen cipher suite
1;
var rval = forge2.util.createBuffer();
rval.putByte(tls.HandshakeType.server_hello);
rval.putInt24(length2);
rval.putByte(c.version.major);
rval.putByte(c.version.minor);
rval.putBytes(c.session.sp.server_random);
writeVector(rval, 1, forge2.util.createBuffer(sessionId));
rval.putByte(c.session.cipherSuite.id[0]);
rval.putByte(c.session.cipherSuite.id[1]);
rval.putByte(c.session.compressionMethod);
return rval;
};
tls.createCertificate = function(c) {
var client = c.entity === tls.ConnectionEnd.client;
var cert = null;
if (c.getCertificate) {
var hint;
if (client) {
hint = c.session.certificateRequest;
} else {
hint = c.session.extensions.server_name.serverNameList;
}
cert = c.getCertificate(c, hint);
}
var certList = forge2.util.createBuffer();
if (cert !== null) {
try {
if (!forge2.util.isArray(cert)) {
cert = [cert];
}
var asn1 = null;
for (var i = 0; i < cert.length; ++i) {
var msg = forge2.pem.decode(cert[i])[0];
if (msg.type !== "CERTIFICATE" && msg.type !== "X509 CERTIFICATE" && msg.type !== "TRUSTED CERTIFICATE") {
var error = new Error('Could not convert certificate from PEM; PEM header type is not "CERTIFICATE", "X509 CERTIFICATE", or "TRUSTED CERTIFICATE".');
error.headerType = msg.type;
throw error;
}
if (msg.procType && msg.procType.type === "ENCRYPTED") {
throw new Error("Could not convert certificate from PEM; PEM is encrypted.");
}
var der = forge2.util.createBuffer(msg.body);
if (asn1 === null) {
asn1 = forge2.asn1.fromDer(der.bytes(), false);
}
var certBuffer = forge2.util.createBuffer();
writeVector(certBuffer, 3, der);
certList.putBuffer(certBuffer);
}
cert = forge2.pki.certificateFromAsn1(asn1);
if (client) {
c.session.clientCertificate = cert;
} else {
c.session.serverCertificate = cert;
}
} catch (ex) {
return c.error(c, {
message: "Could not send certificate list.",
cause: ex,
send: true,
alert: {
level: tls.Alert.Level.fatal,
description: tls.Alert.Description.bad_certificate
}
});
}
}
var length2 = 3 + certList.length();
var rval = forge2.util.createBuffer();
rval.putByte(tls.HandshakeType.certificate);
rval.putInt24(length2);
writeVector(rval, 3, certList);
return rval;
};
tls.createClientKeyExchange = function(c) {
var b = forge2.util.createBuffer();
b.putByte(c.session.clientHelloVersion.major);
b.putByte(c.session.clientHelloVersion.minor);
b.putBytes(forge2.random.getBytes(46));
var sp = c.session.sp;
sp.pre_master_secret = b.getBytes();
var key3 = c.session.serverCertificate.publicKey;
b = key3.encrypt(sp.pre_master_secret);
var length2 = b.length + 2;
var rval = forge2.util.createBuffer();
rval.putByte(tls.HandshakeType.client_key_exchange);
rval.putInt24(length2);
rval.putInt16(b.length);
rval.putBytes(b);
return rval;
};
tls.createServerKeyExchange = function(c) {
var length2 = 0;
var rval = forge2.util.createBuffer();
if (length2 > 0) {
rval.putByte(tls.HandshakeType.server_key_exchange);
rval.putInt24(length2);
}
return rval;
};
tls.getClientSignature = function(c, callback) {
var b = forge2.util.createBuffer();
b.putBuffer(c.session.md5.digest());
b.putBuffer(c.session.sha1.digest());
b = b.getBytes();
c.getSignature = c.getSignature || function(c2, b2, callback2) {
var privateKey = null;
if (c2.getPrivateKey) {
try {
privateKey = c2.getPrivateKey(c2, c2.session.clientCertificate);
privateKey = forge2.pki.privateKeyFromPem(privateKey);
} catch (ex) {
c2.error(c2, {
message: "Could not get private key.",
cause: ex,
send: true,
alert: {
level: tls.Alert.Level.fatal,
description: tls.Alert.Description.internal_error
}
});
}
}
if (privateKey === null) {
c2.error(c2, {
message: "No private key set.",
send: true,
alert: {
level: tls.Alert.Level.fatal,
description: tls.Alert.Description.internal_error
}
});
} else {
b2 = privateKey.sign(b2, null);
}
callback2(c2, b2);
};
c.getSignature(c, b, callback);
};
tls.createCertificateVerify = function(c, signature) {
var length2 = signature.length + 2;
var rval = forge2.util.createBuffer();
rval.putByte(tls.HandshakeType.certificate_verify);
rval.putInt24(length2);
rval.putInt16(signature.length);
rval.putBytes(signature);
return rval;
};
tls.createCertificateRequest = function(c) {
var certTypes = forge2.util.createBuffer();
certTypes.putByte(1);
var cAs = forge2.util.createBuffer();
for (var key3 in c.caStore.certs) {
var cert = c.caStore.certs[key3];
var dn = forge2.pki.distinguishedNameToAsn1(cert.subject);
var byteBuffer = forge2.asn1.toDer(dn);
cAs.putInt16(byteBuffer.length());
cAs.putBuffer(byteBuffer);
}
var length2 = 1 + certTypes.length() + 2 + cAs.length();
var rval = forge2.util.createBuffer();
rval.putByte(tls.HandshakeType.certificate_request);
rval.putInt24(length2);
writeVector(rval, 1, certTypes);
writeVector(rval, 2, cAs);
return rval;
};
tls.createServerHelloDone = function(c) {
var rval = forge2.util.createBuffer();
rval.putByte(tls.HandshakeType.server_hello_done);
rval.putInt24(0);
return rval;
};
tls.createChangeCipherSpec = function() {
var rval = forge2.util.createBuffer();
rval.putByte(1);
return rval;
};
tls.createFinished = function(c) {
var b = forge2.util.createBuffer();
b.putBuffer(c.session.md5.digest());
b.putBuffer(c.session.sha1.digest());
var client = c.entity === tls.ConnectionEnd.client;
var sp = c.session.sp;
var vdl = 12;
var prf = prf_TLS1;
var label = client ? "client finished" : "server finished";
b = prf(sp.master_secret, label, b.getBytes(), vdl);
var rval = forge2.util.createBuffer();
rval.putByte(tls.HandshakeType.finished);
rval.putInt24(b.length());
rval.putBuffer(b);
return rval;
};
tls.createHeartbeat = function(type, payload, payloadLength) {
if (typeof payloadLength === "undefined") {
payloadLength = payload.length;
}
var rval = forge2.util.createBuffer();
rval.putByte(type);
rval.putInt16(payloadLength);
rval.putBytes(payload);
var plaintextLength = rval.length();
var paddingLength = Math.max(16, plaintextLength - payloadLength - 3);
rval.putBytes(forge2.random.getBytes(paddingLength));
return rval;
};
tls.queue = function(c, record) {
if (!record) {
return;
}
if (record.fragment.length() === 0) {
if (record.type === tls.ContentType.handshake || record.type === tls.ContentType.alert || record.type === tls.ContentType.change_cipher_spec) {
return;
}
}
if (record.type === tls.ContentType.handshake) {
var bytes = record.fragment.bytes();
c.session.md5.update(bytes);
c.session.sha1.update(bytes);
bytes = null;
}
var records;
if (record.fragment.length() <= tls.MaxFragment) {
records = [record];
} else {
records = [];
var data2 = record.fragment.bytes();
while (data2.length > tls.MaxFragment) {
records.push(tls.createRecord(c, {
type: record.type,
data: forge2.util.createBuffer(data2.slice(0, tls.MaxFragment))
}));
data2 = data2.slice(tls.MaxFragment);
}
if (data2.length > 0) {
records.push(tls.createRecord(c, {
type: record.type,
data: forge2.util.createBuffer(data2)
}));
}
}
for (var i = 0; i < records.length && !c.fail; ++i) {
var rec = records[i];
var s = c.state.current.write;
if (s.update(c, rec)) {
c.records.push(rec);
}
}
};
tls.flush = function(c) {
for (var i = 0; i < c.records.length; ++i) {
var record = c.records[i];
c.tlsData.putByte(record.type);
c.tlsData.putByte(record.version.major);
c.tlsData.putByte(record.version.minor);
c.tlsData.putInt16(record.fragment.length());
c.tlsData.putBuffer(c.records[i].fragment);
}
c.records = [];
return c.tlsDataReady(c);
};
var _certErrorToAlertDesc = function(error) {
switch (error) {
case true:
return true;
case forge2.pki.certificateError.bad_certificate:
return tls.Alert.Description.bad_certificate;
case forge2.pki.certificateError.unsupported_certificate:
return tls.Alert.Description.unsupported_certificate;
case forge2.pki.certificateError.certificate_revoked:
return tls.Alert.Description.certificate_revoked;
case forge2.pki.certificateError.certificate_expired:
return tls.Alert.Description.certificate_expired;
case forge2.pki.certificateError.certificate_unknown:
return tls.Alert.Description.certificate_unknown;
case forge2.pki.certificateError.unknown_ca:
return tls.Alert.Description.unknown_ca;
default:
return tls.Alert.Description.bad_certificate;
}
};
var _alertDescToCertError = function(desc) {
switch (desc) {
case true:
return true;
case tls.Alert.Description.bad_certificate:
return forge2.pki.certificateError.bad_certificate;
case tls.Alert.Description.unsupported_certificate:
return forge2.pki.certificateError.unsupported_certificate;
case tls.Alert.Description.certificate_revoked:
return forge2.pki.certificateError.certificate_revoked;
case tls.Alert.Description.certificate_expired:
return forge2.pki.certificateError.certificate_expired;
case tls.Alert.Description.certificate_unknown:
return forge2.pki.certificateError.certificate_unknown;
case tls.Alert.Description.unknown_ca:
return forge2.pki.certificateError.unknown_ca;
default:
return forge2.pki.certificateError.bad_certificate;
}
};
tls.verifyCertificateChain = function(c, chain) {
try {
var options = {};
for (var key3 in c.verifyOptions) {
options[key3] = c.verifyOptions[key3];
}
options.verify = function(vfd, depth, chain2) {
var desc = _certErrorToAlertDesc(vfd);
var ret = c.verify(c, vfd, depth, chain2);
if (ret !== true) {
if (typeof ret === "object" && !forge2.util.isArray(ret)) {
var error = new Error("The application rejected the certificate.");
error.send = true;
error.alert = {
level: tls.Alert.Level.fatal,
description: tls.Alert.Description.bad_certificate
};
if (ret.message) {
error.message = ret.message;
}
if (ret.alert) {
error.alert.description = ret.alert;
}
throw error;
}
if (ret !== vfd) {
ret = _alertDescToCertError(ret);
}
}
return ret;
};
forge2.pki.verifyCertificateChain(c.caStore, chain, options);
} catch (ex) {
var err = ex;
if (typeof err !== "object" || forge2.util.isArray(err)) {
err = {
send: true,
alert: {
level: tls.Alert.Level.fatal,
description: _certErrorToAlertDesc(ex)
}
};
}
if (!("send" in err)) {
err.send = true;
}
if (!("alert" in err)) {
err.alert = {
level: tls.Alert.Level.fatal,
description: _certErrorToAlertDesc(err.error)
};
}
c.error(c, err);
}
return !c.fail;
};
tls.createSessionCache = function(cache, capacity) {
var rval = null;
if (cache && cache.getSession && cache.setSession && cache.order) {
rval = cache;
} else {
rval = {};
rval.cache = cache || {};
rval.capacity = Math.max(capacity || 100, 1);
rval.order = [];
for (var key3 in cache) {
if (rval.order.length <= capacity) {
rval.order.push(key3);
} else {
delete cache[key3];
}
}
rval.getSession = function(sessionId) {
var session = null;
var key4 = null;
if (sessionId) {
key4 = forge2.util.bytesToHex(sessionId);
} else if (rval.order.length > 0) {
key4 = rval.order[0];
}
if (key4 !== null && key4 in rval.cache) {
session = rval.cache[key4];
delete rval.cache[key4];
for (var i in rval.order) {
if (rval.order[i] === key4) {
rval.order.splice(i, 1);
break;
}
}
}
return session;
};
rval.setSession = function(sessionId, session) {
if (rval.order.length === rval.capacity) {
var key4 = rval.order.shift();
delete rval.cache[key4];
}
var key4 = forge2.util.bytesToHex(sessionId);
rval.order.push(key4);
rval.cache[key4] = session;
};
}
return rval;
};
tls.createConnection = function(options) {
var caStore = null;
if (options.caStore) {
if (forge2.util.isArray(options.caStore)) {
caStore = forge2.pki.createCaStore(options.caStore);
} else {
caStore = options.caStore;
}
} else {
caStore = forge2.pki.createCaStore();
}
var cipherSuites = options.cipherSuites || null;
if (cipherSuites === null) {
cipherSuites = [];
for (var key3 in tls.CipherSuites) {
cipherSuites.push(tls.CipherSuites[key3]);
}
}
var entity = options.server || false ? tls.ConnectionEnd.server : tls.ConnectionEnd.client;
var sessionCache = options.sessionCache ? tls.createSessionCache(options.sessionCache) : null;
var c = {
version: { major: tls.Version.major, minor: tls.Version.minor },
entity,
sessionId: options.sessionId,
caStore,
sessionCache,
cipherSuites,
connected: options.connected,
virtualHost: options.virtualHost || null,
verifyClient: options.verifyClient || false,
verify: options.verify || function(cn, vfd, dpth, cts) {
return vfd;
},
verifyOptions: options.verifyOptions || {},
getCertificate: options.getCertificate || null,
getPrivateKey: options.getPrivateKey || null,
getSignature: options.getSignature || null,
input: forge2.util.createBuffer(),
tlsData: forge2.util.createBuffer(),
data: forge2.util.createBuffer(),
tlsDataReady: options.tlsDataReady,
dataReady: options.dataReady,
heartbeatReceived: options.heartbeatReceived,
closed: options.closed,
error: function(c2, ex) {
ex.origin = ex.origin || (c2.entity === tls.ConnectionEnd.client ? "client" : "server");
if (ex.send) {
tls.queue(c2, tls.createAlert(c2, ex.alert));
tls.flush(c2);
}
var fatal = ex.fatal !== false;
if (fatal) {
c2.fail = true;
}
options.error(c2, ex);
if (fatal) {
c2.close(false);
}
},
deflate: options.deflate || null,
inflate: options.inflate || null
};
c.reset = function(clearFail) {
c.version = { major: tls.Version.major, minor: tls.Version.minor };
c.record = null;
c.session = null;
c.peerCertificate = null;
c.state = {
pending: null,
current: null
};
c.expect = c.entity === tls.ConnectionEnd.client ? SHE : CHE;
c.fragmented = null;
c.records = [];
c.open = false;
c.handshakes = 0;
c.handshaking = false;
c.isConnected = false;
c.fail = !(clearFail || typeof clearFail === "undefined");
c.input.clear();
c.tlsData.clear();
c.data.clear();
c.state.current = tls.createConnectionState(c);
};
c.reset();
var _update = function(c2, record) {
var aligned = record.type - tls.ContentType.change_cipher_spec;
var handlers = ctTable[c2.entity][c2.expect];
if (aligned in handlers) {
handlers[aligned](c2, record);
} else {
tls.handleUnexpected(c2, record);
}
};
var _readRecordHeader = function(c2) {
var rval = 0;
var b = c2.input;
var len = b.length();
if (len < 5) {
rval = 5 - len;
} else {
c2.record = {
type: b.getByte(),
version: {
major: b.getByte(),
minor: b.getByte()
},
length: b.getInt16(),
fragment: forge2.util.createBuffer(),
ready: false
};
var compatibleVersion = c2.record.version.major === c2.version.major;
if (compatibleVersion && c2.session && c2.session.version) {
compatibleVersion = c2.record.version.minor === c2.version.minor;
}
if (!compatibleVersion) {
c2.error(c2, {
message: "Incompatible TLS version.",
send: true,
alert: {
level: tls.Alert.Level.fatal,
description: tls.Alert.Description.protocol_version
}
});
}
}
return rval;
};
var _readRecord = function(c2) {
var rval = 0;
var b = c2.input;
var len = b.length();
if (len < c2.record.length) {
rval = c2.record.length - len;
} else {
c2.record.fragment.putBytes(b.getBytes(c2.record.length));
b.compact();
var s = c2.state.current.read;
if (s.update(c2, c2.record)) {
if (c2.fragmented !== null) {
if (c2.fragmented.type === c2.record.type) {
c2.fragmented.fragment.putBuffer(c2.record.fragment);
c2.record = c2.fragmented;
} else {
c2.error(c2, {
message: "Invalid fragmented record.",
send: true,
alert: {
level: tls.Alert.Level.fatal,
description: tls.Alert.Description.unexpected_message
}
});
}
}
c2.record.ready = true;
}
}
return rval;
};
c.handshake = function(sessionId) {
if (c.entity !== tls.ConnectionEnd.client) {
c.error(c, {
message: "Cannot initiate handshake as a server.",
fatal: false
});
} else if (c.handshaking) {
c.error(c, {
message: "Handshake already in progress.",
fatal: false
});
} else {
if (c.fail && !c.open && c.handshakes === 0) {
c.fail = false;
}
c.handshaking = true;
sessionId = sessionId || "";
var session = null;
if (sessionId.length > 0) {
if (c.sessionCache) {
session = c.sessionCache.getSession(sessionId);
}
if (session === null) {
sessionId = "";
}
}
if (sessionId.length === 0 && c.sessionCache) {
session = c.sessionCache.getSession();
if (session !== null) {
sessionId = session.id;
}
}
c.session = {
id: sessionId,
version: null,
cipherSuite: null,
compressionMethod: null,
serverCertificate: null,
certificateRequest: null,
clientCertificate: null,
sp: {},
md5: forge2.md.md5.create(),
sha1: forge2.md.sha1.create()
};
if (session) {
c.version = session.version;
c.session.sp = session.sp;
}
c.session.sp.client_random = tls.createRandom().getBytes();
c.open = true;
tls.queue(c, tls.createRecord(c, {
type: tls.ContentType.handshake,
data: tls.createClientHello(c)
}));
tls.flush(c);
}
};
c.process = function(data2) {
var rval = 0;
if (data2) {
c.input.putBytes(data2);
}
if (!c.fail) {
if (c.record !== null && c.record.ready && c.record.fragment.isEmpty()) {
c.record = null;
}
if (c.record === null) {
rval = _readRecordHeader(c);
}
if (!c.fail && c.record !== null && !c.record.ready) {
rval = _readRecord(c);
}
if (!c.fail && c.record !== null && c.record.ready) {
_update(c, c.record);
}
}
return rval;
};
c.prepare = function(data2) {
tls.queue(c, tls.createRecord(c, {
type: tls.ContentType.application_data,
data: forge2.util.createBuffer(data2)
}));
return tls.flush(c);
};
c.prepareHeartbeatRequest = function(payload, payloadLength) {
if (payload instanceof forge2.util.ByteBuffer) {
payload = payload.bytes();
}
if (typeof payloadLength === "undefined") {
payloadLength = payload.length;
}
c.expectedHeartbeatPayload = payload;
tls.queue(c, tls.createRecord(c, {
type: tls.ContentType.heartbeat,
data: tls.createHeartbeat(
tls.HeartbeatMessageType.heartbeat_request,
payload,
payloadLength
)
}));
return tls.flush(c);
};
c.close = function(clearFail) {
if (!c.fail && c.sessionCache && c.session) {
var session = {
id: c.session.id,
version: c.session.version,
sp: c.session.sp
};
session.sp.keys = null;
c.sessionCache.setSession(session.id, session);
}
if (c.open) {
c.open = false;
c.input.clear();
if (c.isConnected || c.handshaking) {
c.isConnected = c.handshaking = false;
tls.queue(c, tls.createAlert(c, {
level: tls.Alert.Level.warning,
description: tls.Alert.Description.close_notify
}));
tls.flush(c);
}
c.closed(c);
}
c.reset(clearFail);
};
return c;
};
module2.exports = forge2.tls = forge2.tls || {};
for (key2 in tls) {
if (typeof tls[key2] !== "function") {
forge2.tls[key2] = tls[key2];
}
}
var key2;
forge2.tls.prf_tls1 = prf_TLS1;
forge2.tls.hmac_sha1 = hmac_sha1;
forge2.tls.createSessionCache = tls.createSessionCache;
forge2.tls.createConnection = tls.createConnection;
}
});
// node_modules/node-forge/lib/aesCipherSuites.js
var require_aesCipherSuites = __commonJS({
"node_modules/node-forge/lib/aesCipherSuites.js"(exports2, module2) {
"use strict";
var forge2 = require_forge();
require_aes();
require_tls();
var tls = module2.exports = forge2.tls;
tls.CipherSuites["TLS_RSA_WITH_AES_128_CBC_SHA"] = {
id: [0, 47],
name: "TLS_RSA_WITH_AES_128_CBC_SHA",
initSecurityParameters: function(sp) {
sp.bulk_cipher_algorithm = tls.BulkCipherAlgorithm.aes;
sp.cipher_type = tls.CipherType.block;
sp.enc_key_length = 16;
sp.block_length = 16;
sp.fixed_iv_length = 16;
sp.record_iv_length = 16;
sp.mac_algorithm = tls.MACAlgorithm.hmac_sha1;
sp.mac_length = 20;
sp.mac_key_length = 20;
},
initConnectionState
};
tls.CipherSuites["TLS_RSA_WITH_AES_256_CBC_SHA"] = {
id: [0, 53],
name: "TLS_RSA_WITH_AES_256_CBC_SHA",
initSecurityParameters: function(sp) {
sp.bulk_cipher_algorithm = tls.BulkCipherAlgorithm.aes;
sp.cipher_type = tls.CipherType.block;
sp.enc_key_length = 32;
sp.block_length = 16;
sp.fixed_iv_length = 16;
sp.record_iv_length = 16;
sp.mac_algorithm = tls.MACAlgorithm.hmac_sha1;
sp.mac_length = 20;
sp.mac_key_length = 20;
},
initConnectionState
};
function initConnectionState(state, c, sp) {
var client = c.entity === forge2.tls.ConnectionEnd.client;
state.read.cipherState = {
init: false,
cipher: forge2.cipher.createDecipher("AES-CBC", client ? sp.keys.server_write_key : sp.keys.client_write_key),
iv: client ? sp.keys.server_write_IV : sp.keys.client_write_IV
};
state.write.cipherState = {
init: false,
cipher: forge2.cipher.createCipher("AES-CBC", client ? sp.keys.client_write_key : sp.keys.server_write_key),
iv: client ? sp.keys.client_write_IV : sp.keys.server_write_IV
};
state.read.cipherFunction = decrypt_aes_cbc_sha1;
state.write.cipherFunction = encrypt_aes_cbc_sha1;
state.read.macLength = state.write.macLength = sp.mac_length;
state.read.macFunction = state.write.macFunction = tls.hmac_sha1;
}
function encrypt_aes_cbc_sha1(record, s) {
var rval = false;
var mac = s.macFunction(s.macKey, s.sequenceNumber, record);
record.fragment.putBytes(mac);
s.updateSequenceNumber();
var iv;
if (record.version.minor === tls.Versions.TLS_1_0.minor) {
iv = s.cipherState.init ? null : s.cipherState.iv;
} else {
iv = forge2.random.getBytesSync(16);
}
s.cipherState.init = true;
var cipher = s.cipherState.cipher;
cipher.start({ iv });
if (record.version.minor >= tls.Versions.TLS_1_1.minor) {
cipher.output.putBytes(iv);
}
cipher.update(record.fragment);
if (cipher.finish(encrypt_aes_cbc_sha1_padding)) {
record.fragment = cipher.output;
record.length = record.fragment.length();
rval = true;
}
return rval;
}
function encrypt_aes_cbc_sha1_padding(blockSize, input2, decrypt) {
if (!decrypt) {
var padding = blockSize - input2.length() % blockSize;
input2.fillWithByte(padding - 1, padding);
}
return true;
}
function decrypt_aes_cbc_sha1_padding(blockSize, output, decrypt) {
var rval = true;
if (decrypt) {
var len = output.length();
var paddingLength = output.last();
for (var i = len - 1 - paddingLength; i < len - 1; ++i) {
rval = rval && output.at(i) == paddingLength;
}
if (rval) {
output.truncate(paddingLength + 1);
}
}
return rval;
}
function decrypt_aes_cbc_sha1(record, s) {
var rval = false;
var iv;
if (record.version.minor === tls.Versions.TLS_1_0.minor) {
iv = s.cipherState.init ? null : s.cipherState.iv;
} else {
iv = record.fragment.getBytes(16);
}
s.cipherState.init = true;
var cipher = s.cipherState.cipher;
cipher.start({ iv });
cipher.update(record.fragment);
rval = cipher.finish(decrypt_aes_cbc_sha1_padding);
var macLen = s.macLength;
var mac = forge2.random.getBytesSync(macLen);
var len = cipher.output.length();
if (len >= macLen) {
record.fragment = cipher.output.getBytes(len - macLen);
mac = cipher.output.getBytes(macLen);
} else {
record.fragment = cipher.output.getBytes();
}
record.fragment = forge2.util.createBuffer(record.fragment);
record.length = record.fragment.length();
var mac2 = s.macFunction(s.macKey, s.sequenceNumber, record);
s.updateSequenceNumber();
rval = compareMacs(s.macKey, mac, mac2) && rval;
return rval;
}
function compareMacs(key2, mac1, mac2) {
var hmac = forge2.hmac.create();
hmac.start("SHA1", key2);
hmac.update(mac1);
mac1 = hmac.digest().getBytes();
hmac.start(null, null);
hmac.update(mac2);
mac2 = hmac.digest().getBytes();
return mac1 === mac2;
}
}
});
// node_modules/node-forge/lib/sha512.js
var require_sha512 = __commonJS({
"node_modules/node-forge/lib/sha512.js"(exports2, module2) {
"use strict";
var forge2 = require_forge();
require_md();
require_util();
var sha512 = module2.exports = forge2.sha512 = forge2.sha512 || {};
forge2.md.sha512 = forge2.md.algorithms.sha512 = sha512;
var sha384 = forge2.sha384 = forge2.sha512.sha384 = forge2.sha512.sha384 || {};
sha384.create = function() {
return sha512.create("SHA-384");
};
forge2.md.sha384 = forge2.md.algorithms.sha384 = sha384;
forge2.sha512.sha256 = forge2.sha512.sha256 || {
create: function() {
return sha512.create("SHA-512/256");
}
};
forge2.md["sha512/256"] = forge2.md.algorithms["sha512/256"] = forge2.sha512.sha256;
forge2.sha512.sha224 = forge2.sha512.sha224 || {
create: function() {
return sha512.create("SHA-512/224");
}
};
forge2.md["sha512/224"] = forge2.md.algorithms["sha512/224"] = forge2.sha512.sha224;
sha512.create = function(algorithm) {
if (!_initialized) {
_init();
}
if (typeof algorithm === "undefined") {
algorithm = "SHA-512";
}
if (!(algorithm in _states)) {
throw new Error("Invalid SHA-512 algorithm: " + algorithm);
}
var _state = _states[algorithm];
var _h = null;
var _input = forge2.util.createBuffer();
var _w = new Array(80);
for (var wi = 0; wi < 80; ++wi) {
_w[wi] = new Array(2);
}
var digestLength = 64;
switch (algorithm) {
case "SHA-384":
digestLength = 48;
break;
case "SHA-512/256":
digestLength = 32;
break;
case "SHA-512/224":
digestLength = 28;
break;
}
var md = {
// SHA-512 => sha512
algorithm: algorithm.replace("-", "").toLowerCase(),
blockLength: 128,
digestLength,
// 56-bit length of message so far (does not including padding)
messageLength: 0,
// true message length
fullMessageLength: null,
// size of message length in bytes
messageLengthSize: 16
};
md.start = function() {
md.messageLength = 0;
md.fullMessageLength = md.messageLength128 = [];
var int32s = md.messageLengthSize / 4;
for (var i = 0; i < int32s; ++i) {
md.fullMessageLength.push(0);
}
_input = forge2.util.createBuffer();
_h = new Array(_state.length);
for (var i = 0; i < _state.length; ++i) {
_h[i] = _state[i].slice(0);
}
return md;
};
md.start();
md.update = function(msg, encoding) {
if (encoding === "utf8") {
msg = forge2.util.encodeUtf8(msg);
}
var len = msg.length;
md.messageLength += len;
len = [len / 4294967296 >>> 0, len >>> 0];
for (var i = md.fullMessageLength.length - 1; i >= 0; --i) {
md.fullMessageLength[i] += len[1];
len[1] = len[0] + (md.fullMessageLength[i] / 4294967296 >>> 0);
md.fullMessageLength[i] = md.fullMessageLength[i] >>> 0;
len[0] = len[1] / 4294967296 >>> 0;
}
_input.putBytes(msg);
_update(_h, _w, _input);
if (_input.read > 2048 || _input.length() === 0) {
_input.compact();
}
return md;
};
md.digest = function() {
var finalBlock = forge2.util.createBuffer();
finalBlock.putBytes(_input.bytes());
var remaining = md.fullMessageLength[md.fullMessageLength.length - 1] + md.messageLengthSize;
var overflow = remaining & md.blockLength - 1;
finalBlock.putBytes(_padding.substr(0, md.blockLength - overflow));
var next, carry;
var bits = md.fullMessageLength[0] * 8;
for (var i = 0; i < md.fullMessageLength.length - 1; ++i) {
next = md.fullMessageLength[i + 1] * 8;
carry = next / 4294967296 >>> 0;
bits += carry;
finalBlock.putInt32(bits >>> 0);
bits = next >>> 0;
}
finalBlock.putInt32(bits);
var h = new Array(_h.length);
for (var i = 0; i < _h.length; ++i) {
h[i] = _h[i].slice(0);
}
_update(h, _w, finalBlock);
var rval = forge2.util.createBuffer();
var hlen;
if (algorithm === "SHA-512") {
hlen = h.length;
} else if (algorithm === "SHA-384") {
hlen = h.length - 2;
} else {
hlen = h.length - 4;
}
for (var i = 0; i < hlen; ++i) {
rval.putInt32(h[i][0]);
if (i !== hlen - 1 || algorithm !== "SHA-512/224") {
rval.putInt32(h[i][1]);
}
}
return rval;
};
return md;
};
var _padding = null;
var _initialized = false;
var _k = null;
var _states = null;
function _init() {
_padding = String.fromCharCode(128);
_padding += forge2.util.fillString(String.fromCharCode(0), 128);
_k = [
[1116352408, 3609767458],
[1899447441, 602891725],
[3049323471, 3964484399],
[3921009573, 2173295548],
[961987163, 4081628472],
[1508970993, 3053834265],
[2453635748, 2937671579],
[2870763221, 3664609560],
[3624381080, 2734883394],
[310598401, 1164996542],
[607225278, 1323610764],
[1426881987, 3590304994],
[1925078388, 4068182383],
[2162078206, 991336113],
[2614888103, 633803317],
[3248222580, 3479774868],
[3835390401, 2666613458],
[4022224774, 944711139],
[264347078, 2341262773],
[604807628, 2007800933],
[770255983, 1495990901],
[1249150122, 1856431235],
[1555081692, 3175218132],
[1996064986, 2198950837],
[2554220882, 3999719339],
[2821834349, 766784016],
[2952996808, 2566594879],
[3210313671, 3203337956],
[3336571891, 1034457026],
[3584528711, 2466948901],
[113926993, 3758326383],
[338241895, 168717936],
[666307205, 1188179964],
[773529912, 1546045734],
[1294757372, 1522805485],
[1396182291, 2643833823],
[1695183700, 2343527390],
[1986661051, 1014477480],
[2177026350, 1206759142],
[2456956037, 344077627],
[2730485921, 1290863460],
[2820302411, 3158454273],
[3259730800, 3505952657],
[3345764771, 106217008],
[3516065817, 3606008344],
[3600352804, 1432725776],
[4094571909, 1467031594],
[275423344, 851169720],
[430227734, 3100823752],
[506948616, 1363258195],
[659060556, 3750685593],
[883997877, 3785050280],
[958139571, 3318307427],
[1322822218, 3812723403],
[1537002063, 2003034995],
[1747873779, 3602036899],
[1955562222, 1575990012],
[2024104815, 1125592928],
[2227730452, 2716904306],
[2361852424, 442776044],
[2428436474, 593698344],
[2756734187, 3733110249],
[3204031479, 2999351573],
[3329325298, 3815920427],
[3391569614, 3928383900],
[3515267271, 566280711],
[3940187606, 3454069534],
[4118630271, 4000239992],
[116418474, 1914138554],
[174292421, 2731055270],
[289380356, 3203993006],
[460393269, 320620315],
[685471733, 587496836],
[852142971, 1086792851],
[1017036298, 365543100],
[1126000580, 2618297676],
[1288033470, 3409855158],
[1501505948, 4234509866],
[1607167915, 987167468],
[1816402316, 1246189591]
];
_states = {};
_states["SHA-512"] = [
[1779033703, 4089235720],
[3144134277, 2227873595],
[1013904242, 4271175723],
[2773480762, 1595750129],
[1359893119, 2917565137],
[2600822924, 725511199],
[528734635, 4215389547],
[1541459225, 327033209]
];
_states["SHA-384"] = [
[3418070365, 3238371032],
[1654270250, 914150663],
[2438529370, 812702999],
[355462360, 4144912697],
[1731405415, 4290775857],
[2394180231, 1750603025],
[3675008525, 1694076839],
[1203062813, 3204075428]
];
_states["SHA-512/256"] = [
[573645204, 4230739756],
[2673172387, 3360449730],
[596883563, 1867755857],
[2520282905, 1497426621],
[2519219938, 2827943907],
[3193839141, 1401305490],
[721525244, 746961066],
[246885852, 2177182882]
];
_states["SHA-512/224"] = [
[2352822216, 424955298],
[1944164710, 2312950998],
[502970286, 855612546],
[1738396948, 1479516111],
[258812777, 2077511080],
[2011393907, 79989058],
[1067287976, 1780299464],
[286451373, 2446758561]
];
_initialized = true;
}
function _update(s, w, bytes) {
var t1_hi, t1_lo;
var t2_hi, t2_lo;
var s0_hi, s0_lo;
var s1_hi, s1_lo;
var ch_hi, ch_lo;
var maj_hi, maj_lo;
var a_hi, a_lo;
var b_hi, b_lo;
var c_hi, c_lo;
var d_hi, d_lo;
var e_hi, e_lo;
var f_hi, f_lo;
var g_hi, g_lo;
var h_hi, h_lo;
var i, hi, lo, w2, w7, w15, w16;
var len = bytes.length();
while (len >= 128) {
for (i = 0; i < 16; ++i) {
w[i][0] = bytes.getInt32() >>> 0;
w[i][1] = bytes.getInt32() >>> 0;
}
for (; i < 80; ++i) {
w2 = w[i - 2];
hi = w2[0];
lo = w2[1];
t1_hi = ((hi >>> 19 | lo << 13) ^ // ROTR 19
(lo >>> 29 | hi << 3) ^ // ROTR 61/(swap + ROTR 29)
hi >>> 6) >>> 0;
t1_lo = ((hi << 13 | lo >>> 19) ^ // ROTR 19
(lo << 3 | hi >>> 29) ^ // ROTR 61/(swap + ROTR 29)
(hi << 26 | lo >>> 6)) >>> 0;
w15 = w[i - 15];
hi = w15[0];
lo = w15[1];
t2_hi = ((hi >>> 1 | lo << 31) ^ // ROTR 1
(hi >>> 8 | lo << 24) ^ // ROTR 8
hi >>> 7) >>> 0;
t2_lo = ((hi << 31 | lo >>> 1) ^ // ROTR 1
(hi << 24 | lo >>> 8) ^ // ROTR 8
(hi << 25 | lo >>> 7)) >>> 0;
w7 = w[i - 7];
w16 = w[i - 16];
lo = t1_lo + w7[1] + t2_lo + w16[1];
w[i][0] = t1_hi + w7[0] + t2_hi + w16[0] + (lo / 4294967296 >>> 0) >>> 0;
w[i][1] = lo >>> 0;
}
a_hi = s[0][0];
a_lo = s[0][1];
b_hi = s[1][0];
b_lo = s[1][1];
c_hi = s[2][0];
c_lo = s[2][1];
d_hi = s[3][0];
d_lo = s[3][1];
e_hi = s[4][0];
e_lo = s[4][1];
f_hi = s[5][0];
f_lo = s[5][1];
g_hi = s[6][0];
g_lo = s[6][1];
h_hi = s[7][0];
h_lo = s[7][1];
for (i = 0; i < 80; ++i) {
s1_hi = ((e_hi >>> 14 | e_lo << 18) ^ // ROTR 14
(e_hi >>> 18 | e_lo << 14) ^ // ROTR 18
(e_lo >>> 9 | e_hi << 23)) >>> 0;
s1_lo = ((e_hi << 18 | e_lo >>> 14) ^ // ROTR 14
(e_hi << 14 | e_lo >>> 18) ^ // ROTR 18
(e_lo << 23 | e_hi >>> 9)) >>> 0;
ch_hi = (g_hi ^ e_hi & (f_hi ^ g_hi)) >>> 0;
ch_lo = (g_lo ^ e_lo & (f_lo ^ g_lo)) >>> 0;
s0_hi = ((a_hi >>> 28 | a_lo << 4) ^ // ROTR 28
(a_lo >>> 2 | a_hi << 30) ^ // ROTR 34/(swap + ROTR 2)
(a_lo >>> 7 | a_hi << 25)) >>> 0;
s0_lo = ((a_hi << 4 | a_lo >>> 28) ^ // ROTR 28
(a_lo << 30 | a_hi >>> 2) ^ // ROTR 34/(swap + ROTR 2)
(a_lo << 25 | a_hi >>> 7)) >>> 0;
maj_hi = (a_hi & b_hi | c_hi & (a_hi ^ b_hi)) >>> 0;
maj_lo = (a_lo & b_lo | c_lo & (a_lo ^ b_lo)) >>> 0;
lo = h_lo + s1_lo + ch_lo + _k[i][1] + w[i][1];
t1_hi = h_hi + s1_hi + ch_hi + _k[i][0] + w[i][0] + (lo / 4294967296 >>> 0) >>> 0;
t1_lo = lo >>> 0;
lo = s0_lo + maj_lo;
t2_hi = s0_hi + maj_hi + (lo / 4294967296 >>> 0) >>> 0;
t2_lo = lo >>> 0;
h_hi = g_hi;
h_lo = g_lo;
g_hi = f_hi;
g_lo = f_lo;
f_hi = e_hi;
f_lo = e_lo;
lo = d_lo + t1_lo;
e_hi = d_hi + t1_hi + (lo / 4294967296 >>> 0) >>> 0;
e_lo = lo >>> 0;
d_hi = c_hi;
d_lo = c_lo;
c_hi = b_hi;
c_lo = b_lo;
b_hi = a_hi;
b_lo = a_lo;
lo = t1_lo + t2_lo;
a_hi = t1_hi + t2_hi + (lo / 4294967296 >>> 0) >>> 0;
a_lo = lo >>> 0;
}
lo = s[0][1] + a_lo;
s[0][0] = s[0][0] + a_hi + (lo / 4294967296 >>> 0) >>> 0;
s[0][1] = lo >>> 0;
lo = s[1][1] + b_lo;
s[1][0] = s[1][0] + b_hi + (lo / 4294967296 >>> 0) >>> 0;
s[1][1] = lo >>> 0;
lo = s[2][1] + c_lo;
s[2][0] = s[2][0] + c_hi + (lo / 4294967296 >>> 0) >>> 0;
s[2][1] = lo >>> 0;
lo = s[3][1] + d_lo;
s[3][0] = s[3][0] + d_hi + (lo / 4294967296 >>> 0) >>> 0;
s[3][1] = lo >>> 0;
lo = s[4][1] + e_lo;
s[4][0] = s[4][0] + e_hi + (lo / 4294967296 >>> 0) >>> 0;
s[4][1] = lo >>> 0;
lo = s[5][1] + f_lo;
s[5][0] = s[5][0] + f_hi + (lo / 4294967296 >>> 0) >>> 0;
s[5][1] = lo >>> 0;
lo = s[6][1] + g_lo;
s[6][0] = s[6][0] + g_hi + (lo / 4294967296 >>> 0) >>> 0;
s[6][1] = lo >>> 0;
lo = s[7][1] + h_lo;
s[7][0] = s[7][0] + h_hi + (lo / 4294967296 >>> 0) >>> 0;
s[7][1] = lo >>> 0;
len -= 128;
}
}
}
});
// node_modules/node-forge/lib/asn1-validator.js
var require_asn1_validator = __commonJS({
"node_modules/node-forge/lib/asn1-validator.js"(exports2) {
"use strict";
var forge2 = require_forge();
require_asn1();
var asn1 = forge2.asn1;
exports2.privateKeyValidator = {
// PrivateKeyInfo
name: "PrivateKeyInfo",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.SEQUENCE,
constructed: true,
value: [{
// Version (INTEGER)
name: "PrivateKeyInfo.version",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.INTEGER,
constructed: false,
capture: "privateKeyVersion"
}, {
// privateKeyAlgorithm
name: "PrivateKeyInfo.privateKeyAlgorithm",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.SEQUENCE,
constructed: true,
value: [{
name: "AlgorithmIdentifier.algorithm",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.OID,
constructed: false,
capture: "privateKeyOid"
}]
}, {
// PrivateKey
name: "PrivateKeyInfo",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.OCTETSTRING,
constructed: false,
capture: "privateKey"
}]
};
exports2.publicKeyValidator = {
name: "SubjectPublicKeyInfo",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.SEQUENCE,
constructed: true,
captureAsn1: "subjectPublicKeyInfo",
value: [
{
name: "SubjectPublicKeyInfo.AlgorithmIdentifier",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.SEQUENCE,
constructed: true,
value: [{
name: "AlgorithmIdentifier.algorithm",
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.OID,
constructed: false,
capture: "publicKeyOid"
}]
},
// capture group for ed25519PublicKey
{
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.BITSTRING,
constructed: false,
composed: true,
captureBitStringValue: "ed25519PublicKey"
}
// FIXME: this is capture group for rsaPublicKey, use it in this API or
// discard?
/* {
// subjectPublicKey
name: 'SubjectPublicKeyInfo.subjectPublicKey',
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.BITSTRING,
constructed: false,
value: [{
// RSAPublicKey
name: 'SubjectPublicKeyInfo.subjectPublicKey.RSAPublicKey',
tagClass: asn1.Class.UNIVERSAL,
type: asn1.Type.SEQUENCE,
constructed: true,
optional: true,
captureAsn1: 'rsaPublicKey'
}]
} */
]
};
}
});
// node_modules/node-forge/lib/ed25519.js
var require_ed25519 = __commonJS({
"node_modules/node-forge/lib/ed25519.js"(exports2, module2) {
"use strict";
var forge2 = require_forge();
require_jsbn();
require_random();
require_sha512();
require_util();
var asn1Validator = require_asn1_validator();
var publicKeyValidator = asn1Validator.publicKeyValidator;
var privateKeyValidator = asn1Validator.privateKeyValidator;
if (typeof BigInteger === "undefined") {
BigInteger = forge2.jsbn.BigInteger;
}
var BigInteger;
var ByteBuffer = forge2.util.ByteBuffer;
var NativeBuffer = typeof Buffer === "undefined" ? Uint8Array : Buffer;
forge2.pki = forge2.pki || {};
module2.exports = forge2.pki.ed25519 = forge2.ed25519 = forge2.ed25519 || {};
var ed25519 = forge2.ed25519;
ed25519.constants = {};
ed25519.constants.PUBLIC_KEY_BYTE_LENGTH = 32;
ed25519.constants.PRIVATE_KEY_BYTE_LENGTH = 64;
ed25519.constants.SEED_BYTE_LENGTH = 32;
ed25519.constants.SIGN_BYTE_LENGTH = 64;
ed25519.constants.HASH_BYTE_LENGTH = 64;
ed25519.generateKeyPair = function(options) {
options = options || {};
var seed = options.seed;
if (seed === void 0) {
seed = forge2.random.getBytesSync(ed25519.constants.SEED_BYTE_LENGTH);
} else if (typeof seed === "string") {
if (seed.length !== ed25519.constants.SEED_BYTE_LENGTH) {
throw new TypeError(
'"seed" must be ' + ed25519.constants.SEED_BYTE_LENGTH + " bytes in length."
);
}
} else if (!(seed instanceof Uint8Array)) {
throw new TypeError(
'"seed" must be a node.js Buffer, Uint8Array, or a binary string.'
);
}
seed = messageToNativeBuffer({ message: seed, encoding: "binary" });
var pk = new NativeBuffer(ed25519.constants.PUBLIC_KEY_BYTE_LENGTH);
var sk = new NativeBuffer(ed25519.constants.PRIVATE_KEY_BYTE_LENGTH);
for (var i = 0; i < 32; ++i) {
sk[i] = seed[i];
}
crypto_sign_keypair(pk, sk);
return { publicKey: pk, privateKey: sk };
};
ed25519.privateKeyFromAsn1 = function(obj) {
var capture = {};
var errors = [];
var valid = forge2.asn1.validate(obj, privateKeyValidator, capture, errors);
if (!valid) {
var error = new Error("Invalid Key.");
error.errors = errors;
throw error;
}
var oid = forge2.asn1.derToOid(capture.privateKeyOid);
var ed25519Oid = forge2.oids.EdDSA25519;
if (oid !== ed25519Oid) {
throw new Error('Invalid OID "' + oid + '"; OID must be "' + ed25519Oid + '".');
}
var privateKey = capture.privateKey;
var privateKeyBytes = messageToNativeBuffer({
message: forge2.asn1.fromDer(privateKey).value,
encoding: "binary"
});
return { privateKeyBytes };
};
ed25519.publicKeyFromAsn1 = function(obj) {
var capture = {};
var errors = [];
var valid = forge2.asn1.validate(obj, publicKeyValidator, capture, errors);
if (!valid) {
var error = new Error("Invalid Key.");
error.errors = errors;
throw error;
}
var oid = forge2.asn1.derToOid(capture.publicKeyOid);
var ed25519Oid = forge2.oids.EdDSA25519;
if (oid !== ed25519Oid) {
throw new Error('Invalid OID "' + oid + '"; OID must be "' + ed25519Oid + '".');
}
var publicKeyBytes = capture.ed25519PublicKey;
if (publicKeyBytes.length !== ed25519.constants.PUBLIC_KEY_BYTE_LENGTH) {
throw new Error("Key length is invalid.");
}
return messageToNativeBuffer({
message: publicKeyBytes,
encoding: "binary"
});
};
ed25519.publicKeyFromPrivateKey = function(options) {
options = options || {};
var privateKey = messageToNativeBuffer({
message: options.privateKey,
encoding: "binary"
});
if (privateKey.length !== ed25519.constants.PRIVATE_KEY_BYTE_LENGTH) {
throw new TypeError(
'"options.privateKey" must have a byte length of ' + ed25519.constants.PRIVATE_KEY_BYTE_LENGTH
);
}
var pk = new NativeBuffer(ed25519.constants.PUBLIC_KEY_BYTE_LENGTH);
for (var i = 0; i < pk.length; ++i) {
pk[i] = privateKey[32 + i];
}
return pk;
};
ed25519.sign = function(options) {
options = options || {};
var msg = messageToNativeBuffer(options);
var privateKey = messageToNativeBuffer({
message: options.privateKey,
encoding: "binary"
});
if (privateKey.length === ed25519.constants.SEED_BYTE_LENGTH) {
var keyPair = ed25519.generateKeyPair({ seed: privateKey });
privateKey = keyPair.privateKey;
} else if (privateKey.length !== ed25519.constants.PRIVATE_KEY_BYTE_LENGTH) {
throw new TypeError(
'"options.privateKey" must have a byte length of ' + ed25519.constants.SEED_BYTE_LENGTH + " or " + ed25519.constants.PRIVATE_KEY_BYTE_LENGTH
);
}
var signedMsg = new NativeBuffer(
ed25519.constants.SIGN_BYTE_LENGTH + msg.length
);
crypto_sign(signedMsg, msg, msg.length, privateKey);
var sig = new NativeBuffer(ed25519.constants.SIGN_BYTE_LENGTH);
for (var i = 0; i < sig.length; ++i) {
sig[i] = signedMsg[i];
}
return sig;
};
ed25519.verify = function(options) {
options = options || {};
var msg = messageToNativeBuffer(options);
if (options.signature === void 0) {
throw new TypeError(
'"options.signature" must be a node.js Buffer, a Uint8Array, a forge ByteBuffer, or a binary string.'
);
}
var sig = messageToNativeBuffer({
message: options.signature,
encoding: "binary"
});
if (sig.length !== ed25519.constants.SIGN_BYTE_LENGTH) {
throw new TypeError(
'"options.signature" must have a byte length of ' + ed25519.constants.SIGN_BYTE_LENGTH
);
}
var publicKey = messageToNativeBuffer({
message: options.publicKey,
encoding: "binary"
});
if (publicKey.length !== ed25519.constants.PUBLIC_KEY_BYTE_LENGTH) {
throw new TypeError(
'"options.publicKey" must have a byte length of ' + ed25519.constants.PUBLIC_KEY_BYTE_LENGTH
);
}
var sm = new NativeBuffer(ed25519.constants.SIGN_BYTE_LENGTH + msg.length);
var m = new NativeBuffer(ed25519.constants.SIGN_BYTE_LENGTH + msg.length);
var i;
for (i = 0; i < ed25519.constants.SIGN_BYTE_LENGTH; ++i) {
sm[i] = sig[i];
}
for (i = 0; i < msg.length; ++i) {
sm[i + ed25519.constants.SIGN_BYTE_LENGTH] = msg[i];
}
return crypto_sign_open(m, sm, sm.length, publicKey) >= 0;
};
function messageToNativeBuffer(options) {
var message = options.message;
if (message instanceof Uint8Array || message instanceof NativeBuffer) {
return message;
}
var encoding = options.encoding;
if (message === void 0) {
if (options.md) {
message = options.md.digest().getBytes();
encoding = "binary";
} else {
throw new TypeError('"options.message" or "options.md" not specified.');
}
}
if (typeof message === "string" && !encoding) {
throw new TypeError('"options.encoding" must be "binary" or "utf8".');
}
if (typeof message === "string") {
if (typeof Buffer !== "undefined") {
return Buffer.from(message, encoding);
}
message = new ByteBuffer(message, encoding);
} else if (!(message instanceof ByteBuffer)) {
throw new TypeError(
'"options.message" must be a node.js Buffer, a Uint8Array, a forge ByteBuffer, or a string with "options.encoding" specifying its encoding.'
);
}
var buffer = new NativeBuffer(message.length());
for (var i = 0; i < buffer.length; ++i) {
buffer[i] = message.at(i);
}
return buffer;
}
var gf0 = gf();
var gf1 = gf([1]);
var D = gf([
30883,
4953,
19914,
30187,
55467,
16705,
2637,
112,
59544,
30585,
16505,
36039,
65139,
11119,
27886,
20995
]);
var D2 = gf([
61785,
9906,
39828,
60374,
45398,
33411,
5274,
224,
53552,
61171,
33010,
6542,
64743,
22239,
55772,
9222
]);
var X = gf([
54554,
36645,
11616,
51542,
42930,
38181,
51040,
26924,
56412,
64982,
57905,
49316,
21502,
52590,
14035,
8553
]);
var Y = gf([
26200,
26214,
26214,
26214,
26214,
26214,
26214,
26214,
26214,
26214,
26214,
26214,
26214,
26214,
26214,
26214
]);
var L = new Float64Array([
237,
211,
245,
92,
26,
99,
18,
88,
214,
156,
247,
162,
222,
249,
222,
20,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
16
]);
var I = gf([
41136,
18958,
6951,
50414,
58488,
44335,
6150,
12099,
55207,
15867,
153,
11085,
57099,
20417,
9344,
11139
]);
function sha512(msg, msgLen) {
var md = forge2.md.sha512.create();
var buffer = new ByteBuffer(msg);
md.update(buffer.getBytes(msgLen), "binary");
var hash = md.digest().getBytes();
if (typeof Buffer !== "undefined") {
return Buffer.from(hash, "binary");
}
var out = new NativeBuffer(ed25519.constants.HASH_BYTE_LENGTH);
for (var i = 0; i < 64; ++i) {
out[i] = hash.charCodeAt(i);
}
return out;
}
function crypto_sign_keypair(pk, sk) {
var p = [gf(), gf(), gf(), gf()];
var i;
var d = sha512(sk, 32);
d[0] &= 248;
d[31] &= 127;
d[31] |= 64;
scalarbase(p, d);
pack(pk, p);
for (i = 0; i < 32; ++i) {
sk[i + 32] = pk[i];
}
return 0;
}
function crypto_sign(sm, m, n, sk) {
var i, j, x = new Float64Array(64);
var p = [gf(), gf(), gf(), gf()];
var d = sha512(sk, 32);
d[0] &= 248;
d[31] &= 127;
d[31] |= 64;
var smlen = n + 64;
for (i = 0; i < n; ++i) {
sm[64 + i] = m[i];
}
for (i = 0; i < 32; ++i) {
sm[32 + i] = d[32 + i];
}
var r = sha512(sm.subarray(32), n + 32);
reduce(r);
scalarbase(p, r);
pack(sm, p);
for (i = 32; i < 64; ++i) {
sm[i] = sk[i];
}
var h = sha512(sm, n + 64);
reduce(h);
for (i = 32; i < 64; ++i) {
x[i] = 0;
}
for (i = 0; i < 32; ++i) {
x[i] = r[i];
}
for (i = 0; i < 32; ++i) {
for (j = 0; j < 32; j++) {
x[i + j] += h[i] * d[j];
}
}
modL(sm.subarray(32), x);
return smlen;
}
function crypto_sign_open(m, sm, n, pk) {
var i, mlen;
var t = new NativeBuffer(32);
var p = [gf(), gf(), gf(), gf()], q = [gf(), gf(), gf(), gf()];
mlen = -1;
if (n < 64) {
return -1;
}
if (unpackneg(q, pk)) {
return -1;
}
for (i = 0; i < n; ++i) {
m[i] = sm[i];
}
for (i = 0; i < 32; ++i) {
m[i + 32] = pk[i];
}
var h = sha512(m, n);
reduce(h);
scalarmult(p, q, h);
scalarbase(q, sm.subarray(32));
add2(p, q);
pack(t, p);
n -= 64;
if (crypto_verify_32(sm, 0, t, 0)) {
for (i = 0; i < n; ++i) {
m[i] = 0;
}
return -1;
}
for (i = 0; i < n; ++i) {
m[i] = sm[i + 64];
}
mlen = n;
return mlen;
}
function modL(r, x) {
var carry, i, j, k;
for (i = 63; i >= 32; --i) {
carry = 0;
for (j = i - 32, k = i - 12; j < k; ++j) {
x[j] += carry - 16 * x[i] * L[j - (i - 32)];
carry = x[j] + 128 >> 8;
x[j] -= carry * 256;
}
x[j] += carry;
x[i] = 0;
}
carry = 0;
for (j = 0; j < 32; ++j) {
x[j] += carry - (x[31] >> 4) * L[j];
carry = x[j] >> 8;
x[j] &= 255;
}
for (j = 0; j < 32; ++j) {
x[j] -= carry * L[j];
}
for (i = 0; i < 32; ++i) {
x[i + 1] += x[i] >> 8;
r[i] = x[i] & 255;
}
}
function reduce(r) {
var x = new Float64Array(64);
for (var i = 0; i < 64; ++i) {
x[i] = r[i];
r[i] = 0;
}
modL(r, x);
}
function add2(p, q) {
var a = gf(), b = gf(), c = gf(), d = gf(), e = gf(), f = gf(), g = gf(), h = gf(), t = gf();
Z(a, p[1], p[0]);
Z(t, q[1], q[0]);
M(a, a, t);
A(b, p[0], p[1]);
A(t, q[0], q[1]);
M(b, b, t);
M(c, p[3], q[3]);
M(c, c, D2);
M(d, p[2], q[2]);
A(d, d, d);
Z(e, b, a);
Z(f, d, c);
A(g, d, c);
A(h, b, a);
M(p[0], e, f);
M(p[1], h, g);
M(p[2], g, f);
M(p[3], e, h);
}
function cswap(p, q, b) {
for (var i = 0; i < 4; ++i) {
sel25519(p[i], q[i], b);
}
}
function pack(r, p) {
var tx = gf(), ty = gf(), zi = gf();
inv25519(zi, p[2]);
M(tx, p[0], zi);
M(ty, p[1], zi);
pack25519(r, ty);
r[31] ^= par25519(tx) << 7;
}
function pack25519(o, n) {
var i, j, b;
var m = gf(), t = gf();
for (i = 0; i < 16; ++i) {
t[i] = n[i];
}
car25519(t);
car25519(t);
car25519(t);
for (j = 0; j < 2; ++j) {
m[0] = t[0] - 65517;
for (i = 1; i < 15; ++i) {
m[i] = t[i] - 65535 - (m[i - 1] >> 16 & 1);
m[i - 1] &= 65535;
}
m[15] = t[15] - 32767 - (m[14] >> 16 & 1);
b = m[15] >> 16 & 1;
m[14] &= 65535;
sel25519(t, m, 1 - b);
}
for (i = 0; i < 16; i++) {
o[2 * i] = t[i] & 255;
o[2 * i + 1] = t[i] >> 8;
}
}
function unpackneg(r, p) {
var t = gf(), chk = gf(), num = gf(), den = gf(), den2 = gf(), den4 = gf(), den6 = gf();
set25519(r[2], gf1);
unpack25519(r[1], p);
S(num, r[1]);
M(den, num, D);
Z(num, num, r[2]);
A(den, r[2], den);
S(den2, den);
S(den4, den2);
M(den6, den4, den2);
M(t, den6, num);
M(t, t, den);
pow2523(t, t);
M(t, t, num);
M(t, t, den);
M(t, t, den);
M(r[0], t, den);
S(chk, r[0]);
M(chk, chk, den);
if (neq25519(chk, num)) {
M(r[0], r[0], I);
}
S(chk, r[0]);
M(chk, chk, den);
if (neq25519(chk, num)) {
return -1;
}
if (par25519(r[0]) === p[31] >> 7) {
Z(r[0], gf0, r[0]);
}
M(r[3], r[0], r[1]);
return 0;
}
function unpack25519(o, n) {
var i;
for (i = 0; i < 16; ++i) {
o[i] = n[2 * i] + (n[2 * i + 1] << 8);
}
o[15] &= 32767;
}
function pow2523(o, i) {
var c = gf();
var a;
for (a = 0; a < 16; ++a) {
c[a] = i[a];
}
for (a = 250; a >= 0; --a) {
S(c, c);
if (a !== 1) {
M(c, c, i);
}
}
for (a = 0; a < 16; ++a) {
o[a] = c[a];
}
}
function neq25519(a, b) {
var c = new NativeBuffer(32);
var d = new NativeBuffer(32);
pack25519(c, a);
pack25519(d, b);
return crypto_verify_32(c, 0, d, 0);
}
function crypto_verify_32(x, xi, y, yi) {
return vn(x, xi, y, yi, 32);
}
function vn(x, xi, y, yi, n) {
var i, d = 0;
for (i = 0; i < n; ++i) {
d |= x[xi + i] ^ y[yi + i];
}
return (1 & d - 1 >>> 8) - 1;
}
function par25519(a) {
var d = new NativeBuffer(32);
pack25519(d, a);
return d[0] & 1;
}
function scalarmult(p, q, s) {
var b, i;
set25519(p[0], gf0);
set25519(p[1], gf1);
set25519(p[2], gf1);
set25519(p[3], gf0);
for (i = 255; i >= 0; --i) {
b = s[i / 8 | 0] >> (i & 7) & 1;
cswap(p, q, b);
add2(q, p);
add2(p, p);
cswap(p, q, b);
}
}
function scalarbase(p, s) {
var q = [gf(), gf(), gf(), gf()];
set25519(q[0], X);
set25519(q[1], Y);
set25519(q[2], gf1);
M(q[3], X, Y);
scalarmult(p, q, s);
}
function set25519(r, a) {
var i;
for (i = 0; i < 16; i++) {
r[i] = a[i] | 0;
}
}
function inv25519(o, i) {
var c = gf();
var a;
for (a = 0; a < 16; ++a) {
c[a] = i[a];
}
for (a = 253; a >= 0; --a) {
S(c, c);
if (a !== 2 && a !== 4) {
M(c, c, i);
}
}
for (a = 0; a < 16; ++a) {
o[a] = c[a];
}
}
function car25519(o) {
var i, v, c = 1;
for (i = 0; i < 16; ++i) {
v = o[i] + c + 65535;
c = Math.floor(v / 65536);
o[i] = v - c * 65536;
}
o[0] += c - 1 + 37 * (c - 1);
}
function sel25519(p, q, b) {
var t, c = ~(b - 1);
for (var i = 0; i < 16; ++i) {
t = c & (p[i] ^ q[i]);
p[i] ^= t;
q[i] ^= t;
}
}
function gf(init) {
var i, r = new Float64Array(16);
if (init) {
for (i = 0; i < init.length; ++i) {
r[i] = init[i];
}
}
return r;
}
function A(o, a, b) {
for (var i = 0; i < 16; ++i) {
o[i] = a[i] + b[i];
}
}
function Z(o, a, b) {
for (var i = 0; i < 16; ++i) {
o[i] = a[i] - b[i];
}
}
function S(o, a) {
M(o, a, a);
}
function M(o, a, b) {
var v, c, t0 = 0, t1 = 0, t2 = 0, t3 = 0, t4 = 0, t5 = 0, t6 = 0, t7 = 0, t8 = 0, t9 = 0, t10 = 0, t11 = 0, t12 = 0, t13 = 0, t14 = 0, t15 = 0, t16 = 0, t17 = 0, t18 = 0, t19 = 0, t20 = 0, t21 = 0, t22 = 0, t23 = 0, t24 = 0, t25 = 0, t26 = 0, t27 = 0, t28 = 0, t29 = 0, t30 = 0, b0 = b[0], b1 = b[1], b2 = b[2], b3 = b[3], b4 = b[4], b5 = b[5], b6 = b[6], b7 = b[7], b8 = b[8], b9 = b[9], b10 = b[10], b11 = b[11], b12 = b[12], b13 = b[13], b14 = b[14], b15 = b[15];
v = a[0];
t0 += v * b0;
t1 += v * b1;
t2 += v * b2;
t3 += v * b3;
t4 += v * b4;
t5 += v * b5;
t6 += v * b6;
t7 += v * b7;
t8 += v * b8;
t9 += v * b9;
t10 += v * b10;
t11 += v * b11;
t12 += v * b12;
t13 += v * b13;
t14 += v * b14;
t15 += v * b15;
v = a[1];
t1 += v * b0;
t2 += v * b1;
t3 += v * b2;
t4 += v * b3;
t5 += v * b4;
t6 += v * b5;
t7 += v * b6;
t8 += v * b7;
t9 += v * b8;
t10 += v * b9;
t11 += v * b10;
t12 += v * b11;
t13 += v * b12;
t14 += v * b13;
t15 += v * b14;
t16 += v * b15;
v = a[2];
t2 += v * b0;
t3 += v * b1;
t4 += v * b2;
t5 += v * b3;
t6 += v * b4;
t7 += v * b5;
t8 += v * b6;
t9 += v * b7;
t10 += v * b8;
t11 += v * b9;
t12 += v * b10;
t13 += v * b11;
t14 += v * b12;
t15 += v * b13;
t16 += v * b14;
t17 += v * b15;
v = a[3];
t3 += v * b0;
t4 += v * b1;
t5 += v * b2;
t6 += v * b3;
t7 += v * b4;
t8 += v * b5;
t9 += v * b6;
t10 += v * b7;
t11 += v * b8;
t12 += v * b9;
t13 += v * b10;
t14 += v * b11;
t15 += v * b12;
t16 += v * b13;
t17 += v * b14;
t18 += v * b15;
v = a[4];
t4 += v * b0;
t5 += v * b1;
t6 += v * b2;
t7 += v * b3;
t8 += v * b4;
t9 += v * b5;
t10 += v * b6;
t11 += v * b7;
t12 += v * b8;
t13 += v * b9;
t14 += v * b10;
t15 += v * b11;
t16 += v * b12;
t17 += v * b13;
t18 += v * b14;
t19 += v * b15;
v = a[5];
t5 += v * b0;
t6 += v * b1;
t7 += v * b2;
t8 += v * b3;
t9 += v * b4;
t10 += v * b5;
t11 += v * b6;
t12 += v * b7;
t13 += v * b8;
t14 += v * b9;
t15 += v * b10;
t16 += v * b11;
t17 += v * b12;
t18 += v * b13;
t19 += v * b14;
t20 += v * b15;
v = a[6];
t6 += v * b0;
t7 += v * b1;
t8 += v * b2;
t9 += v * b3;
t10 += v * b4;
t11 += v * b5;
t12 += v * b6;
t13 += v * b7;
t14 += v * b8;
t15 += v * b9;
t16 += v * b10;
t17 += v * b11;
t18 += v * b12;
t19 += v * b13;
t20 += v * b14;
t21 += v * b15;
v = a[7];
t7 += v * b0;
t8 += v * b1;
t9 += v * b2;
t10 += v * b3;
t11 += v * b4;
t12 += v * b5;
t13 += v * b6;
t14 += v * b7;
t15 += v * b8;
t16 += v * b9;
t17 += v * b10;
t18 += v * b11;
t19 += v * b12;
t20 += v * b13;
t21 += v * b14;
t22 += v * b15;
v = a[8];
t8 += v * b0;
t9 += v * b1;
t10 += v * b2;
t11 += v * b3;
t12 += v * b4;
t13 += v * b5;
t14 += v * b6;
t15 += v * b7;
t16 += v * b8;
t17 += v * b9;
t18 += v * b10;
t19 += v * b11;
t20 += v * b12;
t21 += v * b13;
t22 += v * b14;
t23 += v * b15;
v = a[9];
t9 += v * b0;
t10 += v * b1;
t11 += v * b2;
t12 += v * b3;
t13 += v * b4;
t14 += v * b5;
t15 += v * b6;
t16 += v * b7;
t17 += v * b8;
t18 += v * b9;
t19 += v * b10;
t20 += v * b11;
t21 += v * b12;
t22 += v * b13;
t23 += v * b14;
t24 += v * b15;
v = a[10];
t10 += v * b0;
t11 += v * b1;
t12 += v * b2;
t13 += v * b3;
t14 += v * b4;
t15 += v * b5;
t16 += v * b6;
t17 += v * b7;
t18 += v * b8;
t19 += v * b9;
t20 += v * b10;
t21 += v * b11;
t22 += v * b12;
t23 += v * b13;
t24 += v * b14;
t25 += v * b15;
v = a[11];
t11 += v * b0;
t12 += v * b1;
t13 += v * b2;
t14 += v * b3;
t15 += v * b4;
t16 += v * b5;
t17 += v * b6;
t18 += v * b7;
t19 += v * b8;
t20 += v * b9;
t21 += v * b10;
t22 += v * b11;
t23 += v * b12;
t24 += v * b13;
t25 += v * b14;
t26 += v * b15;
v = a[12];
t12 += v * b0;
t13 += v * b1;
t14 += v * b2;
t15 += v * b3;
t16 += v * b4;
t17 += v * b5;
t18 += v * b6;
t19 += v * b7;
t20 += v * b8;
t21 += v * b9;
t22 += v * b10;
t23 += v * b11;
t24 += v * b12;
t25 += v * b13;
t26 += v * b14;
t27 += v * b15;
v = a[13];
t13 += v * b0;
t14 += v * b1;
t15 += v * b2;
t16 += v * b3;
t17 += v * b4;
t18 += v * b5;
t19 += v * b6;
t20 += v * b7;
t21 += v * b8;
t22 += v * b9;
t23 += v * b10;
t24 += v * b11;
t25 += v * b12;
t26 += v * b13;
t27 += v * b14;
t28 += v * b15;
v = a[14];
t14 += v * b0;
t15 += v * b1;
t16 += v * b2;
t17 += v * b3;
t18 += v * b4;
t19 += v * b5;
t20 += v * b6;
t21 += v * b7;
t22 += v * b8;
t23 += v * b9;
t24 += v * b10;
t25 += v * b11;
t26 += v * b12;
t27 += v * b13;
t28 += v * b14;
t29 += v * b15;
v = a[15];
t15 += v * b0;
t16 += v * b1;
t17 += v * b2;
t18 += v * b3;
t19 += v * b4;
t20 += v * b5;
t21 += v * b6;
t22 += v * b7;
t23 += v * b8;
t24 += v * b9;
t25 += v * b10;
t26 += v * b11;
t27 += v * b12;
t28 += v * b13;
t29 += v * b14;
t30 += v * b15;
t0 += 38 * t16;
t1 += 38 * t17;
t2 += 38 * t18;
t3 += 38 * t19;
t4 += 38 * t20;
t5 += 38 * t21;
t6 += 38 * t22;
t7 += 38 * t23;
t8 += 38 * t24;
t9 += 38 * t25;
t10 += 38 * t26;
t11 += 38 * t27;
t12 += 38 * t28;
t13 += 38 * t29;
t14 += 38 * t30;
c = 1;
v = t0 + c + 65535;
c = Math.floor(v / 65536);
t0 = v - c * 65536;
v = t1 + c + 65535;
c = Math.floor(v / 65536);
t1 = v - c * 65536;
v = t2 + c + 65535;
c = Math.floor(v / 65536);
t2 = v - c * 65536;
v = t3 + c + 65535;
c = Math.floor(v / 65536);
t3 = v - c * 65536;
v = t4 + c + 65535;
c = Math.floor(v / 65536);
t4 = v - c * 65536;
v = t5 + c + 65535;
c = Math.floor(v / 65536);
t5 = v - c * 65536;
v = t6 + c + 65535;
c = Math.floor(v / 65536);
t6 = v - c * 65536;
v = t7 + c + 65535;
c = Math.floor(v / 65536);
t7 = v - c * 65536;
v = t8 + c + 65535;
c = Math.floor(v / 65536);
t8 = v - c * 65536;
v = t9 + c + 65535;
c = Math.floor(v / 65536);
t9 = v - c * 65536;
v = t10 + c + 65535;
c = Math.floor(v / 65536);
t10 = v - c * 65536;
v = t11 + c + 65535;
c = Math.floor(v / 65536);
t11 = v - c * 65536;
v = t12 + c + 65535;
c = Math.floor(v / 65536);
t12 = v - c * 65536;
v = t13 + c + 65535;
c = Math.floor(v / 65536);
t13 = v - c * 65536;
v = t14 + c + 65535;
c = Math.floor(v / 65536);
t14 = v - c * 65536;
v = t15 + c + 65535;
c = Math.floor(v / 65536);
t15 = v - c * 65536;
t0 += c - 1 + 37 * (c - 1);
c = 1;
v = t0 + c + 65535;
c = Math.floor(v / 65536);
t0 = v - c * 65536;
v = t1 + c + 65535;
c = Math.floor(v / 65536);
t1 = v - c * 65536;
v = t2 + c + 65535;
c = Math.floor(v / 65536);
t2 = v - c * 65536;
v = t3 + c + 65535;
c = Math.floor(v / 65536);
t3 = v - c * 65536;
v = t4 + c + 65535;
c = Math.floor(v / 65536);
t4 = v - c * 65536;
v = t5 + c + 65535;
c = Math.floor(v / 65536);
t5 = v - c * 65536;
v = t6 + c + 65535;
c = Math.floor(v / 65536);
t6 = v - c * 65536;
v = t7 + c + 65535;
c = Math.floor(v / 65536);
t7 = v - c * 65536;
v = t8 + c + 65535;
c = Math.floor(v / 65536);
t8 = v - c * 65536;
v = t9 + c + 65535;
c = Math.floor(v / 65536);
t9 = v - c * 65536;
v = t10 + c + 65535;
c = Math.floor(v / 65536);
t10 = v - c * 65536;
v = t11 + c + 65535;
c = Math.floor(v / 65536);
t11 = v - c * 65536;
v = t12 + c + 65535;
c = Math.floor(v / 65536);
t12 = v - c * 65536;
v = t13 + c + 65535;
c = Math.floor(v / 65536);
t13 = v - c * 65536;
v = t14 + c + 65535;
c = Math.floor(v / 65536);
t14 = v - c * 65536;
v = t15 + c + 65535;
c = Math.floor(v / 65536);
t15 = v - c * 65536;
t0 += c - 1 + 37 * (c - 1);
o[0] = t0;
o[1] = t1;
o[2] = t2;
o[3] = t3;
o[4] = t4;
o[5] = t5;
o[6] = t6;
o[7] = t7;
o[8] = t8;
o[9] = t9;
o[10] = t10;
o[11] = t11;
o[12] = t12;
o[13] = t13;
o[14] = t14;
o[15] = t15;
}
}
});
// node_modules/node-forge/lib/kem.js
var require_kem = __commonJS({
"node_modules/node-forge/lib/kem.js"(exports2, module2) {
"use strict";
var forge2 = require_forge();
require_util();
require_random();
require_jsbn();
module2.exports = forge2.kem = forge2.kem || {};
var BigInteger = forge2.jsbn.BigInteger;
forge2.kem.rsa = {};
forge2.kem.rsa.create = function(kdf, options) {
options = options || {};
var prng = options.prng || forge2.random;
var kem = {};
kem.encrypt = function(publicKey, keyLength) {
var byteLength = Math.ceil(publicKey.n.bitLength() / 8);
var r;
do {
r = new BigInteger(
forge2.util.bytesToHex(prng.getBytesSync(byteLength)),
16
).mod(publicKey.n);
} while (r.compareTo(BigInteger.ONE) <= 0);
r = forge2.util.hexToBytes(r.toString(16));
var zeros = byteLength - r.length;
if (zeros > 0) {
r = forge2.util.fillString(String.fromCharCode(0), zeros) + r;
}
var encapsulation = publicKey.encrypt(r, "NONE");
var key2 = kdf.generate(r, keyLength);
return { encapsulation, key: key2 };
};
kem.decrypt = function(privateKey, encapsulation, keyLength) {
var r = privateKey.decrypt(encapsulation, "NONE");
return kdf.generate(r, keyLength);
};
return kem;
};
forge2.kem.kdf1 = function(md, digestLength) {
_createKDF(this, md, 0, digestLength || md.digestLength);
};
forge2.kem.kdf2 = function(md, digestLength) {
_createKDF(this, md, 1, digestLength || md.digestLength);
};
function _createKDF(kdf, md, counterStart, digestLength) {
kdf.generate = function(x, length2) {
var key2 = new forge2.util.ByteBuffer();
var k = Math.ceil(length2 / digestLength) + counterStart;
var c = new forge2.util.ByteBuffer();
for (var i = counterStart; i < k; ++i) {
c.putInt32(i);
md.start();
md.update(x + c.getBytes());
var hash = md.digest();
key2.putBytes(hash.getBytes(digestLength));
}
key2.truncate(key2.length() - length2);
return key2.getBytes();
};
}
}
});
// node_modules/node-forge/lib/log.js
var require_log = __commonJS({
"node_modules/node-forge/lib/log.js"(exports2, module2) {
"use strict";
var forge2 = require_forge();
require_util();
module2.exports = forge2.log = forge2.log || {};
forge2.log.levels = [
"none",
"error",
"warning",
"info",
"debug",
"verbose",
"max"
];
var sLevelInfo = {};
var sLoggers = [];
var sConsoleLogger = null;
forge2.log.LEVEL_LOCKED = 1 << 1;
forge2.log.NO_LEVEL_CHECK = 1 << 2;
forge2.log.INTERPOLATE = 1 << 3;
for (i = 0; i < forge2.log.levels.length; ++i) {
level = forge2.log.levels[i];
sLevelInfo[level] = {
index: i,
name: level.toUpperCase()
};
}
var level;
var i;
forge2.log.logMessage = function(message) {
var messageLevelIndex = sLevelInfo[message.level].index;
for (var i2 = 0; i2 < sLoggers.length; ++i2) {
var logger2 = sLoggers[i2];
if (logger2.flags & forge2.log.NO_LEVEL_CHECK) {
logger2.f(message);
} else {
var loggerLevelIndex = sLevelInfo[logger2.level].index;
if (messageLevelIndex <= loggerLevelIndex) {
logger2.f(logger2, message);
}
}
}
};
forge2.log.prepareStandard = function(message) {
if (!("standard" in message)) {
message.standard = sLevelInfo[message.level].name + //' ' + +message.timestamp +
" [" + message.category + "] " + message.message;
}
};
forge2.log.prepareFull = function(message) {
if (!("full" in message)) {
var args = [message.message];
args = args.concat([]);
message.full = forge2.util.format.apply(this, args);
}
};
forge2.log.prepareStandardFull = function(message) {
if (!("standardFull" in message)) {
forge2.log.prepareStandard(message);
message.standardFull = message.standard;
}
};
if (true) {
levels = ["error", "warning", "info", "debug", "verbose"];
for (i = 0; i < levels.length; ++i) {
(function(level2) {
forge2.log[level2] = function(category, message) {
var args = Array.prototype.slice.call(arguments).slice(2);
var msg = {
timestamp: /* @__PURE__ */ new Date(),
level: level2,
category,
message,
"arguments": args
/*standard*/
/*full*/
/*fullMessage*/
};
forge2.log.logMessage(msg);
};
})(levels[i]);
}
}
var levels;
var i;
forge2.log.makeLogger = function(logFunction) {
var logger2 = {
flags: 0,
f: logFunction
};
forge2.log.setLevel(logger2, "none");
return logger2;
};
forge2.log.setLevel = function(logger2, level2) {
var rval = false;
if (logger2 && !(logger2.flags & forge2.log.LEVEL_LOCKED)) {
for (var i2 = 0; i2 < forge2.log.levels.length; ++i2) {
var aValidLevel = forge2.log.levels[i2];
if (level2 == aValidLevel) {
logger2.level = level2;
rval = true;
break;
}
}
}
return rval;
};
forge2.log.lock = function(logger2, lock2) {
if (typeof lock2 === "undefined" || lock2) {
logger2.flags |= forge2.log.LEVEL_LOCKED;
} else {
logger2.flags &= ~forge2.log.LEVEL_LOCKED;
}
};
forge2.log.addLogger = function(logger2) {
sLoggers.push(logger2);
};
if (typeof console !== "undefined" && "log" in console) {
if (console.error && console.warn && console.info && console.debug) {
levelHandlers = {
error: console.error,
warning: console.warn,
info: console.info,
debug: console.debug,
verbose: console.debug
};
f = function(logger2, message) {
forge2.log.prepareStandard(message);
var handler = levelHandlers[message.level];
var args = [message.standard];
args = args.concat(message["arguments"].slice());
handler.apply(console, args);
};
logger = forge2.log.makeLogger(f);
} else {
f = function(logger2, message) {
forge2.log.prepareStandardFull(message);
console.log(message.standardFull);
};
logger = forge2.log.makeLogger(f);
}
forge2.log.setLevel(logger, "debug");
forge2.log.addLogger(logger);
sConsoleLogger = logger;
} else {
console = {
log: function() {
}
};
}
var logger;
var levelHandlers;
var f;
if (sConsoleLogger !== null && typeof window !== "undefined" && window.location) {
query = new URL(window.location.href).searchParams;
if (query.has("console.level")) {
forge2.log.setLevel(
sConsoleLogger,
query.get("console.level").slice(-1)[0]
);
}
if (query.has("console.lock")) {
lock = query.get("console.lock").slice(-1)[0];
if (lock == "true") {
forge2.log.lock(sConsoleLogger);
}
}
}
var query;
var lock;
forge2.log.consoleLogger = sConsoleLogger;
}
});
// node_modules/node-forge/lib/md.all.js
var require_md_all = __commonJS({
"node_modules/node-forge/lib/md.all.js"(exports2, module2) {
"use strict";
module2.exports = require_md();
require_md5();
require_sha1();
require_sha256();
require_sha512();
}
});
// node_modules/node-forge/lib/pkcs7.js
var require_pkcs7 = __commonJS({
"node_modules/node-forge/lib/pkcs7.js"(exports2, module2) {
"use strict";
var forge2 = require_forge();
require_aes();
require_asn1();
require_des();
require_oids();
require_pem();
require_pkcs7asn1();
require_random();
require_util();
require_x509();
var asn1 = forge2.asn1;
var p7 = module2.exports = forge2.pkcs7 = forge2.pkcs7 || {};
p7.messageFromPem = function(pem) {
var msg = forge2.pem.decode(pem)[0];
if (msg.type !== "PKCS7") {
var error = new Error('Could not convert PKCS#7 message from PEM; PEM header type is not "PKCS#7".');
error.headerType = msg.type;
throw error;
}
if (msg.procType && msg.procType.type === "ENCRYPTED") {
throw new Error("Could not convert PKCS#7 message from PEM; PEM is encrypted.");
}
var obj = asn1.fromDer(msg.body);
return p7.messageFromAsn1(obj);
};
p7.messageToPem = function(msg, maxline) {
var pemObj = {
type: "PKCS7",
body: asn1.toDer(msg.toAsn1()).getBytes()
};
return forge2.pem.encode(pemObj, { maxline });
};
p7.messageFromAsn1 = function(obj) {
var capture = {};
var errors = [];
if (!asn1.validate(obj, p7.asn1.contentInfoValidator, capture, errors)) {
var error = new Error("Cannot read PKCS#7 message. ASN.1 object is not an PKCS#7 ContentInfo.");
error.errors = errors;
throw error;
}
var contentType = asn1.derToOid(capture.contentType);
var msg;
switch (contentType) {
case forge2.pki.oids.envelopedData:
msg = p7.createEnvelopedData();
break;
case forge2.pki.oids.encryptedData:
msg = p7.createEncryptedData();
break;
case forge2.pki.oids.signedData:
msg = p7.createSignedData();
break;
default:
throw new Error("Cannot read PKCS#7 message. ContentType with OID " + contentType + " is not (yet) supported.");
}
msg.fromAsn1(capture.content.value[0]);
return msg;
};
p7.createSignedData = function() {
var msg = null;
msg = {
type: forge2.pki.oids.signedData,
version: 1,
certificates: [],
crls: [],
// TODO: add json-formatted signer stuff here?
signers: [],
// populated during sign()
digestAlgorithmIdentifiers: [],
contentInfo: null,
signerInfos: [],
fromAsn1: function(obj) {
_fromAsn1(msg, obj, p7.asn1.signedDataValidator);
msg.certificates = [];
msg.crls = [];
msg.digestAlgorithmIdentifiers = [];
msg.contentInfo = null;
msg.signerInfos = [];
if (msg.rawCapture.certificates) {
var certs = msg.rawCapture.certificates.value;
for (var i = 0; i < certs.length; ++i) {
msg.certificates.push(forge2.pki.certificateFromAsn1(certs[i]));
}
}
},
toAsn1: function() {
if (!msg.contentInfo) {
msg.sign();
}
var certs = [];
for (var i = 0; i < msg.certificates.length; ++i) {
certs.push(forge2.pki.certificateToAsn1(msg.certificates[i]));
}
var crls = [];
var signedData = asn1.create(asn1.Class.CONTEXT_SPECIFIC, 0, true, [
asn1.create(asn1.Class.UNIVERSAL, asn1.Type.SEQUENCE, true, [
// Version
asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.INTEGER,
false,
asn1.integerToDer(msg.version).getBytes()
),
// DigestAlgorithmIdentifiers
asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.SET,
true,
msg.digestAlgorithmIdentifiers
),
// ContentInfo
msg.contentInfo
])
]);
if (certs.length > 0) {
signedData.value[0].value.push(
asn1.create(asn1.Class.CONTEXT_SPECIFIC, 0, true, certs)
);
}
if (crls.length > 0) {
signedData.value[0].value.push(
asn1.create(asn1.Class.CONTEXT_SPECIFIC, 1, true, crls)
);
}
signedData.value[0].value.push(
asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.SET,
true,
msg.signerInfos
)
);
return asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.SEQUENCE,
true,
[
// ContentType
asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.OID,
false,
asn1.oidToDer(msg.type).getBytes()
),
// [0] SignedData
signedData
]
);
},
/**
* Add (another) entity to list of signers.
*
* Note: If authenticatedAttributes are provided, then, per RFC 2315,
* they must include at least two attributes: content type and
* message digest. The message digest attribute value will be
* auto-calculated during signing and will be ignored if provided.
*
* Here's an example of providing these two attributes:
*
* forge.pkcs7.createSignedData();
* p7.addSigner({
* issuer: cert.issuer.attributes,
* serialNumber: cert.serialNumber,
* key: privateKey,
* digestAlgorithm: forge.pki.oids.sha1,
* authenticatedAttributes: [{
* type: forge.pki.oids.contentType,
* value: forge.pki.oids.data
* }, {
* type: forge.pki.oids.messageDigest
* }]
* });
*
* TODO: Support [subjectKeyIdentifier] as signer's ID.
*
* @param signer the signer information:
* key the signer's private key.
* [certificate] a certificate containing the public key
* associated with the signer's private key; use this option as
* an alternative to specifying signer.issuer and
* signer.serialNumber.
* [issuer] the issuer attributes (eg: cert.issuer.attributes).
* [serialNumber] the signer's certificate's serial number in
* hexadecimal (eg: cert.serialNumber).
* [digestAlgorithm] the message digest OID, as a string, to use
* (eg: forge.pki.oids.sha1).
* [authenticatedAttributes] an optional array of attributes
* to also sign along with the content.
*/
addSigner: function(signer) {
var issuer = signer.issuer;
var serialNumber = signer.serialNumber;
if (signer.certificate) {
var cert = signer.certificate;
if (typeof cert === "string") {
cert = forge2.pki.certificateFromPem(cert);
}
issuer = cert.issuer.attributes;
serialNumber = cert.serialNumber;
}
var key2 = signer.key;
if (!key2) {
throw new Error(
"Could not add PKCS#7 signer; no private key specified."
);
}
if (typeof key2 === "string") {
key2 = forge2.pki.privateKeyFromPem(key2);
}
var digestAlgorithm = signer.digestAlgorithm || forge2.pki.oids.sha1;
switch (digestAlgorithm) {
case forge2.pki.oids.sha1:
case forge2.pki.oids.sha256:
case forge2.pki.oids.sha384:
case forge2.pki.oids.sha512:
case forge2.pki.oids.md5:
break;
default:
throw new Error(
"Could not add PKCS#7 signer; unknown message digest algorithm: " + digestAlgorithm
);
}
var authenticatedAttributes = signer.authenticatedAttributes || [];
if (authenticatedAttributes.length > 0) {
var contentType = false;
var messageDigest = false;
for (var i = 0; i < authenticatedAttributes.length; ++i) {
var attr = authenticatedAttributes[i];
if (!contentType && attr.type === forge2.pki.oids.contentType) {
contentType = true;
if (messageDigest) {
break;
}
continue;
}
if (!messageDigest && attr.type === forge2.pki.oids.messageDigest) {
messageDigest = true;
if (contentType) {
break;
}
continue;
}
}
if (!contentType || !messageDigest) {
throw new Error("Invalid signer.authenticatedAttributes. If signer.authenticatedAttributes is specified, then it must contain at least two attributes, PKCS #9 content-type and PKCS #9 message-digest.");
}
}
msg.signers.push({
key: key2,
version: 1,
issuer,
serialNumber,
digestAlgorithm,
signatureAlgorithm: forge2.pki.oids.rsaEncryption,
signature: null,
authenticatedAttributes,
unauthenticatedAttributes: []
});
},
/**
* Signs the content.
* @param options Options to apply when signing:
* [detached] boolean. If signing should be done in detached mode. Defaults to false.
*/
sign: function(options) {
options = options || {};
if (typeof msg.content !== "object" || msg.contentInfo === null) {
msg.contentInfo = asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.SEQUENCE,
true,
[
// ContentType
asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.OID,
false,
asn1.oidToDer(forge2.pki.oids.data).getBytes()
)
]
);
if ("content" in msg) {
var content2;
if (msg.content instanceof forge2.util.ByteBuffer) {
content2 = msg.content.bytes();
} else if (typeof msg.content === "string") {
content2 = forge2.util.encodeUtf8(msg.content);
}
if (options.detached) {
msg.detachedContent = asn1.create(asn1.Class.UNIVERSAL, asn1.Type.OCTETSTRING, false, content2);
} else {
msg.contentInfo.value.push(
// [0] EXPLICIT content
asn1.create(asn1.Class.CONTEXT_SPECIFIC, 0, true, [
asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.OCTETSTRING,
false,
content2
)
])
);
}
}
}
if (msg.signers.length === 0) {
return;
}
var mds = addDigestAlgorithmIds();
addSignerInfos(mds);
},
verify: function() {
throw new Error("PKCS#7 signature verification not yet implemented.");
},
/**
* Add a certificate.
*
* @param cert the certificate to add.
*/
addCertificate: function(cert) {
if (typeof cert === "string") {
cert = forge2.pki.certificateFromPem(cert);
}
msg.certificates.push(cert);
},
/**
* Add a certificate revokation list.
*
* @param crl the certificate revokation list to add.
*/
addCertificateRevokationList: function(crl) {
throw new Error("PKCS#7 CRL support not yet implemented.");
}
};
return msg;
function addDigestAlgorithmIds() {
var mds = {};
for (var i = 0; i < msg.signers.length; ++i) {
var signer = msg.signers[i];
var oid = signer.digestAlgorithm;
if (!(oid in mds)) {
mds[oid] = forge2.md[forge2.pki.oids[oid]].create();
}
if (signer.authenticatedAttributes.length === 0) {
signer.md = mds[oid];
} else {
signer.md = forge2.md[forge2.pki.oids[oid]].create();
}
}
msg.digestAlgorithmIdentifiers = [];
for (var oid in mds) {
msg.digestAlgorithmIdentifiers.push(
// AlgorithmIdentifier
asn1.create(asn1.Class.UNIVERSAL, asn1.Type.SEQUENCE, true, [
// algorithm
asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.OID,
false,
asn1.oidToDer(oid).getBytes()
),
// parameters (null)
asn1.create(asn1.Class.UNIVERSAL, asn1.Type.NULL, false, "")
])
);
}
return mds;
}
function addSignerInfos(mds) {
var content2;
if (msg.detachedContent) {
content2 = msg.detachedContent;
} else {
content2 = msg.contentInfo.value[1];
content2 = content2.value[0];
}
if (!content2) {
throw new Error(
"Could not sign PKCS#7 message; there is no content to sign."
);
}
var contentType = asn1.derToOid(msg.contentInfo.value[0].value);
var bytes = asn1.toDer(content2);
bytes.getByte();
asn1.getBerValueLength(bytes);
bytes = bytes.getBytes();
for (var oid in mds) {
mds[oid].start().update(bytes);
}
var signingTime = /* @__PURE__ */ new Date();
for (var i = 0; i < msg.signers.length; ++i) {
var signer = msg.signers[i];
if (signer.authenticatedAttributes.length === 0) {
if (contentType !== forge2.pki.oids.data) {
throw new Error(
"Invalid signer; authenticatedAttributes must be present when the ContentInfo content type is not PKCS#7 Data."
);
}
} else {
signer.authenticatedAttributesAsn1 = asn1.create(
asn1.Class.CONTEXT_SPECIFIC,
0,
true,
[]
);
var attrsAsn1 = asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.SET,
true,
[]
);
for (var ai = 0; ai < signer.authenticatedAttributes.length; ++ai) {
var attr = signer.authenticatedAttributes[ai];
if (attr.type === forge2.pki.oids.messageDigest) {
attr.value = mds[signer.digestAlgorithm].digest();
} else if (attr.type === forge2.pki.oids.signingTime) {
if (!attr.value) {
attr.value = signingTime;
}
}
attrsAsn1.value.push(_attributeToAsn1(attr));
signer.authenticatedAttributesAsn1.value.push(_attributeToAsn1(attr));
}
bytes = asn1.toDer(attrsAsn1).getBytes();
signer.md.start().update(bytes);
}
signer.signature = signer.key.sign(signer.md, "RSASSA-PKCS1-V1_5");
}
msg.signerInfos = _signersToAsn1(msg.signers);
}
};
p7.createEncryptedData = function() {
var msg = null;
msg = {
type: forge2.pki.oids.encryptedData,
version: 0,
encryptedContent: {
algorithm: forge2.pki.oids["aes256-CBC"]
},
/**
* Reads an EncryptedData content block (in ASN.1 format)
*
* @param obj The ASN.1 representation of the EncryptedData content block
*/
fromAsn1: function(obj) {
_fromAsn1(msg, obj, p7.asn1.encryptedDataValidator);
},
/**
* Decrypt encrypted content
*
* @param key The (symmetric) key as a byte buffer
*/
decrypt: function(key2) {
if (key2 !== void 0) {
msg.encryptedContent.key = key2;
}
_decryptContent(msg);
}
};
return msg;
};
p7.createEnvelopedData = function() {
var msg = null;
msg = {
type: forge2.pki.oids.envelopedData,
version: 0,
recipients: [],
encryptedContent: {
algorithm: forge2.pki.oids["aes256-CBC"]
},
/**
* Reads an EnvelopedData content block (in ASN.1 format)
*
* @param obj the ASN.1 representation of the EnvelopedData content block.
*/
fromAsn1: function(obj) {
var capture = _fromAsn1(msg, obj, p7.asn1.envelopedDataValidator);
msg.recipients = _recipientsFromAsn1(capture.recipientInfos.value);
},
toAsn1: function() {
return asn1.create(asn1.Class.UNIVERSAL, asn1.Type.SEQUENCE, true, [
// ContentType
asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.OID,
false,
asn1.oidToDer(msg.type).getBytes()
),
// [0] EnvelopedData
asn1.create(asn1.Class.CONTEXT_SPECIFIC, 0, true, [
asn1.create(asn1.Class.UNIVERSAL, asn1.Type.SEQUENCE, true, [
// Version
asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.INTEGER,
false,
asn1.integerToDer(msg.version).getBytes()
),
// RecipientInfos
asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.SET,
true,
_recipientsToAsn1(msg.recipients)
),
// EncryptedContentInfo
asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.SEQUENCE,
true,
_encryptedContentToAsn1(msg.encryptedContent)
)
])
])
]);
},
/**
* Find recipient by X.509 certificate's issuer.
*
* @param cert the certificate with the issuer to look for.
*
* @return the recipient object.
*/
findRecipient: function(cert) {
var sAttr = cert.issuer.attributes;
for (var i = 0; i < msg.recipients.length; ++i) {
var r = msg.recipients[i];
var rAttr = r.issuer;
if (r.serialNumber !== cert.serialNumber) {
continue;
}
if (rAttr.length !== sAttr.length) {
continue;
}
var match2 = true;
for (var j = 0; j < sAttr.length; ++j) {
if (rAttr[j].type !== sAttr[j].type || rAttr[j].value !== sAttr[j].value) {
match2 = false;
break;
}
}
if (match2) {
return r;
}
}
return null;
},
/**
* Decrypt enveloped content
*
* @param recipient The recipient object related to the private key
* @param privKey The (RSA) private key object
*/
decrypt: function(recipient, privKey) {
if (msg.encryptedContent.key === void 0 && recipient !== void 0 && privKey !== void 0) {
switch (recipient.encryptedContent.algorithm) {
case forge2.pki.oids.rsaEncryption:
case forge2.pki.oids.desCBC:
var key2 = privKey.decrypt(recipient.encryptedContent.content);
msg.encryptedContent.key = forge2.util.createBuffer(key2);
break;
default:
throw new Error("Unsupported asymmetric cipher, OID " + recipient.encryptedContent.algorithm);
}
}
_decryptContent(msg);
},
/**
* Add (another) entity to list of recipients.
*
* @param cert The certificate of the entity to add.
*/
addRecipient: function(cert) {
msg.recipients.push({
version: 0,
issuer: cert.issuer.attributes,
serialNumber: cert.serialNumber,
encryptedContent: {
// We simply assume rsaEncryption here, since forge.pki only
// supports RSA so far. If the PKI module supports other
// ciphers one day, we need to modify this one as well.
algorithm: forge2.pki.oids.rsaEncryption,
key: cert.publicKey
}
});
},
/**
* Encrypt enveloped content.
*
* This function supports two optional arguments, cipher and key, which
* can be used to influence symmetric encryption. Unless cipher is
* provided, the cipher specified in encryptedContent.algorithm is used
* (defaults to AES-256-CBC). If no key is provided, encryptedContent.key
* is (re-)used. If that one's not set, a random key will be generated
* automatically.
*
* @param [key] The key to be used for symmetric encryption.
* @param [cipher] The OID of the symmetric cipher to use.
*/
encrypt: function(key2, cipher) {
if (msg.encryptedContent.content === void 0) {
cipher = cipher || msg.encryptedContent.algorithm;
key2 = key2 || msg.encryptedContent.key;
var keyLen, ivLen, ciphFn;
switch (cipher) {
case forge2.pki.oids["aes128-CBC"]:
keyLen = 16;
ivLen = 16;
ciphFn = forge2.aes.createEncryptionCipher;
break;
case forge2.pki.oids["aes192-CBC"]:
keyLen = 24;
ivLen = 16;
ciphFn = forge2.aes.createEncryptionCipher;
break;
case forge2.pki.oids["aes256-CBC"]:
keyLen = 32;
ivLen = 16;
ciphFn = forge2.aes.createEncryptionCipher;
break;
case forge2.pki.oids["des-EDE3-CBC"]:
keyLen = 24;
ivLen = 8;
ciphFn = forge2.des.createEncryptionCipher;
break;
default:
throw new Error("Unsupported symmetric cipher, OID " + cipher);
}
if (key2 === void 0) {
key2 = forge2.util.createBuffer(forge2.random.getBytes(keyLen));
} else if (key2.length() != keyLen) {
throw new Error("Symmetric key has wrong length; got " + key2.length() + " bytes, expected " + keyLen + ".");
}
msg.encryptedContent.algorithm = cipher;
msg.encryptedContent.key = key2;
msg.encryptedContent.parameter = forge2.util.createBuffer(
forge2.random.getBytes(ivLen)
);
var ciph = ciphFn(key2);
ciph.start(msg.encryptedContent.parameter.copy());
ciph.update(msg.content);
if (!ciph.finish()) {
throw new Error("Symmetric encryption failed.");
}
msg.encryptedContent.content = ciph.output;
}
for (var i = 0; i < msg.recipients.length; ++i) {
var recipient = msg.recipients[i];
if (recipient.encryptedContent.content !== void 0) {
continue;
}
switch (recipient.encryptedContent.algorithm) {
case forge2.pki.oids.rsaEncryption:
recipient.encryptedContent.content = recipient.encryptedContent.key.encrypt(
msg.encryptedContent.key.data
);
break;
default:
throw new Error("Unsupported asymmetric cipher, OID " + recipient.encryptedContent.algorithm);
}
}
}
};
return msg;
};
function _recipientFromAsn1(obj) {
var capture = {};
var errors = [];
if (!asn1.validate(obj, p7.asn1.recipientInfoValidator, capture, errors)) {
var error = new Error("Cannot read PKCS#7 RecipientInfo. ASN.1 object is not an PKCS#7 RecipientInfo.");
error.errors = errors;
throw error;
}
return {
version: capture.version.charCodeAt(0),
issuer: forge2.pki.RDNAttributesAsArray(capture.issuer),
serialNumber: forge2.util.createBuffer(capture.serial).toHex(),
encryptedContent: {
algorithm: asn1.derToOid(capture.encAlgorithm),
parameter: capture.encParameter ? capture.encParameter.value : void 0,
content: capture.encKey
}
};
}
function _recipientToAsn1(obj) {
return asn1.create(asn1.Class.UNIVERSAL, asn1.Type.SEQUENCE, true, [
// Version
asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.INTEGER,
false,
asn1.integerToDer(obj.version).getBytes()
),
// IssuerAndSerialNumber
asn1.create(asn1.Class.UNIVERSAL, asn1.Type.SEQUENCE, true, [
// Name
forge2.pki.distinguishedNameToAsn1({ attributes: obj.issuer }),
// Serial
asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.INTEGER,
false,
forge2.util.hexToBytes(obj.serialNumber)
)
]),
// KeyEncryptionAlgorithmIdentifier
asn1.create(asn1.Class.UNIVERSAL, asn1.Type.SEQUENCE, true, [
// Algorithm
asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.OID,
false,
asn1.oidToDer(obj.encryptedContent.algorithm).getBytes()
),
// Parameter, force NULL, only RSA supported for now.
asn1.create(asn1.Class.UNIVERSAL, asn1.Type.NULL, false, "")
]),
// EncryptedKey
asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.OCTETSTRING,
false,
obj.encryptedContent.content
)
]);
}
function _recipientsFromAsn1(infos) {
var ret = [];
for (var i = 0; i < infos.length; ++i) {
ret.push(_recipientFromAsn1(infos[i]));
}
return ret;
}
function _recipientsToAsn1(recipients) {
var ret = [];
for (var i = 0; i < recipients.length; ++i) {
ret.push(_recipientToAsn1(recipients[i]));
}
return ret;
}
function _signerToAsn1(obj) {
var rval = asn1.create(asn1.Class.UNIVERSAL, asn1.Type.SEQUENCE, true, [
// version
asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.INTEGER,
false,
asn1.integerToDer(obj.version).getBytes()
),
// issuerAndSerialNumber
asn1.create(asn1.Class.UNIVERSAL, asn1.Type.SEQUENCE, true, [
// name
forge2.pki.distinguishedNameToAsn1({ attributes: obj.issuer }),
// serial
asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.INTEGER,
false,
forge2.util.hexToBytes(obj.serialNumber)
)
]),
// digestAlgorithm
asn1.create(asn1.Class.UNIVERSAL, asn1.Type.SEQUENCE, true, [
// algorithm
asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.OID,
false,
asn1.oidToDer(obj.digestAlgorithm).getBytes()
),
// parameters (null)
asn1.create(asn1.Class.UNIVERSAL, asn1.Type.NULL, false, "")
])
]);
if (obj.authenticatedAttributesAsn1) {
rval.value.push(obj.authenticatedAttributesAsn1);
}
rval.value.push(asn1.create(asn1.Class.UNIVERSAL, asn1.Type.SEQUENCE, true, [
// algorithm
asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.OID,
false,
asn1.oidToDer(obj.signatureAlgorithm).getBytes()
),
// parameters (null)
asn1.create(asn1.Class.UNIVERSAL, asn1.Type.NULL, false, "")
]));
rval.value.push(asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.OCTETSTRING,
false,
obj.signature
));
if (obj.unauthenticatedAttributes.length > 0) {
var attrsAsn1 = asn1.create(asn1.Class.CONTEXT_SPECIFIC, 1, true, []);
for (var i = 0; i < obj.unauthenticatedAttributes.length; ++i) {
var attr = obj.unauthenticatedAttributes[i];
attrsAsn1.values.push(_attributeToAsn1(attr));
}
rval.value.push(attrsAsn1);
}
return rval;
}
function _signersToAsn1(signers) {
var ret = [];
for (var i = 0; i < signers.length; ++i) {
ret.push(_signerToAsn1(signers[i]));
}
return ret;
}
function _attributeToAsn1(attr) {
var value2;
if (attr.type === forge2.pki.oids.contentType) {
value2 = asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.OID,
false,
asn1.oidToDer(attr.value).getBytes()
);
} else if (attr.type === forge2.pki.oids.messageDigest) {
value2 = asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.OCTETSTRING,
false,
attr.value.bytes()
);
} else if (attr.type === forge2.pki.oids.signingTime) {
var jan_1_1950 = /* @__PURE__ */ new Date("1950-01-01T00:00:00Z");
var jan_1_2050 = /* @__PURE__ */ new Date("2050-01-01T00:00:00Z");
var date = attr.value;
if (typeof date === "string") {
var timestamp = Date.parse(date);
if (!isNaN(timestamp)) {
date = new Date(timestamp);
} else if (date.length === 13) {
date = asn1.utcTimeToDate(date);
} else {
date = asn1.generalizedTimeToDate(date);
}
}
if (date >= jan_1_1950 && date < jan_1_2050) {
value2 = asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.UTCTIME,
false,
asn1.dateToUtcTime(date)
);
} else {
value2 = asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.GENERALIZEDTIME,
false,
asn1.dateToGeneralizedTime(date)
);
}
}
return asn1.create(asn1.Class.UNIVERSAL, asn1.Type.SEQUENCE, true, [
// AttributeType
asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.OID,
false,
asn1.oidToDer(attr.type).getBytes()
),
asn1.create(asn1.Class.UNIVERSAL, asn1.Type.SET, true, [
// AttributeValue
value2
])
]);
}
function _encryptedContentToAsn1(ec) {
return [
// ContentType, always Data for the moment
asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.OID,
false,
asn1.oidToDer(forge2.pki.oids.data).getBytes()
),
// ContentEncryptionAlgorithmIdentifier
asn1.create(asn1.Class.UNIVERSAL, asn1.Type.SEQUENCE, true, [
// Algorithm
asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.OID,
false,
asn1.oidToDer(ec.algorithm).getBytes()
),
// Parameters (IV)
!ec.parameter ? void 0 : asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.OCTETSTRING,
false,
ec.parameter.getBytes()
)
]),
// [0] EncryptedContent
asn1.create(asn1.Class.CONTEXT_SPECIFIC, 0, true, [
asn1.create(
asn1.Class.UNIVERSAL,
asn1.Type.OCTETSTRING,
false,
ec.content.getBytes()
)
])
];
}
function _fromAsn1(msg, obj, validator) {
var capture = {};
var errors = [];
if (!asn1.validate(obj, validator, capture, errors)) {
var error = new Error("Cannot read PKCS#7 message. ASN.1 object is not a supported PKCS#7 message.");
error.errors = error;
throw error;
}
var contentType = asn1.derToOid(capture.contentType);
if (contentType !== forge2.pki.oids.data) {
throw new Error("Unsupported PKCS#7 message. Only wrapped ContentType Data supported.");
}
if (capture.encryptedContent) {
var content2 = "";
if (forge2.util.isArray(capture.encryptedContent)) {
for (var i = 0; i < capture.encryptedContent.length; ++i) {
if (capture.encryptedContent[i].type !== asn1.Type.OCTETSTRING) {
throw new Error("Malformed PKCS#7 message, expecting encrypted content constructed of only OCTET STRING objects.");
}
content2 += capture.encryptedContent[i].value;
}
} else {
content2 = capture.encryptedContent;
}
msg.encryptedContent = {
algorithm: asn1.derToOid(capture.encAlgorithm),
parameter: forge2.util.createBuffer(capture.encParameter.value),
content: forge2.util.createBuffer(content2)
};
}
if (capture.content) {
var content2 = "";
if (forge2.util.isArray(capture.content)) {
for (var i = 0; i < capture.content.length; ++i) {
if (capture.content[i].type !== asn1.Type.OCTETSTRING) {
throw new Error("Malformed PKCS#7 message, expecting content constructed of only OCTET STRING objects.");
}
content2 += capture.content[i].value;
}
} else {
content2 = capture.content;
}
msg.content = forge2.util.createBuffer(content2);
}
msg.version = capture.version.charCodeAt(0);
msg.rawCapture = capture;
return capture;
}
function _decryptContent(msg) {
if (msg.encryptedContent.key === void 0) {
throw new Error("Symmetric key not available.");
}
if (msg.content === void 0) {
var ciph;
switch (msg.encryptedContent.algorithm) {
case forge2.pki.oids["aes128-CBC"]:
case forge2.pki.oids["aes192-CBC"]:
case forge2.pki.oids["aes256-CBC"]:
ciph = forge2.aes.createDecryptionCipher(msg.encryptedContent.key);
break;
case forge2.pki.oids["desCBC"]:
case forge2.pki.oids["des-EDE3-CBC"]:
ciph = forge2.des.createDecryptionCipher(msg.encryptedContent.key);
break;
default:
throw new Error("Unsupported symmetric cipher, OID " + msg.encryptedContent.algorithm);
}
ciph.start(msg.encryptedContent.parameter);
ciph.update(msg.encryptedContent.content);
if (!ciph.finish()) {
throw new Error("Symmetric decryption failed.");
}
msg.content = ciph.output;
}
}
}
});
// node_modules/node-forge/lib/ssh.js
var require_ssh = __commonJS({
"node_modules/node-forge/lib/ssh.js"(exports2, module2) {
"use strict";
var forge2 = require_forge();
require_aes();
require_hmac();
require_md5();
require_sha1();
require_util();
var ssh = module2.exports = forge2.ssh = forge2.ssh || {};
ssh.privateKeyToPutty = function(privateKey, passphrase, comment) {
comment = comment || "";
passphrase = passphrase || "";
var algorithm = "ssh-rsa";
var encryptionAlgorithm = passphrase === "" ? "none" : "aes256-cbc";
var ppk = "PuTTY-User-Key-File-2: " + algorithm + "\r\n";
ppk += "Encryption: " + encryptionAlgorithm + "\r\n";
ppk += "Comment: " + comment + "\r\n";
var pubbuffer = forge2.util.createBuffer();
_addStringToBuffer(pubbuffer, algorithm);
_addBigIntegerToBuffer(pubbuffer, privateKey.e);
_addBigIntegerToBuffer(pubbuffer, privateKey.n);
var pub = forge2.util.encode64(pubbuffer.bytes(), 64);
var length2 = Math.floor(pub.length / 66) + 1;
ppk += "Public-Lines: " + length2 + "\r\n";
ppk += pub;
var privbuffer = forge2.util.createBuffer();
_addBigIntegerToBuffer(privbuffer, privateKey.d);
_addBigIntegerToBuffer(privbuffer, privateKey.p);
_addBigIntegerToBuffer(privbuffer, privateKey.q);
_addBigIntegerToBuffer(privbuffer, privateKey.qInv);
var priv;
if (!passphrase) {
priv = forge2.util.encode64(privbuffer.bytes(), 64);
} else {
var encLen = privbuffer.length() + 16 - 1;
encLen -= encLen % 16;
var padding = _sha1(privbuffer.bytes());
padding.truncate(padding.length() - encLen + privbuffer.length());
privbuffer.putBuffer(padding);
var aeskey = forge2.util.createBuffer();
aeskey.putBuffer(_sha1("\0\0\0\0", passphrase));
aeskey.putBuffer(_sha1("\0\0\0", passphrase));
var cipher = forge2.aes.createEncryptionCipher(aeskey.truncate(8), "CBC");
cipher.start(forge2.util.createBuffer().fillWithByte(0, 16));
cipher.update(privbuffer.copy());
cipher.finish();
var encrypted = cipher.output;
encrypted.truncate(16);
priv = forge2.util.encode64(encrypted.bytes(), 64);
}
length2 = Math.floor(priv.length / 66) + 1;
ppk += "\r\nPrivate-Lines: " + length2 + "\r\n";
ppk += priv;
var mackey = _sha1("putty-private-key-file-mac-key", passphrase);
var macbuffer = forge2.util.createBuffer();
_addStringToBuffer(macbuffer, algorithm);
_addStringToBuffer(macbuffer, encryptionAlgorithm);
_addStringToBuffer(macbuffer, comment);
macbuffer.putInt32(pubbuffer.length());
macbuffer.putBuffer(pubbuffer);
macbuffer.putInt32(privbuffer.length());
macbuffer.putBuffer(privbuffer);
var hmac = forge2.hmac.create();
hmac.start("sha1", mackey);
hmac.update(macbuffer.bytes());
ppk += "\r\nPrivate-MAC: " + hmac.digest().toHex() + "\r\n";
return ppk;
};
ssh.publicKeyToOpenSSH = function(key2, comment) {
var type = "ssh-rsa";
comment = comment || "";
var buffer = forge2.util.createBuffer();
_addStringToBuffer(buffer, type);
_addBigIntegerToBuffer(buffer, key2.e);
_addBigIntegerToBuffer(buffer, key2.n);
return type + " " + forge2.util.encode64(buffer.bytes()) + " " + comment;
};
ssh.privateKeyToOpenSSH = function(privateKey, passphrase) {
if (!passphrase) {
return forge2.pki.privateKeyToPem(privateKey);
}
return forge2.pki.encryptRsaPrivateKey(
privateKey,
passphrase,
{ legacy: true, algorithm: "aes128" }
);
};
ssh.getPublicKeyFingerprint = function(key2, options) {
options = options || {};
var md = options.md || forge2.md.md5.create();
var type = "ssh-rsa";
var buffer = forge2.util.createBuffer();
_addStringToBuffer(buffer, type);
_addBigIntegerToBuffer(buffer, key2.e);
_addBigIntegerToBuffer(buffer, key2.n);
md.start();
md.update(buffer.getBytes());
var digest = md.digest();
if (options.encoding === "hex") {
var hex = digest.toHex();
if (options.delimiter) {
return hex.match(/.{2}/g).join(options.delimiter);
}
return hex;
} else if (options.encoding === "binary") {
return digest.getBytes();
} else if (options.encoding) {
throw new Error('Unknown encoding "' + options.encoding + '".');
}
return digest;
};
function _addBigIntegerToBuffer(buffer, val2) {
var hexVal = val2.toString(16);
if (hexVal[0] >= "8") {
hexVal = "00" + hexVal;
}
var bytes = forge2.util.hexToBytes(hexVal);
buffer.putInt32(bytes.length);
buffer.putBytes(bytes);
}
function _addStringToBuffer(buffer, val2) {
buffer.putInt32(val2.length);
buffer.putString(val2);
}
function _sha1() {
var sha = forge2.md.sha1.create();
var num = arguments.length;
for (var i = 0; i < num; ++i) {
sha.update(arguments[i]);
}
return sha.digest();
}
}
});
// node_modules/node-forge/lib/index.js
var require_lib = __commonJS({
"node_modules/node-forge/lib/index.js"(exports2, module2) {
"use strict";
module2.exports = require_forge();
require_aes();
require_aesCipherSuites();
require_asn1();
require_cipher();
require_des();
require_ed25519();
require_hmac();
require_kem();
require_log();
require_md_all();
require_mgf1();
require_pbkdf2();
require_pem();
require_pkcs1();
require_pkcs12();
require_pkcs7();
require_pki();
require_prime();
require_prng();
require_pss();
require_random();
require_rc2();
require_ssh();
require_tls();
require_util();
}
});
// node_modules/lottie-web/build/player/lottie.js
var require_lottie = __commonJS({
"node_modules/lottie-web/build/player/lottie.js"(exports, module) {
"use strict";
typeof navigator !== "undefined" && function(global2, factory) {
typeof exports === "object" && typeof module !== "undefined" ? module.exports = factory() : typeof define === "function" && define.amd ? define(factory) : (global2 = typeof globalThis !== "undefined" ? globalThis : global2 || self, global2.lottie = factory());
}(exports, function() {
"use strict";
var svgNS = "http://www.w3.org/2000/svg";
var locationHref = "";
var _useWebWorker = false;
var initialDefaultFrame = -999999;
var setWebWorker = function setWebWorker2(flag) {
_useWebWorker = !!flag;
};
var getWebWorker = function getWebWorker2() {
return _useWebWorker;
};
var setLocationHref = function setLocationHref2(value2) {
locationHref = value2;
};
var getLocationHref = function getLocationHref2() {
return locationHref;
};
function createTag(type) {
return document.createElement(type);
}
function extendPrototype(sources, destination) {
var i;
var len = sources.length;
var sourcePrototype;
for (i = 0; i < len; i += 1) {
sourcePrototype = sources[i].prototype;
for (var attr in sourcePrototype) {
if (Object.prototype.hasOwnProperty.call(sourcePrototype, attr))
destination.prototype[attr] = sourcePrototype[attr];
}
}
}
function getDescriptor(object, prop) {
return Object.getOwnPropertyDescriptor(object, prop);
}
function createProxyFunction(prototype) {
function ProxyFunction() {
}
ProxyFunction.prototype = prototype;
return ProxyFunction;
}
var audioControllerFactory = function() {
function AudioController(audioFactory) {
this.audios = [];
this.audioFactory = audioFactory;
this._volume = 1;
this._isMuted = false;
}
AudioController.prototype = {
addAudio: function addAudio(audio) {
this.audios.push(audio);
},
pause: function pause() {
var i;
var len = this.audios.length;
for (i = 0; i < len; i += 1) {
this.audios[i].pause();
}
},
resume: function resume() {
var i;
var len = this.audios.length;
for (i = 0; i < len; i += 1) {
this.audios[i].resume();
}
},
setRate: function setRate(rateValue) {
var i;
var len = this.audios.length;
for (i = 0; i < len; i += 1) {
this.audios[i].setRate(rateValue);
}
},
createAudio: function createAudio(assetPath) {
if (this.audioFactory) {
return this.audioFactory(assetPath);
}
if (window.Howl) {
return new window.Howl({
src: [assetPath]
});
}
return {
isPlaying: false,
play: function play() {
this.isPlaying = true;
},
seek: function seek() {
this.isPlaying = false;
},
playing: function playing() {
},
rate: function rate() {
},
setVolume: function setVolume() {
}
};
},
setAudioFactory: function setAudioFactory(audioFactory) {
this.audioFactory = audioFactory;
},
setVolume: function setVolume(value2) {
this._volume = value2;
this._updateVolume();
},
mute: function mute() {
this._isMuted = true;
this._updateVolume();
},
unmute: function unmute() {
this._isMuted = false;
this._updateVolume();
},
getVolume: function getVolume() {
return this._volume;
},
_updateVolume: function _updateVolume() {
var i;
var len = this.audios.length;
for (i = 0; i < len; i += 1) {
this.audios[i].volume(this._volume * (this._isMuted ? 0 : 1));
}
}
};
return function() {
return new AudioController();
};
}();
var createTypedArray = function() {
function createRegularArray(type, len) {
var i = 0;
var arr = [];
var value2;
switch (type) {
case "int16":
case "uint8c":
value2 = 1;
break;
default:
value2 = 1.1;
break;
}
for (i = 0; i < len; i += 1) {
arr.push(value2);
}
return arr;
}
function createTypedArrayFactory(type, len) {
if (type === "float32") {
return new Float32Array(len);
}
if (type === "int16") {
return new Int16Array(len);
}
if (type === "uint8c") {
return new Uint8ClampedArray(len);
}
return createRegularArray(type, len);
}
if (typeof Uint8ClampedArray === "function" && typeof Float32Array === "function") {
return createTypedArrayFactory;
}
return createRegularArray;
}();
function createSizedArray(len) {
return Array.apply(null, {
length: len
});
}
function _typeof$6(obj) {
"@babel/helpers - typeof";
if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
_typeof$6 = function _typeof2(obj2) {
return typeof obj2;
};
} else {
_typeof$6 = function _typeof2(obj2) {
return obj2 && typeof Symbol === "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
};
}
return _typeof$6(obj);
}
var subframeEnabled = true;
var expressionsPlugin = null;
var expressionsInterfaces = null;
var idPrefix$1 = "";
var isSafari = /^((?!chrome|android).)*safari/i.test(navigator.userAgent);
var _shouldRoundValues = false;
var bmPow = Math.pow;
var bmSqrt = Math.sqrt;
var bmFloor = Math.floor;
var bmMax = Math.max;
var bmMin = Math.min;
var BMMath = {};
(function() {
var propertyNames = ["abs", "acos", "acosh", "asin", "asinh", "atan", "atanh", "atan2", "ceil", "cbrt", "expm1", "clz32", "cos", "cosh", "exp", "floor", "fround", "hypot", "imul", "log", "log1p", "log2", "log10", "max", "min", "pow", "random", "round", "sign", "sin", "sinh", "sqrt", "tan", "tanh", "trunc", "E", "LN10", "LN2", "LOG10E", "LOG2E", "PI", "SQRT1_2", "SQRT2"];
var i;
var len = propertyNames.length;
for (i = 0; i < len; i += 1) {
BMMath[propertyNames[i]] = Math[propertyNames[i]];
}
})();
function ProjectInterface$1() {
return {};
}
BMMath.random = Math.random;
BMMath.abs = function(val2) {
var tOfVal = _typeof$6(val2);
if (tOfVal === "object" && val2.length) {
var absArr = createSizedArray(val2.length);
var i;
var len = val2.length;
for (i = 0; i < len; i += 1) {
absArr[i] = Math.abs(val2[i]);
}
return absArr;
}
return Math.abs(val2);
};
var defaultCurveSegments = 150;
var degToRads = Math.PI / 180;
var roundCorner = 0.5519;
function roundValues(flag) {
_shouldRoundValues = !!flag;
}
function bmRnd(value2) {
if (_shouldRoundValues) {
return Math.round(value2);
}
return value2;
}
function styleDiv(element) {
element.style.position = "absolute";
element.style.top = 0;
element.style.left = 0;
element.style.display = "block";
element.style.transformOrigin = "0 0";
element.style.webkitTransformOrigin = "0 0";
element.style.backfaceVisibility = "visible";
element.style.webkitBackfaceVisibility = "visible";
element.style.transformStyle = "preserve-3d";
element.style.webkitTransformStyle = "preserve-3d";
element.style.mozTransformStyle = "preserve-3d";
}
function BMEnterFrameEvent(type, currentTime, totalTime, frameMultiplier) {
this.type = type;
this.currentTime = currentTime;
this.totalTime = totalTime;
this.direction = frameMultiplier < 0 ? -1 : 1;
}
function BMCompleteEvent(type, frameMultiplier) {
this.type = type;
this.direction = frameMultiplier < 0 ? -1 : 1;
}
function BMCompleteLoopEvent(type, totalLoops, currentLoop, frameMultiplier) {
this.type = type;
this.currentLoop = currentLoop;
this.totalLoops = totalLoops;
this.direction = frameMultiplier < 0 ? -1 : 1;
}
function BMSegmentStartEvent(type, firstFrame, totalFrames) {
this.type = type;
this.firstFrame = firstFrame;
this.totalFrames = totalFrames;
}
function BMDestroyEvent(type, target) {
this.type = type;
this.target = target;
}
function BMRenderFrameErrorEvent(nativeError, currentTime) {
this.type = "renderFrameError";
this.nativeError = nativeError;
this.currentTime = currentTime;
}
function BMConfigErrorEvent(nativeError) {
this.type = "configError";
this.nativeError = nativeError;
}
function BMAnimationConfigErrorEvent(type, nativeError) {
this.type = type;
this.nativeError = nativeError;
}
var createElementID = /* @__PURE__ */ function() {
var _count = 0;
return function createID() {
_count += 1;
return idPrefix$1 + "__lottie_element_" + _count;
};
}();
function HSVtoRGB(h, s, v) {
var r;
var g;
var b;
var i;
var f;
var p;
var q;
var t;
i = Math.floor(h * 6);
f = h * 6 - i;
p = v * (1 - s);
q = v * (1 - f * s);
t = v * (1 - (1 - f) * s);
switch (i % 6) {
case 0:
r = v;
g = t;
b = p;
break;
case 1:
r = q;
g = v;
b = p;
break;
case 2:
r = p;
g = v;
b = t;
break;
case 3:
r = p;
g = q;
b = v;
break;
case 4:
r = t;
g = p;
b = v;
break;
case 5:
r = v;
g = p;
b = q;
break;
default:
break;
}
return [r, g, b];
}
function RGBtoHSV(r, g, b) {
var max = Math.max(r, g, b);
var min = Math.min(r, g, b);
var d = max - min;
var h;
var s = max === 0 ? 0 : d / max;
var v = max / 255;
switch (max) {
case min:
h = 0;
break;
case r:
h = g - b + d * (g < b ? 6 : 0);
h /= 6 * d;
break;
case g:
h = b - r + d * 2;
h /= 6 * d;
break;
case b:
h = r - g + d * 4;
h /= 6 * d;
break;
default:
break;
}
return [h, s, v];
}
function addSaturationToRGB(color, offset) {
var hsv = RGBtoHSV(color[0] * 255, color[1] * 255, color[2] * 255);
hsv[1] += offset;
if (hsv[1] > 1) {
hsv[1] = 1;
} else if (hsv[1] <= 0) {
hsv[1] = 0;
}
return HSVtoRGB(hsv[0], hsv[1], hsv[2]);
}
function addBrightnessToRGB(color, offset) {
var hsv = RGBtoHSV(color[0] * 255, color[1] * 255, color[2] * 255);
hsv[2] += offset;
if (hsv[2] > 1) {
hsv[2] = 1;
} else if (hsv[2] < 0) {
hsv[2] = 0;
}
return HSVtoRGB(hsv[0], hsv[1], hsv[2]);
}
function addHueToRGB(color, offset) {
var hsv = RGBtoHSV(color[0] * 255, color[1] * 255, color[2] * 255);
hsv[0] += offset / 360;
if (hsv[0] > 1) {
hsv[0] -= 1;
} else if (hsv[0] < 0) {
hsv[0] += 1;
}
return HSVtoRGB(hsv[0], hsv[1], hsv[2]);
}
var rgbToHex = function() {
var colorMap = [];
var i;
var hex;
for (i = 0; i < 256; i += 1) {
hex = i.toString(16);
colorMap[i] = hex.length === 1 ? "0" + hex : hex;
}
return function(r, g, b) {
if (r < 0) {
r = 0;
}
if (g < 0) {
g = 0;
}
if (b < 0) {
b = 0;
}
return "#" + colorMap[r] + colorMap[g] + colorMap[b];
};
}();
var setSubframeEnabled = function setSubframeEnabled2(flag) {
subframeEnabled = !!flag;
};
var getSubframeEnabled = function getSubframeEnabled2() {
return subframeEnabled;
};
var setExpressionsPlugin = function setExpressionsPlugin2(value2) {
expressionsPlugin = value2;
};
var getExpressionsPlugin = function getExpressionsPlugin2() {
return expressionsPlugin;
};
var setExpressionInterfaces = function setExpressionInterfaces2(value2) {
expressionsInterfaces = value2;
};
var getExpressionInterfaces = function getExpressionInterfaces2() {
return expressionsInterfaces;
};
var setDefaultCurveSegments = function setDefaultCurveSegments2(value2) {
defaultCurveSegments = value2;
};
var getDefaultCurveSegments = function getDefaultCurveSegments2() {
return defaultCurveSegments;
};
var setIdPrefix = function setIdPrefix2(value2) {
idPrefix$1 = value2;
};
var getIdPrefix = function getIdPrefix2() {
return idPrefix$1;
};
function createNS(type) {
return document.createElementNS(svgNS, type);
}
function _typeof$5(obj) {
"@babel/helpers - typeof";
if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
_typeof$5 = function _typeof2(obj2) {
return typeof obj2;
};
} else {
_typeof$5 = function _typeof2(obj2) {
return obj2 && typeof Symbol === "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
};
}
return _typeof$5(obj);
}
var dataManager = /* @__PURE__ */ function() {
var _counterId = 1;
var processes = [];
var workerFn;
var workerInstance;
var workerProxy = {
onmessage: function onmessage() {
},
postMessage: function postMessage(path) {
workerFn({
data: path
});
}
};
var _workerSelf = {
postMessage: function postMessage(data2) {
workerProxy.onmessage({
data: data2
});
}
};
function createWorker(fn) {
if (window.Worker && window.Blob && getWebWorker()) {
var blob = new Blob(["var _workerSelf = self; self.onmessage = ", fn.toString()], {
type: "text/javascript"
});
var url = URL.createObjectURL(blob);
return new Worker(url);
}
workerFn = fn;
return workerProxy;
}
function setupWorker() {
if (!workerInstance) {
workerInstance = createWorker(function workerStart(e) {
function dataFunctionManager() {
function completeLayers(layers, comps) {
var layerData;
var i;
var len = layers.length;
var j;
var jLen;
var k;
var kLen;
for (i = 0; i < len; i += 1) {
layerData = layers[i];
if ("ks" in layerData && !layerData.completed) {
layerData.completed = true;
if (layerData.hasMask) {
var maskProps = layerData.masksProperties;
jLen = maskProps.length;
for (j = 0; j < jLen; j += 1) {
if (maskProps[j].pt.k.i) {
convertPathsToAbsoluteValues(maskProps[j].pt.k);
} else {
kLen = maskProps[j].pt.k.length;
for (k = 0; k < kLen; k += 1) {
if (maskProps[j].pt.k[k].s) {
convertPathsToAbsoluteValues(maskProps[j].pt.k[k].s[0]);
}
if (maskProps[j].pt.k[k].e) {
convertPathsToAbsoluteValues(maskProps[j].pt.k[k].e[0]);
}
}
}
}
}
if (layerData.ty === 0) {
layerData.layers = findCompLayers(layerData.refId, comps);
completeLayers(layerData.layers, comps);
} else if (layerData.ty === 4) {
completeShapes(layerData.shapes);
} else if (layerData.ty === 5) {
completeText(layerData);
}
}
}
}
function completeChars(chars, assets) {
if (chars) {
var i = 0;
var len = chars.length;
for (i = 0; i < len; i += 1) {
if (chars[i].t === 1) {
chars[i].data.layers = findCompLayers(chars[i].data.refId, assets);
completeLayers(chars[i].data.layers, assets);
}
}
}
}
function findComp(id, comps) {
var i = 0;
var len = comps.length;
while (i < len) {
if (comps[i].id === id) {
return comps[i];
}
i += 1;
}
return null;
}
function findCompLayers(id, comps) {
var comp2 = findComp(id, comps);
if (comp2) {
if (!comp2.layers.__used) {
comp2.layers.__used = true;
return comp2.layers;
}
return JSON.parse(JSON.stringify(comp2.layers));
}
return null;
}
function completeShapes(arr) {
var i;
var len = arr.length;
var j;
var jLen;
for (i = len - 1; i >= 0; i -= 1) {
if (arr[i].ty === "sh") {
if (arr[i].ks.k.i) {
convertPathsToAbsoluteValues(arr[i].ks.k);
} else {
jLen = arr[i].ks.k.length;
for (j = 0; j < jLen; j += 1) {
if (arr[i].ks.k[j].s) {
convertPathsToAbsoluteValues(arr[i].ks.k[j].s[0]);
}
if (arr[i].ks.k[j].e) {
convertPathsToAbsoluteValues(arr[i].ks.k[j].e[0]);
}
}
}
} else if (arr[i].ty === "gr") {
completeShapes(arr[i].it);
}
}
}
function convertPathsToAbsoluteValues(path) {
var i;
var len = path.i.length;
for (i = 0; i < len; i += 1) {
path.i[i][0] += path.v[i][0];
path.i[i][1] += path.v[i][1];
path.o[i][0] += path.v[i][0];
path.o[i][1] += path.v[i][1];
}
}
function checkVersion(minimum, animVersionString) {
var animVersion = animVersionString ? animVersionString.split(".") : [100, 100, 100];
if (minimum[0] > animVersion[0]) {
return true;
}
if (animVersion[0] > minimum[0]) {
return false;
}
if (minimum[1] > animVersion[1]) {
return true;
}
if (animVersion[1] > minimum[1]) {
return false;
}
if (minimum[2] > animVersion[2]) {
return true;
}
if (animVersion[2] > minimum[2]) {
return false;
}
return null;
}
var checkText = /* @__PURE__ */ function() {
var minimumVersion = [4, 4, 14];
function updateTextLayer(textLayer) {
var documentData = textLayer.t.d;
textLayer.t.d = {
k: [{
s: documentData,
t: 0
}]
};
}
function iterateLayers(layers) {
var i;
var len = layers.length;
for (i = 0; i < len; i += 1) {
if (layers[i].ty === 5) {
updateTextLayer(layers[i]);
}
}
}
return function(animationData2) {
if (checkVersion(minimumVersion, animationData2.v)) {
iterateLayers(animationData2.layers);
if (animationData2.assets) {
var i;
var len = animationData2.assets.length;
for (i = 0; i < len; i += 1) {
if (animationData2.assets[i].layers) {
iterateLayers(animationData2.assets[i].layers);
}
}
}
}
};
}();
var checkChars = /* @__PURE__ */ function() {
var minimumVersion = [4, 7, 99];
return function(animationData2) {
if (animationData2.chars && !checkVersion(minimumVersion, animationData2.v)) {
var i;
var len = animationData2.chars.length;
for (i = 0; i < len; i += 1) {
var charData = animationData2.chars[i];
if (charData.data && charData.data.shapes) {
completeShapes(charData.data.shapes);
charData.data.ip = 0;
charData.data.op = 99999;
charData.data.st = 0;
charData.data.sr = 1;
charData.data.ks = {
p: {
k: [0, 0],
a: 0
},
s: {
k: [100, 100],
a: 0
},
a: {
k: [0, 0],
a: 0
},
r: {
k: 0,
a: 0
},
o: {
k: 100,
a: 0
}
};
if (!animationData2.chars[i].t) {
charData.data.shapes.push({
ty: "no"
});
charData.data.shapes[0].it.push({
p: {
k: [0, 0],
a: 0
},
s: {
k: [100, 100],
a: 0
},
a: {
k: [0, 0],
a: 0
},
r: {
k: 0,
a: 0
},
o: {
k: 100,
a: 0
},
sk: {
k: 0,
a: 0
},
sa: {
k: 0,
a: 0
},
ty: "tr"
});
}
}
}
}
};
}();
var checkPathProperties = /* @__PURE__ */ function() {
var minimumVersion = [5, 7, 15];
function updateTextLayer(textLayer) {
var pathData = textLayer.t.p;
if (typeof pathData.a === "number") {
pathData.a = {
a: 0,
k: pathData.a
};
}
if (typeof pathData.p === "number") {
pathData.p = {
a: 0,
k: pathData.p
};
}
if (typeof pathData.r === "number") {
pathData.r = {
a: 0,
k: pathData.r
};
}
}
function iterateLayers(layers) {
var i;
var len = layers.length;
for (i = 0; i < len; i += 1) {
if (layers[i].ty === 5) {
updateTextLayer(layers[i]);
}
}
}
return function(animationData2) {
if (checkVersion(minimumVersion, animationData2.v)) {
iterateLayers(animationData2.layers);
if (animationData2.assets) {
var i;
var len = animationData2.assets.length;
for (i = 0; i < len; i += 1) {
if (animationData2.assets[i].layers) {
iterateLayers(animationData2.assets[i].layers);
}
}
}
}
};
}();
var checkColors = /* @__PURE__ */ function() {
var minimumVersion = [4, 1, 9];
function iterateShapes(shapes) {
var i;
var len = shapes.length;
var j;
var jLen;
for (i = 0; i < len; i += 1) {
if (shapes[i].ty === "gr") {
iterateShapes(shapes[i].it);
} else if (shapes[i].ty === "fl" || shapes[i].ty === "st") {
if (shapes[i].c.k && shapes[i].c.k[0].i) {
jLen = shapes[i].c.k.length;
for (j = 0; j < jLen; j += 1) {
if (shapes[i].c.k[j].s) {
shapes[i].c.k[j].s[0] /= 255;
shapes[i].c.k[j].s[1] /= 255;
shapes[i].c.k[j].s[2] /= 255;
shapes[i].c.k[j].s[3] /= 255;
}
if (shapes[i].c.k[j].e) {
shapes[i].c.k[j].e[0] /= 255;
shapes[i].c.k[j].e[1] /= 255;
shapes[i].c.k[j].e[2] /= 255;
shapes[i].c.k[j].e[3] /= 255;
}
}
} else {
shapes[i].c.k[0] /= 255;
shapes[i].c.k[1] /= 255;
shapes[i].c.k[2] /= 255;
shapes[i].c.k[3] /= 255;
}
}
}
}
function iterateLayers(layers) {
var i;
var len = layers.length;
for (i = 0; i < len; i += 1) {
if (layers[i].ty === 4) {
iterateShapes(layers[i].shapes);
}
}
}
return function(animationData2) {
if (checkVersion(minimumVersion, animationData2.v)) {
iterateLayers(animationData2.layers);
if (animationData2.assets) {
var i;
var len = animationData2.assets.length;
for (i = 0; i < len; i += 1) {
if (animationData2.assets[i].layers) {
iterateLayers(animationData2.assets[i].layers);
}
}
}
}
};
}();
var checkShapes = /* @__PURE__ */ function() {
var minimumVersion = [4, 4, 18];
function completeClosingShapes(arr) {
var i;
var len = arr.length;
var j;
var jLen;
for (i = len - 1; i >= 0; i -= 1) {
if (arr[i].ty === "sh") {
if (arr[i].ks.k.i) {
arr[i].ks.k.c = arr[i].closed;
} else {
jLen = arr[i].ks.k.length;
for (j = 0; j < jLen; j += 1) {
if (arr[i].ks.k[j].s) {
arr[i].ks.k[j].s[0].c = arr[i].closed;
}
if (arr[i].ks.k[j].e) {
arr[i].ks.k[j].e[0].c = arr[i].closed;
}
}
}
} else if (arr[i].ty === "gr") {
completeClosingShapes(arr[i].it);
}
}
}
function iterateLayers(layers) {
var layerData;
var i;
var len = layers.length;
var j;
var jLen;
var k;
var kLen;
for (i = 0; i < len; i += 1) {
layerData = layers[i];
if (layerData.hasMask) {
var maskProps = layerData.masksProperties;
jLen = maskProps.length;
for (j = 0; j < jLen; j += 1) {
if (maskProps[j].pt.k.i) {
maskProps[j].pt.k.c = maskProps[j].cl;
} else {
kLen = maskProps[j].pt.k.length;
for (k = 0; k < kLen; k += 1) {
if (maskProps[j].pt.k[k].s) {
maskProps[j].pt.k[k].s[0].c = maskProps[j].cl;
}
if (maskProps[j].pt.k[k].e) {
maskProps[j].pt.k[k].e[0].c = maskProps[j].cl;
}
}
}
}
}
if (layerData.ty === 4) {
completeClosingShapes(layerData.shapes);
}
}
}
return function(animationData2) {
if (checkVersion(minimumVersion, animationData2.v)) {
iterateLayers(animationData2.layers);
if (animationData2.assets) {
var i;
var len = animationData2.assets.length;
for (i = 0; i < len; i += 1) {
if (animationData2.assets[i].layers) {
iterateLayers(animationData2.assets[i].layers);
}
}
}
}
};
}();
function completeData(animationData2) {
if (animationData2.__complete) {
return;
}
checkColors(animationData2);
checkText(animationData2);
checkChars(animationData2);
checkPathProperties(animationData2);
checkShapes(animationData2);
completeLayers(animationData2.layers, animationData2.assets);
completeChars(animationData2.chars, animationData2.assets);
animationData2.__complete = true;
}
function completeText(data2) {
if (data2.t.a.length === 0 && !("m" in data2.t.p)) {
}
}
var moduleOb = {};
moduleOb.completeData = completeData;
moduleOb.checkColors = checkColors;
moduleOb.checkChars = checkChars;
moduleOb.checkPathProperties = checkPathProperties;
moduleOb.checkShapes = checkShapes;
moduleOb.completeLayers = completeLayers;
return moduleOb;
}
if (!_workerSelf.dataManager) {
_workerSelf.dataManager = dataFunctionManager();
}
if (!_workerSelf.assetLoader) {
_workerSelf.assetLoader = /* @__PURE__ */ function() {
function formatResponse(xhr) {
var contentTypeHeader = xhr.getResponseHeader("content-type");
if (contentTypeHeader && xhr.responseType === "json" && contentTypeHeader.indexOf("json") !== -1) {
return xhr.response;
}
if (xhr.response && _typeof$5(xhr.response) === "object") {
return xhr.response;
}
if (xhr.response && typeof xhr.response === "string") {
return JSON.parse(xhr.response);
}
if (xhr.responseText) {
return JSON.parse(xhr.responseText);
}
return null;
}
function loadAsset(path, fullPath, callback, errorCallback) {
var response;
var xhr = new XMLHttpRequest();
try {
xhr.responseType = "json";
} catch (err) {
}
xhr.onreadystatechange = function() {
if (xhr.readyState === 4) {
if (xhr.status === 200) {
response = formatResponse(xhr);
callback(response);
} else {
try {
response = formatResponse(xhr);
callback(response);
} catch (err) {
if (errorCallback) {
errorCallback(err);
}
}
}
}
};
try {
xhr.open(["G", "E", "T"].join(""), path, true);
} catch (error) {
xhr.open(["G", "E", "T"].join(""), fullPath + "/" + path, true);
}
xhr.send();
}
return {
load: loadAsset
};
}();
}
if (e.data.type === "loadAnimation") {
_workerSelf.assetLoader.load(e.data.path, e.data.fullPath, function(data2) {
_workerSelf.dataManager.completeData(data2);
_workerSelf.postMessage({
id: e.data.id,
payload: data2,
status: "success"
});
}, function() {
_workerSelf.postMessage({
id: e.data.id,
status: "error"
});
});
} else if (e.data.type === "complete") {
var animation = e.data.animation;
_workerSelf.dataManager.completeData(animation);
_workerSelf.postMessage({
id: e.data.id,
payload: animation,
status: "success"
});
} else if (e.data.type === "loadData") {
_workerSelf.assetLoader.load(e.data.path, e.data.fullPath, function(data2) {
_workerSelf.postMessage({
id: e.data.id,
payload: data2,
status: "success"
});
}, function() {
_workerSelf.postMessage({
id: e.data.id,
status: "error"
});
});
}
});
workerInstance.onmessage = function(event) {
var data2 = event.data;
var id = data2.id;
var process3 = processes[id];
processes[id] = null;
if (data2.status === "success") {
process3.onComplete(data2.payload);
} else if (process3.onError) {
process3.onError();
}
};
}
}
function createProcess(onComplete, onError) {
_counterId += 1;
var id = "processId_" + _counterId;
processes[id] = {
onComplete,
onError
};
return id;
}
function loadAnimation2(path, onComplete, onError) {
setupWorker();
var processId = createProcess(onComplete, onError);
workerInstance.postMessage({
type: "loadAnimation",
path,
fullPath: window.location.origin + window.location.pathname,
id: processId
});
}
function loadData(path, onComplete, onError) {
setupWorker();
var processId = createProcess(onComplete, onError);
workerInstance.postMessage({
type: "loadData",
path,
fullPath: window.location.origin + window.location.pathname,
id: processId
});
}
function completeAnimation(anim, onComplete, onError) {
setupWorker();
var processId = createProcess(onComplete, onError);
workerInstance.postMessage({
type: "complete",
animation: anim,
id: processId
});
}
return {
loadAnimation: loadAnimation2,
loadData,
completeAnimation
};
}();
var ImagePreloader = function() {
var proxyImage = function() {
var canvas = createTag("canvas");
canvas.width = 1;
canvas.height = 1;
var ctx = canvas.getContext("2d");
ctx.fillStyle = "rgba(0,0,0,0)";
ctx.fillRect(0, 0, 1, 1);
return canvas;
}();
function imageLoaded() {
this.loadedAssets += 1;
if (this.loadedAssets === this.totalImages && this.loadedFootagesCount === this.totalFootages) {
if (this.imagesLoadedCb) {
this.imagesLoadedCb(null);
}
}
}
function footageLoaded() {
this.loadedFootagesCount += 1;
if (this.loadedAssets === this.totalImages && this.loadedFootagesCount === this.totalFootages) {
if (this.imagesLoadedCb) {
this.imagesLoadedCb(null);
}
}
}
function getAssetsPath(assetData, assetsPath, originalPath) {
var path = "";
if (assetData.e) {
path = assetData.p;
} else if (assetsPath) {
var imagePath = assetData.p;
if (imagePath.indexOf("images/") !== -1) {
imagePath = imagePath.split("/")[1];
}
path = assetsPath + imagePath;
} else {
path = originalPath;
path += assetData.u ? assetData.u : "";
path += assetData.p;
}
return path;
}
function testImageLoaded(img) {
var _count = 0;
var intervalId = setInterval((function() {
var box = img.getBBox();
if (box.width || _count > 500) {
this._imageLoaded();
clearInterval(intervalId);
}
_count += 1;
}).bind(this), 50);
}
function createImageData(assetData) {
var path = getAssetsPath(assetData, this.assetsPath, this.path);
var img = createNS("image");
if (isSafari) {
this.testImageLoaded(img);
} else {
img.addEventListener("load", this._imageLoaded, false);
}
img.addEventListener("error", (function() {
ob2.img = proxyImage;
this._imageLoaded();
}).bind(this), false);
img.setAttributeNS("http://www.w3.org/1999/xlink", "href", path);
if (this._elementHelper.append) {
this._elementHelper.append(img);
} else {
this._elementHelper.appendChild(img);
}
var ob2 = {
img,
assetData
};
return ob2;
}
function createImgData(assetData) {
var path = getAssetsPath(assetData, this.assetsPath, this.path);
var img = createTag("img");
img.crossOrigin = "anonymous";
img.addEventListener("load", this._imageLoaded, false);
img.addEventListener("error", (function() {
ob2.img = proxyImage;
this._imageLoaded();
}).bind(this), false);
img.src = path;
var ob2 = {
img,
assetData
};
return ob2;
}
function createFootageData(data2) {
var ob2 = {
assetData: data2
};
var path = getAssetsPath(data2, this.assetsPath, this.path);
dataManager.loadData(path, (function(footageData) {
ob2.img = footageData;
this._footageLoaded();
}).bind(this), (function() {
ob2.img = {};
this._footageLoaded();
}).bind(this));
return ob2;
}
function loadAssets(assets, cb) {
this.imagesLoadedCb = cb;
var i;
var len = assets.length;
for (i = 0; i < len; i += 1) {
if (!assets[i].layers) {
if (!assets[i].t || assets[i].t === "seq") {
this.totalImages += 1;
this.images.push(this._createImageData(assets[i]));
} else if (assets[i].t === 3) {
this.totalFootages += 1;
this.images.push(this.createFootageData(assets[i]));
}
}
}
}
function setPath(path) {
this.path = path || "";
}
function setAssetsPath(path) {
this.assetsPath = path || "";
}
function getAsset(assetData) {
var i = 0;
var len = this.images.length;
while (i < len) {
if (this.images[i].assetData === assetData) {
return this.images[i].img;
}
i += 1;
}
return null;
}
function destroy() {
this.imagesLoadedCb = null;
this.images.length = 0;
}
function loadedImages() {
return this.totalImages === this.loadedAssets;
}
function loadedFootages() {
return this.totalFootages === this.loadedFootagesCount;
}
function setCacheType(type, elementHelper) {
if (type === "svg") {
this._elementHelper = elementHelper;
this._createImageData = this.createImageData.bind(this);
} else {
this._createImageData = this.createImgData.bind(this);
}
}
function ImagePreloaderFactory() {
this._imageLoaded = imageLoaded.bind(this);
this._footageLoaded = footageLoaded.bind(this);
this.testImageLoaded = testImageLoaded.bind(this);
this.createFootageData = createFootageData.bind(this);
this.assetsPath = "";
this.path = "";
this.totalImages = 0;
this.totalFootages = 0;
this.loadedAssets = 0;
this.loadedFootagesCount = 0;
this.imagesLoadedCb = null;
this.images = [];
}
ImagePreloaderFactory.prototype = {
loadAssets,
setAssetsPath,
setPath,
loadedImages,
loadedFootages,
destroy,
getAsset,
createImgData,
createImageData,
imageLoaded,
footageLoaded,
setCacheType
};
return ImagePreloaderFactory;
}();
function BaseEvent() {
}
BaseEvent.prototype = {
triggerEvent: function triggerEvent(eventName, args) {
if (this._cbs[eventName]) {
var callbacks = this._cbs[eventName];
for (var i = 0; i < callbacks.length; i += 1) {
callbacks[i](args);
}
}
},
addEventListener: function addEventListener(eventName, callback) {
if (!this._cbs[eventName]) {
this._cbs[eventName] = [];
}
this._cbs[eventName].push(callback);
return (function() {
this.removeEventListener(eventName, callback);
}).bind(this);
},
removeEventListener: function removeEventListener(eventName, callback) {
if (!callback) {
this._cbs[eventName] = null;
} else if (this._cbs[eventName]) {
var i = 0;
var len = this._cbs[eventName].length;
while (i < len) {
if (this._cbs[eventName][i] === callback) {
this._cbs[eventName].splice(i, 1);
i -= 1;
len -= 1;
}
i += 1;
}
if (!this._cbs[eventName].length) {
this._cbs[eventName] = null;
}
}
}
};
var markerParser = /* @__PURE__ */ function() {
function parsePayloadLines(payload) {
var lines = payload.split("\r\n");
var keys = {};
var line;
var keysCount = 0;
for (var i = 0; i < lines.length; i += 1) {
line = lines[i].split(":");
if (line.length === 2) {
keys[line[0]] = line[1].trim();
keysCount += 1;
}
}
if (keysCount === 0) {
throw new Error();
}
return keys;
}
return function(_markers) {
var markers = [];
for (var i = 0; i < _markers.length; i += 1) {
var _marker = _markers[i];
var markerData = {
time: _marker.tm,
duration: _marker.dr
};
try {
markerData.payload = JSON.parse(_markers[i].cm);
} catch (_) {
try {
markerData.payload = parsePayloadLines(_markers[i].cm);
} catch (__) {
markerData.payload = {
name: _markers[i].cm
};
}
}
markers.push(markerData);
}
return markers;
};
}();
var ProjectInterface = /* @__PURE__ */ function() {
function registerComposition(comp2) {
this.compositions.push(comp2);
}
return function() {
function _thisProjectFunction(name2) {
var i = 0;
var len = this.compositions.length;
while (i < len) {
if (this.compositions[i].data && this.compositions[i].data.nm === name2) {
if (this.compositions[i].prepareFrame && this.compositions[i].data.xt) {
this.compositions[i].prepareFrame(this.currentFrame);
}
return this.compositions[i].compInterface;
}
i += 1;
}
return null;
}
_thisProjectFunction.compositions = [];
_thisProjectFunction.currentFrame = 0;
_thisProjectFunction.registerComposition = registerComposition;
return _thisProjectFunction;
};
}();
var renderers = {};
var registerRenderer = function registerRenderer2(key2, value2) {
renderers[key2] = value2;
};
function getRenderer(key2) {
return renderers[key2];
}
function getRegisteredRenderer() {
if (renderers.canvas) {
return "canvas";
}
for (var key2 in renderers) {
if (renderers[key2]) {
return key2;
}
}
return "";
}
function _typeof$4(obj) {
"@babel/helpers - typeof";
if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
_typeof$4 = function _typeof2(obj2) {
return typeof obj2;
};
} else {
_typeof$4 = function _typeof2(obj2) {
return obj2 && typeof Symbol === "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
};
}
return _typeof$4(obj);
}
var AnimationItem = function AnimationItem2() {
this._cbs = [];
this.name = "";
this.path = "";
this.isLoaded = false;
this.currentFrame = 0;
this.currentRawFrame = 0;
this.firstFrame = 0;
this.totalFrames = 0;
this.frameRate = 0;
this.frameMult = 0;
this.playSpeed = 1;
this.playDirection = 1;
this.playCount = 0;
this.animationData = {};
this.assets = [];
this.isPaused = true;
this.autoplay = false;
this.loop = true;
this.renderer = null;
this.animationID = createElementID();
this.assetsPath = "";
this.timeCompleted = 0;
this.segmentPos = 0;
this.isSubframeEnabled = getSubframeEnabled();
this.segments = [];
this._idle = true;
this._completedLoop = false;
this.projectInterface = ProjectInterface();
this.imagePreloader = new ImagePreloader();
this.audioController = audioControllerFactory();
this.markers = [];
this.configAnimation = this.configAnimation.bind(this);
this.onSetupError = this.onSetupError.bind(this);
this.onSegmentComplete = this.onSegmentComplete.bind(this);
this.drawnFrameEvent = new BMEnterFrameEvent("drawnFrame", 0, 0, 0);
this.expressionsPlugin = getExpressionsPlugin();
};
extendPrototype([BaseEvent], AnimationItem);
AnimationItem.prototype.setParams = function(params) {
if (params.wrapper || params.container) {
this.wrapper = params.wrapper || params.container;
}
var animType = "svg";
if (params.animType) {
animType = params.animType;
} else if (params.renderer) {
animType = params.renderer;
}
var RendererClass = getRenderer(animType);
this.renderer = new RendererClass(this, params.rendererSettings);
this.imagePreloader.setCacheType(animType, this.renderer.globalData.defs);
this.renderer.setProjectInterface(this.projectInterface);
this.animType = animType;
if (params.loop === "" || params.loop === null || params.loop === void 0 || params.loop === true) {
this.loop = true;
} else if (params.loop === false) {
this.loop = false;
} else {
this.loop = parseInt(params.loop, 10);
}
this.autoplay = "autoplay" in params ? params.autoplay : true;
this.name = params.name ? params.name : "";
this.autoloadSegments = Object.prototype.hasOwnProperty.call(params, "autoloadSegments") ? params.autoloadSegments : true;
this.assetsPath = params.assetsPath;
this.initialSegment = params.initialSegment;
if (params.audioFactory) {
this.audioController.setAudioFactory(params.audioFactory);
}
if (params.animationData) {
this.setupAnimation(params.animationData);
} else if (params.path) {
if (params.path.lastIndexOf("\\") !== -1) {
this.path = params.path.substr(0, params.path.lastIndexOf("\\") + 1);
} else {
this.path = params.path.substr(0, params.path.lastIndexOf("/") + 1);
}
this.fileName = params.path.substr(params.path.lastIndexOf("/") + 1);
this.fileName = this.fileName.substr(0, this.fileName.lastIndexOf(".json"));
dataManager.loadAnimation(params.path, this.configAnimation, this.onSetupError);
}
};
AnimationItem.prototype.onSetupError = function() {
this.trigger("data_failed");
};
AnimationItem.prototype.setupAnimation = function(data2) {
dataManager.completeAnimation(data2, this.configAnimation);
};
AnimationItem.prototype.setData = function(wrapper, animationData2) {
if (animationData2) {
if (_typeof$4(animationData2) !== "object") {
animationData2 = JSON.parse(animationData2);
}
}
var params = {
wrapper,
animationData: animationData2
};
var wrapperAttributes = wrapper.attributes;
params.path = wrapperAttributes.getNamedItem("data-animation-path") ? wrapperAttributes.getNamedItem("data-animation-path").value : wrapperAttributes.getNamedItem("data-bm-path") ? wrapperAttributes.getNamedItem("data-bm-path").value : wrapperAttributes.getNamedItem("bm-path") ? wrapperAttributes.getNamedItem("bm-path").value : "";
params.animType = wrapperAttributes.getNamedItem("data-anim-type") ? wrapperAttributes.getNamedItem("data-anim-type").value : wrapperAttributes.getNamedItem("data-bm-type") ? wrapperAttributes.getNamedItem("data-bm-type").value : wrapperAttributes.getNamedItem("bm-type") ? wrapperAttributes.getNamedItem("bm-type").value : wrapperAttributes.getNamedItem("data-bm-renderer") ? wrapperAttributes.getNamedItem("data-bm-renderer").value : wrapperAttributes.getNamedItem("bm-renderer") ? wrapperAttributes.getNamedItem("bm-renderer").value : getRegisteredRenderer() || "canvas";
var loop = wrapperAttributes.getNamedItem("data-anim-loop") ? wrapperAttributes.getNamedItem("data-anim-loop").value : wrapperAttributes.getNamedItem("data-bm-loop") ? wrapperAttributes.getNamedItem("data-bm-loop").value : wrapperAttributes.getNamedItem("bm-loop") ? wrapperAttributes.getNamedItem("bm-loop").value : "";
if (loop === "false") {
params.loop = false;
} else if (loop === "true") {
params.loop = true;
} else if (loop !== "") {
params.loop = parseInt(loop, 10);
}
var autoplay = wrapperAttributes.getNamedItem("data-anim-autoplay") ? wrapperAttributes.getNamedItem("data-anim-autoplay").value : wrapperAttributes.getNamedItem("data-bm-autoplay") ? wrapperAttributes.getNamedItem("data-bm-autoplay").value : wrapperAttributes.getNamedItem("bm-autoplay") ? wrapperAttributes.getNamedItem("bm-autoplay").value : true;
params.autoplay = autoplay !== "false";
params.name = wrapperAttributes.getNamedItem("data-name") ? wrapperAttributes.getNamedItem("data-name").value : wrapperAttributes.getNamedItem("data-bm-name") ? wrapperAttributes.getNamedItem("data-bm-name").value : wrapperAttributes.getNamedItem("bm-name") ? wrapperAttributes.getNamedItem("bm-name").value : "";
var prerender = wrapperAttributes.getNamedItem("data-anim-prerender") ? wrapperAttributes.getNamedItem("data-anim-prerender").value : wrapperAttributes.getNamedItem("data-bm-prerender") ? wrapperAttributes.getNamedItem("data-bm-prerender").value : wrapperAttributes.getNamedItem("bm-prerender") ? wrapperAttributes.getNamedItem("bm-prerender").value : "";
if (prerender === "false") {
params.prerender = false;
}
if (!params.path) {
this.trigger("destroy");
} else {
this.setParams(params);
}
};
AnimationItem.prototype.includeLayers = function(data2) {
if (data2.op > this.animationData.op) {
this.animationData.op = data2.op;
this.totalFrames = Math.floor(data2.op - this.animationData.ip);
}
var layers = this.animationData.layers;
var i;
var len = layers.length;
var newLayers = data2.layers;
var j;
var jLen = newLayers.length;
for (j = 0; j < jLen; j += 1) {
i = 0;
while (i < len) {
if (layers[i].id === newLayers[j].id) {
layers[i] = newLayers[j];
break;
}
i += 1;
}
}
if (data2.chars || data2.fonts) {
this.renderer.globalData.fontManager.addChars(data2.chars);
this.renderer.globalData.fontManager.addFonts(data2.fonts, this.renderer.globalData.defs);
}
if (data2.assets) {
len = data2.assets.length;
for (i = 0; i < len; i += 1) {
this.animationData.assets.push(data2.assets[i]);
}
}
this.animationData.__complete = false;
dataManager.completeAnimation(this.animationData, this.onSegmentComplete);
};
AnimationItem.prototype.onSegmentComplete = function(data2) {
this.animationData = data2;
var expressionsPlugin2 = getExpressionsPlugin();
if (expressionsPlugin2) {
expressionsPlugin2.initExpressions(this);
}
this.loadNextSegment();
};
AnimationItem.prototype.loadNextSegment = function() {
var segments = this.animationData.segments;
if (!segments || segments.length === 0 || !this.autoloadSegments) {
this.trigger("data_ready");
this.timeCompleted = this.totalFrames;
return;
}
var segment = segments.shift();
this.timeCompleted = segment.time * this.frameRate;
var segmentPath = this.path + this.fileName + "_" + this.segmentPos + ".json";
this.segmentPos += 1;
dataManager.loadData(segmentPath, this.includeLayers.bind(this), (function() {
this.trigger("data_failed");
}).bind(this));
};
AnimationItem.prototype.loadSegments = function() {
var segments = this.animationData.segments;
if (!segments) {
this.timeCompleted = this.totalFrames;
}
this.loadNextSegment();
};
AnimationItem.prototype.imagesLoaded = function() {
this.trigger("loaded_images");
this.checkLoaded();
};
AnimationItem.prototype.preloadImages = function() {
this.imagePreloader.setAssetsPath(this.assetsPath);
this.imagePreloader.setPath(this.path);
this.imagePreloader.loadAssets(this.animationData.assets, this.imagesLoaded.bind(this));
};
AnimationItem.prototype.configAnimation = function(animData) {
if (!this.renderer) {
return;
}
try {
this.animationData = animData;
if (this.initialSegment) {
this.totalFrames = Math.floor(this.initialSegment[1] - this.initialSegment[0]);
this.firstFrame = Math.round(this.initialSegment[0]);
} else {
this.totalFrames = Math.floor(this.animationData.op - this.animationData.ip);
this.firstFrame = Math.round(this.animationData.ip);
}
this.renderer.configAnimation(animData);
if (!animData.assets) {
animData.assets = [];
}
this.assets = this.animationData.assets;
this.frameRate = this.animationData.fr;
this.frameMult = this.animationData.fr / 1e3;
this.renderer.searchExtraCompositions(animData.assets);
this.markers = markerParser(animData.markers || []);
this.trigger("config_ready");
this.preloadImages();
this.loadSegments();
this.updaFrameModifier();
this.waitForFontsLoaded();
if (this.isPaused) {
this.audioController.pause();
}
} catch (error) {
this.triggerConfigError(error);
}
};
AnimationItem.prototype.waitForFontsLoaded = function() {
if (!this.renderer) {
return;
}
if (this.renderer.globalData.fontManager.isLoaded) {
this.checkLoaded();
} else {
setTimeout(this.waitForFontsLoaded.bind(this), 20);
}
};
AnimationItem.prototype.checkLoaded = function() {
if (!this.isLoaded && this.renderer.globalData.fontManager.isLoaded && (this.imagePreloader.loadedImages() || this.renderer.rendererType !== "canvas") && this.imagePreloader.loadedFootages()) {
this.isLoaded = true;
var expressionsPlugin2 = getExpressionsPlugin();
if (expressionsPlugin2) {
expressionsPlugin2.initExpressions(this);
}
this.renderer.initItems();
setTimeout((function() {
this.trigger("DOMLoaded");
}).bind(this), 0);
this.gotoFrame();
if (this.autoplay) {
this.play();
}
}
};
AnimationItem.prototype.resize = function(width2, height2) {
var _width = typeof width2 === "number" ? width2 : void 0;
var _height = typeof height2 === "number" ? height2 : void 0;
this.renderer.updateContainerSize(_width, _height);
};
AnimationItem.prototype.setSubframe = function(flag) {
this.isSubframeEnabled = !!flag;
};
AnimationItem.prototype.gotoFrame = function() {
this.currentFrame = this.isSubframeEnabled ? this.currentRawFrame : ~~this.currentRawFrame;
if (this.timeCompleted !== this.totalFrames && this.currentFrame > this.timeCompleted) {
this.currentFrame = this.timeCompleted;
}
this.trigger("enterFrame");
this.renderFrame();
this.trigger("drawnFrame");
};
AnimationItem.prototype.renderFrame = function() {
if (this.isLoaded === false || !this.renderer) {
return;
}
try {
if (this.expressionsPlugin) {
this.expressionsPlugin.resetFrame();
}
this.renderer.renderFrame(this.currentFrame + this.firstFrame);
} catch (error) {
this.triggerRenderFrameError(error);
}
};
AnimationItem.prototype.play = function(name2) {
if (name2 && this.name !== name2) {
return;
}
if (this.isPaused === true) {
this.isPaused = false;
this.trigger("_play");
this.audioController.resume();
if (this._idle) {
this._idle = false;
this.trigger("_active");
}
}
};
AnimationItem.prototype.pause = function(name2) {
if (name2 && this.name !== name2) {
return;
}
if (this.isPaused === false) {
this.isPaused = true;
this.trigger("_pause");
this._idle = true;
this.trigger("_idle");
this.audioController.pause();
}
};
AnimationItem.prototype.togglePause = function(name2) {
if (name2 && this.name !== name2) {
return;
}
if (this.isPaused === true) {
this.play();
} else {
this.pause();
}
};
AnimationItem.prototype.stop = function(name2) {
if (name2 && this.name !== name2) {
return;
}
this.pause();
this.playCount = 0;
this._completedLoop = false;
this.setCurrentRawFrameValue(0);
};
AnimationItem.prototype.getMarkerData = function(markerName) {
var marker;
for (var i = 0; i < this.markers.length; i += 1) {
marker = this.markers[i];
if (marker.payload && marker.payload.name === markerName) {
return marker;
}
}
return null;
};
AnimationItem.prototype.goToAndStop = function(value2, isFrame, name2) {
if (name2 && this.name !== name2) {
return;
}
var numValue = Number(value2);
if (isNaN(numValue)) {
var marker = this.getMarkerData(value2);
if (marker) {
this.goToAndStop(marker.time, true);
}
} else if (isFrame) {
this.setCurrentRawFrameValue(value2);
} else {
this.setCurrentRawFrameValue(value2 * this.frameModifier);
}
this.pause();
};
AnimationItem.prototype.goToAndPlay = function(value2, isFrame, name2) {
if (name2 && this.name !== name2) {
return;
}
var numValue = Number(value2);
if (isNaN(numValue)) {
var marker = this.getMarkerData(value2);
if (marker) {
if (!marker.duration) {
this.goToAndStop(marker.time, true);
} else {
this.playSegments([marker.time, marker.time + marker.duration], true);
}
}
} else {
this.goToAndStop(numValue, isFrame, name2);
}
this.play();
};
AnimationItem.prototype.advanceTime = function(value2) {
if (this.isPaused === true || this.isLoaded === false) {
return;
}
var nextValue = this.currentRawFrame + value2 * this.frameModifier;
var _isComplete = false;
if (nextValue >= this.totalFrames - 1 && this.frameModifier > 0) {
if (!this.loop || this.playCount === this.loop) {
if (!this.checkSegments(nextValue > this.totalFrames ? nextValue % this.totalFrames : 0)) {
_isComplete = true;
nextValue = this.totalFrames - 1;
}
} else if (nextValue >= this.totalFrames) {
this.playCount += 1;
if (!this.checkSegments(nextValue % this.totalFrames)) {
this.setCurrentRawFrameValue(nextValue % this.totalFrames);
this._completedLoop = true;
this.trigger("loopComplete");
}
} else {
this.setCurrentRawFrameValue(nextValue);
}
} else if (nextValue < 0) {
if (!this.checkSegments(nextValue % this.totalFrames)) {
if (this.loop && !(this.playCount-- <= 0 && this.loop !== true)) {
this.setCurrentRawFrameValue(this.totalFrames + nextValue % this.totalFrames);
if (!this._completedLoop) {
this._completedLoop = true;
} else {
this.trigger("loopComplete");
}
} else {
_isComplete = true;
nextValue = 0;
}
}
} else {
this.setCurrentRawFrameValue(nextValue);
}
if (_isComplete) {
this.setCurrentRawFrameValue(nextValue);
this.pause();
this.trigger("complete");
}
};
AnimationItem.prototype.adjustSegment = function(arr, offset) {
this.playCount = 0;
if (arr[1] < arr[0]) {
if (this.frameModifier > 0) {
if (this.playSpeed < 0) {
this.setSpeed(-this.playSpeed);
} else {
this.setDirection(-1);
}
}
this.totalFrames = arr[0] - arr[1];
this.timeCompleted = this.totalFrames;
this.firstFrame = arr[1];
this.setCurrentRawFrameValue(this.totalFrames - 1e-3 - offset);
} else if (arr[1] > arr[0]) {
if (this.frameModifier < 0) {
if (this.playSpeed < 0) {
this.setSpeed(-this.playSpeed);
} else {
this.setDirection(1);
}
}
this.totalFrames = arr[1] - arr[0];
this.timeCompleted = this.totalFrames;
this.firstFrame = arr[0];
this.setCurrentRawFrameValue(1e-3 + offset);
}
this.trigger("segmentStart");
};
AnimationItem.prototype.setSegment = function(init, end) {
var pendingFrame = -1;
if (this.isPaused) {
if (this.currentRawFrame + this.firstFrame < init) {
pendingFrame = init;
} else if (this.currentRawFrame + this.firstFrame > end) {
pendingFrame = end - init;
}
}
this.firstFrame = init;
this.totalFrames = end - init;
this.timeCompleted = this.totalFrames;
if (pendingFrame !== -1) {
this.goToAndStop(pendingFrame, true);
}
};
AnimationItem.prototype.playSegments = function(arr, forceFlag) {
if (forceFlag) {
this.segments.length = 0;
}
if (_typeof$4(arr[0]) === "object") {
var i;
var len = arr.length;
for (i = 0; i < len; i += 1) {
this.segments.push(arr[i]);
}
} else {
this.segments.push(arr);
}
if (this.segments.length && forceFlag) {
this.adjustSegment(this.segments.shift(), 0);
}
if (this.isPaused) {
this.play();
}
};
AnimationItem.prototype.resetSegments = function(forceFlag) {
this.segments.length = 0;
this.segments.push([this.animationData.ip, this.animationData.op]);
if (forceFlag) {
this.checkSegments(0);
}
};
AnimationItem.prototype.checkSegments = function(offset) {
if (this.segments.length) {
this.adjustSegment(this.segments.shift(), offset);
return true;
}
return false;
};
AnimationItem.prototype.destroy = function(name2) {
if (name2 && this.name !== name2 || !this.renderer) {
return;
}
this.renderer.destroy();
this.imagePreloader.destroy();
this.trigger("destroy");
this._cbs = null;
this.onEnterFrame = null;
this.onLoopComplete = null;
this.onComplete = null;
this.onSegmentStart = null;
this.onDestroy = null;
this.renderer = null;
this.expressionsPlugin = null;
this.imagePreloader = null;
this.projectInterface = null;
};
AnimationItem.prototype.setCurrentRawFrameValue = function(value2) {
this.currentRawFrame = value2;
this.gotoFrame();
};
AnimationItem.prototype.setSpeed = function(val2) {
this.playSpeed = val2;
this.updaFrameModifier();
};
AnimationItem.prototype.setDirection = function(val2) {
this.playDirection = val2 < 0 ? -1 : 1;
this.updaFrameModifier();
};
AnimationItem.prototype.setLoop = function(isLooping) {
this.loop = isLooping;
};
AnimationItem.prototype.setVolume = function(val2, name2) {
if (name2 && this.name !== name2) {
return;
}
this.audioController.setVolume(val2);
};
AnimationItem.prototype.getVolume = function() {
return this.audioController.getVolume();
};
AnimationItem.prototype.mute = function(name2) {
if (name2 && this.name !== name2) {
return;
}
this.audioController.mute();
};
AnimationItem.prototype.unmute = function(name2) {
if (name2 && this.name !== name2) {
return;
}
this.audioController.unmute();
};
AnimationItem.prototype.updaFrameModifier = function() {
this.frameModifier = this.frameMult * this.playSpeed * this.playDirection;
this.audioController.setRate(this.playSpeed * this.playDirection);
};
AnimationItem.prototype.getPath = function() {
return this.path;
};
AnimationItem.prototype.getAssetsPath = function(assetData) {
var path = "";
if (assetData.e) {
path = assetData.p;
} else if (this.assetsPath) {
var imagePath = assetData.p;
if (imagePath.indexOf("images/") !== -1) {
imagePath = imagePath.split("/")[1];
}
path = this.assetsPath + imagePath;
} else {
path = this.path;
path += assetData.u ? assetData.u : "";
path += assetData.p;
}
return path;
};
AnimationItem.prototype.getAssetData = function(id) {
var i = 0;
var len = this.assets.length;
while (i < len) {
if (id === this.assets[i].id) {
return this.assets[i];
}
i += 1;
}
return null;
};
AnimationItem.prototype.hide = function() {
this.renderer.hide();
};
AnimationItem.prototype.show = function() {
this.renderer.show();
};
AnimationItem.prototype.getDuration = function(isFrame) {
return isFrame ? this.totalFrames : this.totalFrames / this.frameRate;
};
AnimationItem.prototype.updateDocumentData = function(path, documentData, index2) {
try {
var element = this.renderer.getElementByPath(path);
element.updateDocumentData(documentData, index2);
} catch (error) {
}
};
AnimationItem.prototype.trigger = function(name2) {
if (this._cbs && this._cbs[name2]) {
switch (name2) {
case "enterFrame":
this.triggerEvent(name2, new BMEnterFrameEvent(name2, this.currentFrame, this.totalFrames, this.frameModifier));
break;
case "drawnFrame":
this.drawnFrameEvent.currentTime = this.currentFrame;
this.drawnFrameEvent.totalTime = this.totalFrames;
this.drawnFrameEvent.direction = this.frameModifier;
this.triggerEvent(name2, this.drawnFrameEvent);
break;
case "loopComplete":
this.triggerEvent(name2, new BMCompleteLoopEvent(name2, this.loop, this.playCount, this.frameMult));
break;
case "complete":
this.triggerEvent(name2, new BMCompleteEvent(name2, this.frameMult));
break;
case "segmentStart":
this.triggerEvent(name2, new BMSegmentStartEvent(name2, this.firstFrame, this.totalFrames));
break;
case "destroy":
this.triggerEvent(name2, new BMDestroyEvent(name2, this));
break;
default:
this.triggerEvent(name2);
}
}
if (name2 === "enterFrame" && this.onEnterFrame) {
this.onEnterFrame.call(this, new BMEnterFrameEvent(name2, this.currentFrame, this.totalFrames, this.frameMult));
}
if (name2 === "loopComplete" && this.onLoopComplete) {
this.onLoopComplete.call(this, new BMCompleteLoopEvent(name2, this.loop, this.playCount, this.frameMult));
}
if (name2 === "complete" && this.onComplete) {
this.onComplete.call(this, new BMCompleteEvent(name2, this.frameMult));
}
if (name2 === "segmentStart" && this.onSegmentStart) {
this.onSegmentStart.call(this, new BMSegmentStartEvent(name2, this.firstFrame, this.totalFrames));
}
if (name2 === "destroy" && this.onDestroy) {
this.onDestroy.call(this, new BMDestroyEvent(name2, this));
}
};
AnimationItem.prototype.triggerRenderFrameError = function(nativeError) {
var error = new BMRenderFrameErrorEvent(nativeError, this.currentFrame);
this.triggerEvent("error", error);
if (this.onError) {
this.onError.call(this, error);
}
};
AnimationItem.prototype.triggerConfigError = function(nativeError) {
var error = new BMConfigErrorEvent(nativeError, this.currentFrame);
this.triggerEvent("error", error);
if (this.onError) {
this.onError.call(this, error);
}
};
var animationManager = function() {
var moduleOb = {};
var registeredAnimations = [];
var initTime = 0;
var len = 0;
var playingAnimationsNum = 0;
var _stopped = true;
var _isFrozen = false;
function removeElement(ev) {
var i = 0;
var animItem = ev.target;
while (i < len) {
if (registeredAnimations[i].animation === animItem) {
registeredAnimations.splice(i, 1);
i -= 1;
len -= 1;
if (!animItem.isPaused) {
subtractPlayingCount();
}
}
i += 1;
}
}
function registerAnimation(element, animationData2) {
if (!element) {
return null;
}
var i = 0;
while (i < len) {
if (registeredAnimations[i].elem === element && registeredAnimations[i].elem !== null) {
return registeredAnimations[i].animation;
}
i += 1;
}
var animItem = new AnimationItem();
setupAnimation(animItem, element);
animItem.setData(element, animationData2);
return animItem;
}
function getRegisteredAnimations() {
var i;
var lenAnims = registeredAnimations.length;
var animations = [];
for (i = 0; i < lenAnims; i += 1) {
animations.push(registeredAnimations[i].animation);
}
return animations;
}
function addPlayingCount() {
playingAnimationsNum += 1;
activate();
}
function subtractPlayingCount() {
playingAnimationsNum -= 1;
}
function setupAnimation(animItem, element) {
animItem.addEventListener("destroy", removeElement);
animItem.addEventListener("_active", addPlayingCount);
animItem.addEventListener("_idle", subtractPlayingCount);
registeredAnimations.push({
elem: element,
animation: animItem
});
len += 1;
}
function loadAnimation2(params) {
var animItem = new AnimationItem();
setupAnimation(animItem, null);
animItem.setParams(params);
return animItem;
}
function setSpeed(val2, animation) {
var i;
for (i = 0; i < len; i += 1) {
registeredAnimations[i].animation.setSpeed(val2, animation);
}
}
function setDirection(val2, animation) {
var i;
for (i = 0; i < len; i += 1) {
registeredAnimations[i].animation.setDirection(val2, animation);
}
}
function play(animation) {
var i;
for (i = 0; i < len; i += 1) {
registeredAnimations[i].animation.play(animation);
}
}
function resume(nowTime) {
var elapsedTime = nowTime - initTime;
var i;
for (i = 0; i < len; i += 1) {
registeredAnimations[i].animation.advanceTime(elapsedTime);
}
initTime = nowTime;
if (playingAnimationsNum && !_isFrozen) {
window.requestAnimationFrame(resume);
} else {
_stopped = true;
}
}
function first2(nowTime) {
initTime = nowTime;
window.requestAnimationFrame(resume);
}
function pause(animation) {
var i;
for (i = 0; i < len; i += 1) {
registeredAnimations[i].animation.pause(animation);
}
}
function goToAndStop(value2, isFrame, animation) {
var i;
for (i = 0; i < len; i += 1) {
registeredAnimations[i].animation.goToAndStop(value2, isFrame, animation);
}
}
function stop(animation) {
var i;
for (i = 0; i < len; i += 1) {
registeredAnimations[i].animation.stop(animation);
}
}
function togglePause(animation) {
var i;
for (i = 0; i < len; i += 1) {
registeredAnimations[i].animation.togglePause(animation);
}
}
function destroy(animation) {
var i;
for (i = len - 1; i >= 0; i -= 1) {
registeredAnimations[i].animation.destroy(animation);
}
}
function searchAnimations2(animationData2, standalone2, renderer2) {
var animElements = [].concat([].slice.call(document.getElementsByClassName("lottie")), [].slice.call(document.getElementsByClassName("bodymovin")));
var i;
var lenAnims = animElements.length;
for (i = 0; i < lenAnims; i += 1) {
if (renderer2) {
animElements[i].setAttribute("data-bm-type", renderer2);
}
registerAnimation(animElements[i], animationData2);
}
if (standalone2 && lenAnims === 0) {
if (!renderer2) {
renderer2 = "svg";
}
var body = document.getElementsByTagName("body")[0];
body.innerText = "";
var div2 = createTag("div");
div2.style.width = "100%";
div2.style.height = "100%";
div2.setAttribute("data-bm-type", renderer2);
body.appendChild(div2);
registerAnimation(div2, animationData2);
}
}
function resize() {
var i;
for (i = 0; i < len; i += 1) {
registeredAnimations[i].animation.resize();
}
}
function activate() {
if (!_isFrozen && playingAnimationsNum) {
if (_stopped) {
window.requestAnimationFrame(first2);
_stopped = false;
}
}
}
function freeze() {
_isFrozen = true;
}
function unfreeze() {
_isFrozen = false;
activate();
}
function setVolume(val2, animation) {
var i;
for (i = 0; i < len; i += 1) {
registeredAnimations[i].animation.setVolume(val2, animation);
}
}
function mute(animation) {
var i;
for (i = 0; i < len; i += 1) {
registeredAnimations[i].animation.mute(animation);
}
}
function unmute(animation) {
var i;
for (i = 0; i < len; i += 1) {
registeredAnimations[i].animation.unmute(animation);
}
}
moduleOb.registerAnimation = registerAnimation;
moduleOb.loadAnimation = loadAnimation2;
moduleOb.setSpeed = setSpeed;
moduleOb.setDirection = setDirection;
moduleOb.play = play;
moduleOb.pause = pause;
moduleOb.stop = stop;
moduleOb.togglePause = togglePause;
moduleOb.searchAnimations = searchAnimations2;
moduleOb.resize = resize;
moduleOb.goToAndStop = goToAndStop;
moduleOb.destroy = destroy;
moduleOb.freeze = freeze;
moduleOb.unfreeze = unfreeze;
moduleOb.setVolume = setVolume;
moduleOb.mute = mute;
moduleOb.unmute = unmute;
moduleOb.getRegisteredAnimations = getRegisteredAnimations;
return moduleOb;
}();
var BezierFactory = function() {
var ob2 = {};
ob2.getBezierEasing = getBezierEasing;
var beziers = {};
function getBezierEasing(a, b, c, d, nm) {
var str = nm || ("bez_" + a + "_" + b + "_" + c + "_" + d).replace(/\./g, "p");
if (beziers[str]) {
return beziers[str];
}
var bezEasing = new BezierEasing([a, b, c, d]);
beziers[str] = bezEasing;
return bezEasing;
}
var NEWTON_ITERATIONS = 4;
var NEWTON_MIN_SLOPE = 1e-3;
var SUBDIVISION_PRECISION = 1e-7;
var SUBDIVISION_MAX_ITERATIONS = 10;
var kSplineTableSize = 11;
var kSampleStepSize = 1 / (kSplineTableSize - 1);
var float32ArraySupported = typeof Float32Array === "function";
function A(aA1, aA2) {
return 1 - 3 * aA2 + 3 * aA1;
}
function B(aA1, aA2) {
return 3 * aA2 - 6 * aA1;
}
function C(aA1) {
return 3 * aA1;
}
function calcBezier(aT, aA1, aA2) {
return ((A(aA1, aA2) * aT + B(aA1, aA2)) * aT + C(aA1)) * aT;
}
function getSlope(aT, aA1, aA2) {
return 3 * A(aA1, aA2) * aT * aT + 2 * B(aA1, aA2) * aT + C(aA1);
}
function binarySubdivide(aX, aA, aB, mX1, mX2) {
var currentX, currentT, i = 0;
do {
currentT = aA + (aB - aA) / 2;
currentX = calcBezier(currentT, mX1, mX2) - aX;
if (currentX > 0) {
aB = currentT;
} else {
aA = currentT;
}
} while (Math.abs(currentX) > SUBDIVISION_PRECISION && ++i < SUBDIVISION_MAX_ITERATIONS);
return currentT;
}
function newtonRaphsonIterate(aX, aGuessT, mX1, mX2) {
for (var i = 0; i < NEWTON_ITERATIONS; ++i) {
var currentSlope = getSlope(aGuessT, mX1, mX2);
if (currentSlope === 0)
return aGuessT;
var currentX = calcBezier(aGuessT, mX1, mX2) - aX;
aGuessT -= currentX / currentSlope;
}
return aGuessT;
}
function BezierEasing(points) {
this._p = points;
this._mSampleValues = float32ArraySupported ? new Float32Array(kSplineTableSize) : new Array(kSplineTableSize);
this._precomputed = false;
this.get = this.get.bind(this);
}
BezierEasing.prototype = {
get: function get(x) {
var mX1 = this._p[0], mY1 = this._p[1], mX2 = this._p[2], mY2 = this._p[3];
if (!this._precomputed)
this._precompute();
if (mX1 === mY1 && mX2 === mY2)
return x;
if (x === 0)
return 0;
if (x === 1)
return 1;
return calcBezier(this._getTForX(x), mY1, mY2);
},
// Private part
_precompute: function _precompute() {
var mX1 = this._p[0], mY1 = this._p[1], mX2 = this._p[2], mY2 = this._p[3];
this._precomputed = true;
if (mX1 !== mY1 || mX2 !== mY2) {
this._calcSampleValues();
}
},
_calcSampleValues: function _calcSampleValues() {
var mX1 = this._p[0], mX2 = this._p[2];
for (var i = 0; i < kSplineTableSize; ++i) {
this._mSampleValues[i] = calcBezier(i * kSampleStepSize, mX1, mX2);
}
},
/**
* getTForX chose the fastest heuristic to determine the percentage value precisely from a given X projection.
*/
_getTForX: function _getTForX(aX) {
var mX1 = this._p[0], mX2 = this._p[2], mSampleValues = this._mSampleValues;
var intervalStart = 0;
var currentSample = 1;
var lastSample = kSplineTableSize - 1;
for (; currentSample !== lastSample && mSampleValues[currentSample] <= aX; ++currentSample) {
intervalStart += kSampleStepSize;
}
--currentSample;
var dist = (aX - mSampleValues[currentSample]) / (mSampleValues[currentSample + 1] - mSampleValues[currentSample]);
var guessForT = intervalStart + dist * kSampleStepSize;
var initialSlope = getSlope(guessForT, mX1, mX2);
if (initialSlope >= NEWTON_MIN_SLOPE) {
return newtonRaphsonIterate(aX, guessForT, mX1, mX2);
}
if (initialSlope === 0) {
return guessForT;
}
return binarySubdivide(aX, intervalStart, intervalStart + kSampleStepSize, mX1, mX2);
}
};
return ob2;
}();
var pooling = /* @__PURE__ */ function() {
function _double(arr) {
return arr.concat(createSizedArray(arr.length));
}
return {
"double": _double
};
}();
var poolFactory = /* @__PURE__ */ function() {
return function(initialLength, _create, _release) {
var _length = 0;
var _maxLength = initialLength;
var pool = createSizedArray(_maxLength);
var ob2 = {
newElement,
release
};
function newElement() {
var element;
if (_length) {
_length -= 1;
element = pool[_length];
} else {
element = _create();
}
return element;
}
function release(element) {
if (_length === _maxLength) {
pool = pooling["double"](pool);
_maxLength *= 2;
}
if (_release) {
_release(element);
}
pool[_length] = element;
_length += 1;
}
return ob2;
};
}();
var bezierLengthPool = function() {
function create() {
return {
addedLength: 0,
percents: createTypedArray("float32", getDefaultCurveSegments()),
lengths: createTypedArray("float32", getDefaultCurveSegments())
};
}
return poolFactory(8, create);
}();
var segmentsLengthPool = function() {
function create() {
return {
lengths: [],
totalLength: 0
};
}
function release(element) {
var i;
var len = element.lengths.length;
for (i = 0; i < len; i += 1) {
bezierLengthPool.release(element.lengths[i]);
}
element.lengths.length = 0;
}
return poolFactory(8, create, release);
}();
function bezFunction() {
var math = Math;
function pointOnLine2D(x1, y1, x2, y2, x3, y3) {
var det1 = x1 * y2 + y1 * x3 + x2 * y3 - x3 * y2 - y3 * x1 - x2 * y1;
return det1 > -1e-3 && det1 < 1e-3;
}
function pointOnLine3D(x1, y1, z1, x2, y2, z2, x3, y3, z3) {
if (z1 === 0 && z2 === 0 && z3 === 0) {
return pointOnLine2D(x1, y1, x2, y2, x3, y3);
}
var dist1 = math.sqrt(math.pow(x2 - x1, 2) + math.pow(y2 - y1, 2) + math.pow(z2 - z1, 2));
var dist2 = math.sqrt(math.pow(x3 - x1, 2) + math.pow(y3 - y1, 2) + math.pow(z3 - z1, 2));
var dist3 = math.sqrt(math.pow(x3 - x2, 2) + math.pow(y3 - y2, 2) + math.pow(z3 - z2, 2));
var diffDist;
if (dist1 > dist2) {
if (dist1 > dist3) {
diffDist = dist1 - dist2 - dist3;
} else {
diffDist = dist3 - dist2 - dist1;
}
} else if (dist3 > dist2) {
diffDist = dist3 - dist2 - dist1;
} else {
diffDist = dist2 - dist1 - dist3;
}
return diffDist > -1e-4 && diffDist < 1e-4;
}
var getBezierLength = /* @__PURE__ */ function() {
return function(pt1, pt2, pt3, pt4) {
var curveSegments = getDefaultCurveSegments();
var k;
var i;
var len;
var ptCoord;
var perc;
var addedLength = 0;
var ptDistance;
var point = [];
var lastPoint = [];
var lengthData = bezierLengthPool.newElement();
len = pt3.length;
for (k = 0; k < curveSegments; k += 1) {
perc = k / (curveSegments - 1);
ptDistance = 0;
for (i = 0; i < len; i += 1) {
ptCoord = bmPow(1 - perc, 3) * pt1[i] + 3 * bmPow(1 - perc, 2) * perc * pt3[i] + 3 * (1 - perc) * bmPow(perc, 2) * pt4[i] + bmPow(perc, 3) * pt2[i];
point[i] = ptCoord;
if (lastPoint[i] !== null) {
ptDistance += bmPow(point[i] - lastPoint[i], 2);
}
lastPoint[i] = point[i];
}
if (ptDistance) {
ptDistance = bmSqrt(ptDistance);
addedLength += ptDistance;
}
lengthData.percents[k] = perc;
lengthData.lengths[k] = addedLength;
}
lengthData.addedLength = addedLength;
return lengthData;
};
}();
function getSegmentsLength(shapeData) {
var segmentsLength = segmentsLengthPool.newElement();
var closed = shapeData.c;
var pathV = shapeData.v;
var pathO = shapeData.o;
var pathI = shapeData.i;
var i;
var len = shapeData._length;
var lengths = segmentsLength.lengths;
var totalLength = 0;
for (i = 0; i < len - 1; i += 1) {
lengths[i] = getBezierLength(pathV[i], pathV[i + 1], pathO[i], pathI[i + 1]);
totalLength += lengths[i].addedLength;
}
if (closed && len) {
lengths[i] = getBezierLength(pathV[i], pathV[0], pathO[i], pathI[0]);
totalLength += lengths[i].addedLength;
}
segmentsLength.totalLength = totalLength;
return segmentsLength;
}
function BezierData(length2) {
this.segmentLength = 0;
this.points = new Array(length2);
}
function PointData(partial, point) {
this.partialLength = partial;
this.point = point;
}
var buildBezierData = /* @__PURE__ */ function() {
var storedData = {};
return function(pt1, pt2, pt3, pt4) {
var bezierName = (pt1[0] + "_" + pt1[1] + "_" + pt2[0] + "_" + pt2[1] + "_" + pt3[0] + "_" + pt3[1] + "_" + pt4[0] + "_" + pt4[1]).replace(/\./g, "p");
if (!storedData[bezierName]) {
var curveSegments = getDefaultCurveSegments();
var k;
var i;
var len;
var ptCoord;
var perc;
var addedLength = 0;
var ptDistance;
var point;
var lastPoint = null;
if (pt1.length === 2 && (pt1[0] !== pt2[0] || pt1[1] !== pt2[1]) && pointOnLine2D(pt1[0], pt1[1], pt2[0], pt2[1], pt1[0] + pt3[0], pt1[1] + pt3[1]) && pointOnLine2D(pt1[0], pt1[1], pt2[0], pt2[1], pt2[0] + pt4[0], pt2[1] + pt4[1])) {
curveSegments = 2;
}
var bezierData = new BezierData(curveSegments);
len = pt3.length;
for (k = 0; k < curveSegments; k += 1) {
point = createSizedArray(len);
perc = k / (curveSegments - 1);
ptDistance = 0;
for (i = 0; i < len; i += 1) {
ptCoord = bmPow(1 - perc, 3) * pt1[i] + 3 * bmPow(1 - perc, 2) * perc * (pt1[i] + pt3[i]) + 3 * (1 - perc) * bmPow(perc, 2) * (pt2[i] + pt4[i]) + bmPow(perc, 3) * pt2[i];
point[i] = ptCoord;
if (lastPoint !== null) {
ptDistance += bmPow(point[i] - lastPoint[i], 2);
}
}
ptDistance = bmSqrt(ptDistance);
addedLength += ptDistance;
bezierData.points[k] = new PointData(ptDistance, point);
lastPoint = point;
}
bezierData.segmentLength = addedLength;
storedData[bezierName] = bezierData;
}
return storedData[bezierName];
};
}();
function getDistancePerc(perc, bezierData) {
var percents = bezierData.percents;
var lengths = bezierData.lengths;
var len = percents.length;
var initPos = bmFloor((len - 1) * perc);
var lengthPos = perc * bezierData.addedLength;
var lPerc = 0;
if (initPos === len - 1 || initPos === 0 || lengthPos === lengths[initPos]) {
return percents[initPos];
}
var dir = lengths[initPos] > lengthPos ? -1 : 1;
var flag = true;
while (flag) {
if (lengths[initPos] <= lengthPos && lengths[initPos + 1] > lengthPos) {
lPerc = (lengthPos - lengths[initPos]) / (lengths[initPos + 1] - lengths[initPos]);
flag = false;
} else {
initPos += dir;
}
if (initPos < 0 || initPos >= len - 1) {
if (initPos === len - 1) {
return percents[initPos];
}
flag = false;
}
}
return percents[initPos] + (percents[initPos + 1] - percents[initPos]) * lPerc;
}
function getPointInSegment(pt1, pt2, pt3, pt4, percent, bezierData) {
var t1 = getDistancePerc(percent, bezierData);
var u1 = 1 - t1;
var ptX = math.round((u1 * u1 * u1 * pt1[0] + (t1 * u1 * u1 + u1 * t1 * u1 + u1 * u1 * t1) * pt3[0] + (t1 * t1 * u1 + u1 * t1 * t1 + t1 * u1 * t1) * pt4[0] + t1 * t1 * t1 * pt2[0]) * 1e3) / 1e3;
var ptY = math.round((u1 * u1 * u1 * pt1[1] + (t1 * u1 * u1 + u1 * t1 * u1 + u1 * u1 * t1) * pt3[1] + (t1 * t1 * u1 + u1 * t1 * t1 + t1 * u1 * t1) * pt4[1] + t1 * t1 * t1 * pt2[1]) * 1e3) / 1e3;
return [ptX, ptY];
}
var bezierSegmentPoints = createTypedArray("float32", 8);
function getNewSegment(pt1, pt2, pt3, pt4, startPerc, endPerc, bezierData) {
if (startPerc < 0) {
startPerc = 0;
} else if (startPerc > 1) {
startPerc = 1;
}
var t0 = getDistancePerc(startPerc, bezierData);
endPerc = endPerc > 1 ? 1 : endPerc;
var t1 = getDistancePerc(endPerc, bezierData);
var i;
var len = pt1.length;
var u0 = 1 - t0;
var u1 = 1 - t1;
var u0u0u0 = u0 * u0 * u0;
var t0u0u0_3 = t0 * u0 * u0 * 3;
var t0t0u0_3 = t0 * t0 * u0 * 3;
var t0t0t0 = t0 * t0 * t0;
var u0u0u1 = u0 * u0 * u1;
var t0u0u1_3 = t0 * u0 * u1 + u0 * t0 * u1 + u0 * u0 * t1;
var t0t0u1_3 = t0 * t0 * u1 + u0 * t0 * t1 + t0 * u0 * t1;
var t0t0t1 = t0 * t0 * t1;
var u0u1u1 = u0 * u1 * u1;
var t0u1u1_3 = t0 * u1 * u1 + u0 * t1 * u1 + u0 * u1 * t1;
var t0t1u1_3 = t0 * t1 * u1 + u0 * t1 * t1 + t0 * u1 * t1;
var t0t1t1 = t0 * t1 * t1;
var u1u1u1 = u1 * u1 * u1;
var t1u1u1_3 = t1 * u1 * u1 + u1 * t1 * u1 + u1 * u1 * t1;
var t1t1u1_3 = t1 * t1 * u1 + u1 * t1 * t1 + t1 * u1 * t1;
var t1t1t1 = t1 * t1 * t1;
for (i = 0; i < len; i += 1) {
bezierSegmentPoints[i * 4] = math.round((u0u0u0 * pt1[i] + t0u0u0_3 * pt3[i] + t0t0u0_3 * pt4[i] + t0t0t0 * pt2[i]) * 1e3) / 1e3;
bezierSegmentPoints[i * 4 + 1] = math.round((u0u0u1 * pt1[i] + t0u0u1_3 * pt3[i] + t0t0u1_3 * pt4[i] + t0t0t1 * pt2[i]) * 1e3) / 1e3;
bezierSegmentPoints[i * 4 + 2] = math.round((u0u1u1 * pt1[i] + t0u1u1_3 * pt3[i] + t0t1u1_3 * pt4[i] + t0t1t1 * pt2[i]) * 1e3) / 1e3;
bezierSegmentPoints[i * 4 + 3] = math.round((u1u1u1 * pt1[i] + t1u1u1_3 * pt3[i] + t1t1u1_3 * pt4[i] + t1t1t1 * pt2[i]) * 1e3) / 1e3;
}
return bezierSegmentPoints;
}
return {
getSegmentsLength,
getNewSegment,
getPointInSegment,
buildBezierData,
pointOnLine2D,
pointOnLine3D
};
}
var bez = bezFunction();
var initFrame = initialDefaultFrame;
var mathAbs = Math.abs;
function interpolateValue(frameNum, caching) {
var offsetTime = this.offsetTime;
var newValue;
if (this.propType === "multidimensional") {
newValue = createTypedArray("float32", this.pv.length);
}
var iterationIndex = caching.lastIndex;
var i = iterationIndex;
var len = this.keyframes.length - 1;
var flag = true;
var keyData;
var nextKeyData;
var keyframeMetadata;
while (flag) {
keyData = this.keyframes[i];
nextKeyData = this.keyframes[i + 1];
if (i === len - 1 && frameNum >= nextKeyData.t - offsetTime) {
if (keyData.h) {
keyData = nextKeyData;
}
iterationIndex = 0;
break;
}
if (nextKeyData.t - offsetTime > frameNum) {
iterationIndex = i;
break;
}
if (i < len - 1) {
i += 1;
} else {
iterationIndex = 0;
flag = false;
}
}
keyframeMetadata = this.keyframesMetadata[i] || {};
var k;
var kLen;
var perc;
var jLen;
var j;
var fnc;
var nextKeyTime = nextKeyData.t - offsetTime;
var keyTime = keyData.t - offsetTime;
var endValue;
if (keyData.to) {
if (!keyframeMetadata.bezierData) {
keyframeMetadata.bezierData = bez.buildBezierData(keyData.s, nextKeyData.s || keyData.e, keyData.to, keyData.ti);
}
var bezierData = keyframeMetadata.bezierData;
if (frameNum >= nextKeyTime || frameNum < keyTime) {
var ind = frameNum >= nextKeyTime ? bezierData.points.length - 1 : 0;
kLen = bezierData.points[ind].point.length;
for (k = 0; k < kLen; k += 1) {
newValue[k] = bezierData.points[ind].point[k];
}
} else {
if (keyframeMetadata.__fnct) {
fnc = keyframeMetadata.__fnct;
} else {
fnc = BezierFactory.getBezierEasing(keyData.o.x, keyData.o.y, keyData.i.x, keyData.i.y, keyData.n).get;
keyframeMetadata.__fnct = fnc;
}
perc = fnc((frameNum - keyTime) / (nextKeyTime - keyTime));
var distanceInLine = bezierData.segmentLength * perc;
var segmentPerc;
var addedLength = caching.lastFrame < frameNum && caching._lastKeyframeIndex === i ? caching._lastAddedLength : 0;
j = caching.lastFrame < frameNum && caching._lastKeyframeIndex === i ? caching._lastPoint : 0;
flag = true;
jLen = bezierData.points.length;
while (flag) {
addedLength += bezierData.points[j].partialLength;
if (distanceInLine === 0 || perc === 0 || j === bezierData.points.length - 1) {
kLen = bezierData.points[j].point.length;
for (k = 0; k < kLen; k += 1) {
newValue[k] = bezierData.points[j].point[k];
}
break;
} else if (distanceInLine >= addedLength && distanceInLine < addedLength + bezierData.points[j + 1].partialLength) {
segmentPerc = (distanceInLine - addedLength) / bezierData.points[j + 1].partialLength;
kLen = bezierData.points[j].point.length;
for (k = 0; k < kLen; k += 1) {
newValue[k] = bezierData.points[j].point[k] + (bezierData.points[j + 1].point[k] - bezierData.points[j].point[k]) * segmentPerc;
}
break;
}
if (j < jLen - 1) {
j += 1;
} else {
flag = false;
}
}
caching._lastPoint = j;
caching._lastAddedLength = addedLength - bezierData.points[j].partialLength;
caching._lastKeyframeIndex = i;
}
} else {
var outX;
var outY;
var inX;
var inY;
var keyValue;
len = keyData.s.length;
endValue = nextKeyData.s || keyData.e;
if (this.sh && keyData.h !== 1) {
if (frameNum >= nextKeyTime) {
newValue[0] = endValue[0];
newValue[1] = endValue[1];
newValue[2] = endValue[2];
} else if (frameNum <= keyTime) {
newValue[0] = keyData.s[0];
newValue[1] = keyData.s[1];
newValue[2] = keyData.s[2];
} else {
var quatStart = createQuaternion(keyData.s);
var quatEnd = createQuaternion(endValue);
var time2 = (frameNum - keyTime) / (nextKeyTime - keyTime);
quaternionToEuler(newValue, slerp(quatStart, quatEnd, time2));
}
} else {
for (i = 0; i < len; i += 1) {
if (keyData.h !== 1) {
if (frameNum >= nextKeyTime) {
perc = 1;
} else if (frameNum < keyTime) {
perc = 0;
} else {
if (keyData.o.x.constructor === Array) {
if (!keyframeMetadata.__fnct) {
keyframeMetadata.__fnct = [];
}
if (!keyframeMetadata.__fnct[i]) {
outX = keyData.o.x[i] === void 0 ? keyData.o.x[0] : keyData.o.x[i];
outY = keyData.o.y[i] === void 0 ? keyData.o.y[0] : keyData.o.y[i];
inX = keyData.i.x[i] === void 0 ? keyData.i.x[0] : keyData.i.x[i];
inY = keyData.i.y[i] === void 0 ? keyData.i.y[0] : keyData.i.y[i];
fnc = BezierFactory.getBezierEasing(outX, outY, inX, inY).get;
keyframeMetadata.__fnct[i] = fnc;
} else {
fnc = keyframeMetadata.__fnct[i];
}
} else if (!keyframeMetadata.__fnct) {
outX = keyData.o.x;
outY = keyData.o.y;
inX = keyData.i.x;
inY = keyData.i.y;
fnc = BezierFactory.getBezierEasing(outX, outY, inX, inY).get;
keyData.keyframeMetadata = fnc;
} else {
fnc = keyframeMetadata.__fnct;
}
perc = fnc((frameNum - keyTime) / (nextKeyTime - keyTime));
}
}
endValue = nextKeyData.s || keyData.e;
keyValue = keyData.h === 1 ? keyData.s[i] : keyData.s[i] + (endValue[i] - keyData.s[i]) * perc;
if (this.propType === "multidimensional") {
newValue[i] = keyValue;
} else {
newValue = keyValue;
}
}
}
}
caching.lastIndex = iterationIndex;
return newValue;
}
function slerp(a, b, t) {
var out = [];
var ax = a[0];
var ay = a[1];
var az = a[2];
var aw = a[3];
var bx = b[0];
var by = b[1];
var bz = b[2];
var bw = b[3];
var omega;
var cosom;
var sinom;
var scale0;
var scale1;
cosom = ax * bx + ay * by + az * bz + aw * bw;
if (cosom < 0) {
cosom = -cosom;
bx = -bx;
by = -by;
bz = -bz;
bw = -bw;
}
if (1 - cosom > 1e-6) {
omega = Math.acos(cosom);
sinom = Math.sin(omega);
scale0 = Math.sin((1 - t) * omega) / sinom;
scale1 = Math.sin(t * omega) / sinom;
} else {
scale0 = 1 - t;
scale1 = t;
}
out[0] = scale0 * ax + scale1 * bx;
out[1] = scale0 * ay + scale1 * by;
out[2] = scale0 * az + scale1 * bz;
out[3] = scale0 * aw + scale1 * bw;
return out;
}
function quaternionToEuler(out, quat) {
var qx = quat[0];
var qy = quat[1];
var qz = quat[2];
var qw = quat[3];
var heading = Math.atan2(2 * qy * qw - 2 * qx * qz, 1 - 2 * qy * qy - 2 * qz * qz);
var attitude = Math.asin(2 * qx * qy + 2 * qz * qw);
var bank = Math.atan2(2 * qx * qw - 2 * qy * qz, 1 - 2 * qx * qx - 2 * qz * qz);
out[0] = heading / degToRads;
out[1] = attitude / degToRads;
out[2] = bank / degToRads;
}
function createQuaternion(values) {
var heading = values[0] * degToRads;
var attitude = values[1] * degToRads;
var bank = values[2] * degToRads;
var c1 = Math.cos(heading / 2);
var c2 = Math.cos(attitude / 2);
var c3 = Math.cos(bank / 2);
var s1 = Math.sin(heading / 2);
var s2 = Math.sin(attitude / 2);
var s3 = Math.sin(bank / 2);
var w = c1 * c2 * c3 - s1 * s2 * s3;
var x = s1 * s2 * c3 + c1 * c2 * s3;
var y = s1 * c2 * c3 + c1 * s2 * s3;
var z = c1 * s2 * c3 - s1 * c2 * s3;
return [x, y, z, w];
}
function getValueAtCurrentTime() {
var frameNum = this.comp.renderedFrame - this.offsetTime;
var initTime = this.keyframes[0].t - this.offsetTime;
var endTime = this.keyframes[this.keyframes.length - 1].t - this.offsetTime;
if (!(frameNum === this._caching.lastFrame || this._caching.lastFrame !== initFrame && (this._caching.lastFrame >= endTime && frameNum >= endTime || this._caching.lastFrame < initTime && frameNum < initTime))) {
if (this._caching.lastFrame >= frameNum) {
this._caching._lastKeyframeIndex = -1;
this._caching.lastIndex = 0;
}
var renderResult = this.interpolateValue(frameNum, this._caching);
this.pv = renderResult;
}
this._caching.lastFrame = frameNum;
return this.pv;
}
function setVValue(val2) {
var multipliedValue;
if (this.propType === "unidimensional") {
multipliedValue = val2 * this.mult;
if (mathAbs(this.v - multipliedValue) > 1e-5) {
this.v = multipliedValue;
this._mdf = true;
}
} else {
var i = 0;
var len = this.v.length;
while (i < len) {
multipliedValue = val2[i] * this.mult;
if (mathAbs(this.v[i] - multipliedValue) > 1e-5) {
this.v[i] = multipliedValue;
this._mdf = true;
}
i += 1;
}
}
}
function processEffectsSequence() {
if (this.elem.globalData.frameId === this.frameId || !this.effectsSequence.length) {
return;
}
if (this.lock) {
this.setVValue(this.pv);
return;
}
this.lock = true;
this._mdf = this._isFirstFrame;
var i;
var len = this.effectsSequence.length;
var finalValue = this.kf ? this.pv : this.data.k;
for (i = 0; i < len; i += 1) {
finalValue = this.effectsSequence[i](finalValue);
}
this.setVValue(finalValue);
this._isFirstFrame = false;
this.lock = false;
this.frameId = this.elem.globalData.frameId;
}
function addEffect(effectFunction) {
this.effectsSequence.push(effectFunction);
this.container.addDynamicProperty(this);
}
function ValueProperty(elem2, data2, mult, container) {
this.propType = "unidimensional";
this.mult = mult || 1;
this.data = data2;
this.v = mult ? data2.k * mult : data2.k;
this.pv = data2.k;
this._mdf = false;
this.elem = elem2;
this.container = container;
this.comp = elem2.comp;
this.k = false;
this.kf = false;
this.vel = 0;
this.effectsSequence = [];
this._isFirstFrame = true;
this.getValue = processEffectsSequence;
this.setVValue = setVValue;
this.addEffect = addEffect;
}
function MultiDimensionalProperty(elem2, data2, mult, container) {
this.propType = "multidimensional";
this.mult = mult || 1;
this.data = data2;
this._mdf = false;
this.elem = elem2;
this.container = container;
this.comp = elem2.comp;
this.k = false;
this.kf = false;
this.frameId = -1;
var i;
var len = data2.k.length;
this.v = createTypedArray("float32", len);
this.pv = createTypedArray("float32", len);
this.vel = createTypedArray("float32", len);
for (i = 0; i < len; i += 1) {
this.v[i] = data2.k[i] * this.mult;
this.pv[i] = data2.k[i];
}
this._isFirstFrame = true;
this.effectsSequence = [];
this.getValue = processEffectsSequence;
this.setVValue = setVValue;
this.addEffect = addEffect;
}
function KeyframedValueProperty(elem2, data2, mult, container) {
this.propType = "unidimensional";
this.keyframes = data2.k;
this.keyframesMetadata = [];
this.offsetTime = elem2.data.st;
this.frameId = -1;
this._caching = {
lastFrame: initFrame,
lastIndex: 0,
value: 0,
_lastKeyframeIndex: -1
};
this.k = true;
this.kf = true;
this.data = data2;
this.mult = mult || 1;
this.elem = elem2;
this.container = container;
this.comp = elem2.comp;
this.v = initFrame;
this.pv = initFrame;
this._isFirstFrame = true;
this.getValue = processEffectsSequence;
this.setVValue = setVValue;
this.interpolateValue = interpolateValue;
this.effectsSequence = [getValueAtCurrentTime.bind(this)];
this.addEffect = addEffect;
}
function KeyframedMultidimensionalProperty(elem2, data2, mult, container) {
this.propType = "multidimensional";
var i;
var len = data2.k.length;
var s;
var e;
var to;
var ti;
for (i = 0; i < len - 1; i += 1) {
if (data2.k[i].to && data2.k[i].s && data2.k[i + 1] && data2.k[i + 1].s) {
s = data2.k[i].s;
e = data2.k[i + 1].s;
to = data2.k[i].to;
ti = data2.k[i].ti;
if (s.length === 2 && !(s[0] === e[0] && s[1] === e[1]) && bez.pointOnLine2D(s[0], s[1], e[0], e[1], s[0] + to[0], s[1] + to[1]) && bez.pointOnLine2D(s[0], s[1], e[0], e[1], e[0] + ti[0], e[1] + ti[1]) || s.length === 3 && !(s[0] === e[0] && s[1] === e[1] && s[2] === e[2]) && bez.pointOnLine3D(s[0], s[1], s[2], e[0], e[1], e[2], s[0] + to[0], s[1] + to[1], s[2] + to[2]) && bez.pointOnLine3D(s[0], s[1], s[2], e[0], e[1], e[2], e[0] + ti[0], e[1] + ti[1], e[2] + ti[2])) {
data2.k[i].to = null;
data2.k[i].ti = null;
}
if (s[0] === e[0] && s[1] === e[1] && to[0] === 0 && to[1] === 0 && ti[0] === 0 && ti[1] === 0) {
if (s.length === 2 || s[2] === e[2] && to[2] === 0 && ti[2] === 0) {
data2.k[i].to = null;
data2.k[i].ti = null;
}
}
}
}
this.effectsSequence = [getValueAtCurrentTime.bind(this)];
this.data = data2;
this.keyframes = data2.k;
this.keyframesMetadata = [];
this.offsetTime = elem2.data.st;
this.k = true;
this.kf = true;
this._isFirstFrame = true;
this.mult = mult || 1;
this.elem = elem2;
this.container = container;
this.comp = elem2.comp;
this.getValue = processEffectsSequence;
this.setVValue = setVValue;
this.interpolateValue = interpolateValue;
this.frameId = -1;
var arrLen = data2.k[0].s.length;
this.v = createTypedArray("float32", arrLen);
this.pv = createTypedArray("float32", arrLen);
for (i = 0; i < arrLen; i += 1) {
this.v[i] = initFrame;
this.pv[i] = initFrame;
}
this._caching = {
lastFrame: initFrame,
lastIndex: 0,
value: createTypedArray("float32", arrLen)
};
this.addEffect = addEffect;
}
var PropertyFactory = /* @__PURE__ */ function() {
function getProp(elem2, data2, type, mult, container) {
if (data2.sid) {
data2 = elem2.globalData.slotManager.getProp(data2);
}
var p;
if (!data2.k.length) {
p = new ValueProperty(elem2, data2, mult, container);
} else if (typeof data2.k[0] === "number") {
p = new MultiDimensionalProperty(elem2, data2, mult, container);
} else {
switch (type) {
case 0:
p = new KeyframedValueProperty(elem2, data2, mult, container);
break;
case 1:
p = new KeyframedMultidimensionalProperty(elem2, data2, mult, container);
break;
default:
break;
}
}
if (p.effectsSequence.length) {
container.addDynamicProperty(p);
}
return p;
}
var ob2 = {
getProp
};
return ob2;
}();
function DynamicPropertyContainer() {
}
DynamicPropertyContainer.prototype = {
addDynamicProperty: function addDynamicProperty(prop) {
if (this.dynamicProperties.indexOf(prop) === -1) {
this.dynamicProperties.push(prop);
this.container.addDynamicProperty(this);
this._isAnimated = true;
}
},
iterateDynamicProperties: function iterateDynamicProperties() {
this._mdf = false;
var i;
var len = this.dynamicProperties.length;
for (i = 0; i < len; i += 1) {
this.dynamicProperties[i].getValue();
if (this.dynamicProperties[i]._mdf) {
this._mdf = true;
}
}
},
initDynamicPropertyContainer: function initDynamicPropertyContainer(container) {
this.container = container;
this.dynamicProperties = [];
this._mdf = false;
this._isAnimated = false;
}
};
var pointPool = function() {
function create() {
return createTypedArray("float32", 2);
}
return poolFactory(8, create);
}();
function ShapePath() {
this.c = false;
this._length = 0;
this._maxLength = 8;
this.v = createSizedArray(this._maxLength);
this.o = createSizedArray(this._maxLength);
this.i = createSizedArray(this._maxLength);
}
ShapePath.prototype.setPathData = function(closed, len) {
this.c = closed;
this.setLength(len);
var i = 0;
while (i < len) {
this.v[i] = pointPool.newElement();
this.o[i] = pointPool.newElement();
this.i[i] = pointPool.newElement();
i += 1;
}
};
ShapePath.prototype.setLength = function(len) {
while (this._maxLength < len) {
this.doubleArrayLength();
}
this._length = len;
};
ShapePath.prototype.doubleArrayLength = function() {
this.v = this.v.concat(createSizedArray(this._maxLength));
this.i = this.i.concat(createSizedArray(this._maxLength));
this.o = this.o.concat(createSizedArray(this._maxLength));
this._maxLength *= 2;
};
ShapePath.prototype.setXYAt = function(x, y, type, pos, replace) {
var arr;
this._length = Math.max(this._length, pos + 1);
if (this._length >= this._maxLength) {
this.doubleArrayLength();
}
switch (type) {
case "v":
arr = this.v;
break;
case "i":
arr = this.i;
break;
case "o":
arr = this.o;
break;
default:
arr = [];
break;
}
if (!arr[pos] || arr[pos] && !replace) {
arr[pos] = pointPool.newElement();
}
arr[pos][0] = x;
arr[pos][1] = y;
};
ShapePath.prototype.setTripleAt = function(vX, vY, oX, oY, iX, iY, pos, replace) {
this.setXYAt(vX, vY, "v", pos, replace);
this.setXYAt(oX, oY, "o", pos, replace);
this.setXYAt(iX, iY, "i", pos, replace);
};
ShapePath.prototype.reverse = function() {
var newPath = new ShapePath();
newPath.setPathData(this.c, this._length);
var vertices = this.v;
var outPoints = this.o;
var inPoints = this.i;
var init = 0;
if (this.c) {
newPath.setTripleAt(vertices[0][0], vertices[0][1], inPoints[0][0], inPoints[0][1], outPoints[0][0], outPoints[0][1], 0, false);
init = 1;
}
var cnt = this._length - 1;
var len = this._length;
var i;
for (i = init; i < len; i += 1) {
newPath.setTripleAt(vertices[cnt][0], vertices[cnt][1], inPoints[cnt][0], inPoints[cnt][1], outPoints[cnt][0], outPoints[cnt][1], i, false);
cnt -= 1;
}
return newPath;
};
ShapePath.prototype.length = function() {
return this._length;
};
var shapePool = function() {
function create() {
return new ShapePath();
}
function release(shapePath) {
var len = shapePath._length;
var i;
for (i = 0; i < len; i += 1) {
pointPool.release(shapePath.v[i]);
pointPool.release(shapePath.i[i]);
pointPool.release(shapePath.o[i]);
shapePath.v[i] = null;
shapePath.i[i] = null;
shapePath.o[i] = null;
}
shapePath._length = 0;
shapePath.c = false;
}
function clone(shape) {
var cloned = factory.newElement();
var i;
var len = shape._length === void 0 ? shape.v.length : shape._length;
cloned.setLength(len);
cloned.c = shape.c;
for (i = 0; i < len; i += 1) {
cloned.setTripleAt(shape.v[i][0], shape.v[i][1], shape.o[i][0], shape.o[i][1], shape.i[i][0], shape.i[i][1], i);
}
return cloned;
}
var factory = poolFactory(4, create, release);
factory.clone = clone;
return factory;
}();
function ShapeCollection() {
this._length = 0;
this._maxLength = 4;
this.shapes = createSizedArray(this._maxLength);
}
ShapeCollection.prototype.addShape = function(shapeData) {
if (this._length === this._maxLength) {
this.shapes = this.shapes.concat(createSizedArray(this._maxLength));
this._maxLength *= 2;
}
this.shapes[this._length] = shapeData;
this._length += 1;
};
ShapeCollection.prototype.releaseShapes = function() {
var i;
for (i = 0; i < this._length; i += 1) {
shapePool.release(this.shapes[i]);
}
this._length = 0;
};
var shapeCollectionPool = function() {
var ob2 = {
newShapeCollection,
release
};
var _length = 0;
var _maxLength = 4;
var pool = createSizedArray(_maxLength);
function newShapeCollection() {
var shapeCollection;
if (_length) {
_length -= 1;
shapeCollection = pool[_length];
} else {
shapeCollection = new ShapeCollection();
}
return shapeCollection;
}
function release(shapeCollection) {
var i;
var len = shapeCollection._length;
for (i = 0; i < len; i += 1) {
shapePool.release(shapeCollection.shapes[i]);
}
shapeCollection._length = 0;
if (_length === _maxLength) {
pool = pooling["double"](pool);
_maxLength *= 2;
}
pool[_length] = shapeCollection;
_length += 1;
}
return ob2;
}();
var ShapePropertyFactory = function() {
var initFrame2 = -999999;
function interpolateShape(frameNum, previousValue, caching) {
var iterationIndex = caching.lastIndex;
var keyPropS;
var keyPropE;
var isHold;
var j;
var k;
var jLen;
var kLen;
var perc;
var vertexValue;
var kf = this.keyframes;
if (frameNum < kf[0].t - this.offsetTime) {
keyPropS = kf[0].s[0];
isHold = true;
iterationIndex = 0;
} else if (frameNum >= kf[kf.length - 1].t - this.offsetTime) {
keyPropS = kf[kf.length - 1].s ? kf[kf.length - 1].s[0] : kf[kf.length - 2].e[0];
isHold = true;
} else {
var i = iterationIndex;
var len = kf.length - 1;
var flag = true;
var keyData;
var nextKeyData;
var keyframeMetadata;
while (flag) {
keyData = kf[i];
nextKeyData = kf[i + 1];
if (nextKeyData.t - this.offsetTime > frameNum) {
break;
}
if (i < len - 1) {
i += 1;
} else {
flag = false;
}
}
keyframeMetadata = this.keyframesMetadata[i] || {};
isHold = keyData.h === 1;
iterationIndex = i;
if (!isHold) {
if (frameNum >= nextKeyData.t - this.offsetTime) {
perc = 1;
} else if (frameNum < keyData.t - this.offsetTime) {
perc = 0;
} else {
var fnc;
if (keyframeMetadata.__fnct) {
fnc = keyframeMetadata.__fnct;
} else {
fnc = BezierFactory.getBezierEasing(keyData.o.x, keyData.o.y, keyData.i.x, keyData.i.y).get;
keyframeMetadata.__fnct = fnc;
}
perc = fnc((frameNum - (keyData.t - this.offsetTime)) / (nextKeyData.t - this.offsetTime - (keyData.t - this.offsetTime)));
}
keyPropE = nextKeyData.s ? nextKeyData.s[0] : keyData.e[0];
}
keyPropS = keyData.s[0];
}
jLen = previousValue._length;
kLen = keyPropS.i[0].length;
caching.lastIndex = iterationIndex;
for (j = 0; j < jLen; j += 1) {
for (k = 0; k < kLen; k += 1) {
vertexValue = isHold ? keyPropS.i[j][k] : keyPropS.i[j][k] + (keyPropE.i[j][k] - keyPropS.i[j][k]) * perc;
previousValue.i[j][k] = vertexValue;
vertexValue = isHold ? keyPropS.o[j][k] : keyPropS.o[j][k] + (keyPropE.o[j][k] - keyPropS.o[j][k]) * perc;
previousValue.o[j][k] = vertexValue;
vertexValue = isHold ? keyPropS.v[j][k] : keyPropS.v[j][k] + (keyPropE.v[j][k] - keyPropS.v[j][k]) * perc;
previousValue.v[j][k] = vertexValue;
}
}
}
function interpolateShapeCurrentTime() {
var frameNum = this.comp.renderedFrame - this.offsetTime;
var initTime = this.keyframes[0].t - this.offsetTime;
var endTime = this.keyframes[this.keyframes.length - 1].t - this.offsetTime;
var lastFrame = this._caching.lastFrame;
if (!(lastFrame !== initFrame2 && (lastFrame < initTime && frameNum < initTime || lastFrame > endTime && frameNum > endTime))) {
this._caching.lastIndex = lastFrame < frameNum ? this._caching.lastIndex : 0;
this.interpolateShape(frameNum, this.pv, this._caching);
}
this._caching.lastFrame = frameNum;
return this.pv;
}
function resetShape() {
this.paths = this.localShapeCollection;
}
function shapesEqual(shape1, shape2) {
if (shape1._length !== shape2._length || shape1.c !== shape2.c) {
return false;
}
var i;
var len = shape1._length;
for (i = 0; i < len; i += 1) {
if (shape1.v[i][0] !== shape2.v[i][0] || shape1.v[i][1] !== shape2.v[i][1] || shape1.o[i][0] !== shape2.o[i][0] || shape1.o[i][1] !== shape2.o[i][1] || shape1.i[i][0] !== shape2.i[i][0] || shape1.i[i][1] !== shape2.i[i][1]) {
return false;
}
}
return true;
}
function setVValue2(newPath) {
if (!shapesEqual(this.v, newPath)) {
this.v = shapePool.clone(newPath);
this.localShapeCollection.releaseShapes();
this.localShapeCollection.addShape(this.v);
this._mdf = true;
this.paths = this.localShapeCollection;
}
}
function processEffectsSequence2() {
if (this.elem.globalData.frameId === this.frameId) {
return;
}
if (!this.effectsSequence.length) {
this._mdf = false;
return;
}
if (this.lock) {
this.setVValue(this.pv);
return;
}
this.lock = true;
this._mdf = false;
var finalValue;
if (this.kf) {
finalValue = this.pv;
} else if (this.data.ks) {
finalValue = this.data.ks.k;
} else {
finalValue = this.data.pt.k;
}
var i;
var len = this.effectsSequence.length;
for (i = 0; i < len; i += 1) {
finalValue = this.effectsSequence[i](finalValue);
}
this.setVValue(finalValue);
this.lock = false;
this.frameId = this.elem.globalData.frameId;
}
function ShapeProperty(elem2, data2, type) {
this.propType = "shape";
this.comp = elem2.comp;
this.container = elem2;
this.elem = elem2;
this.data = data2;
this.k = false;
this.kf = false;
this._mdf = false;
var pathData = type === 3 ? data2.pt.k : data2.ks.k;
this.v = shapePool.clone(pathData);
this.pv = shapePool.clone(this.v);
this.localShapeCollection = shapeCollectionPool.newShapeCollection();
this.paths = this.localShapeCollection;
this.paths.addShape(this.v);
this.reset = resetShape;
this.effectsSequence = [];
}
function addEffect2(effectFunction) {
this.effectsSequence.push(effectFunction);
this.container.addDynamicProperty(this);
}
ShapeProperty.prototype.interpolateShape = interpolateShape;
ShapeProperty.prototype.getValue = processEffectsSequence2;
ShapeProperty.prototype.setVValue = setVValue2;
ShapeProperty.prototype.addEffect = addEffect2;
function KeyframedShapeProperty(elem2, data2, type) {
this.propType = "shape";
this.comp = elem2.comp;
this.elem = elem2;
this.container = elem2;
this.offsetTime = elem2.data.st;
this.keyframes = type === 3 ? data2.pt.k : data2.ks.k;
this.keyframesMetadata = [];
this.k = true;
this.kf = true;
var len = this.keyframes[0].s[0].i.length;
this.v = shapePool.newElement();
this.v.setPathData(this.keyframes[0].s[0].c, len);
this.pv = shapePool.clone(this.v);
this.localShapeCollection = shapeCollectionPool.newShapeCollection();
this.paths = this.localShapeCollection;
this.paths.addShape(this.v);
this.lastFrame = initFrame2;
this.reset = resetShape;
this._caching = {
lastFrame: initFrame2,
lastIndex: 0
};
this.effectsSequence = [interpolateShapeCurrentTime.bind(this)];
}
KeyframedShapeProperty.prototype.getValue = processEffectsSequence2;
KeyframedShapeProperty.prototype.interpolateShape = interpolateShape;
KeyframedShapeProperty.prototype.setVValue = setVValue2;
KeyframedShapeProperty.prototype.addEffect = addEffect2;
var EllShapeProperty = function() {
var cPoint = roundCorner;
function EllShapePropertyFactory(elem2, data2) {
this.v = shapePool.newElement();
this.v.setPathData(true, 4);
this.localShapeCollection = shapeCollectionPool.newShapeCollection();
this.paths = this.localShapeCollection;
this.localShapeCollection.addShape(this.v);
this.d = data2.d;
this.elem = elem2;
this.comp = elem2.comp;
this.frameId = -1;
this.initDynamicPropertyContainer(elem2);
this.p = PropertyFactory.getProp(elem2, data2.p, 1, 0, this);
this.s = PropertyFactory.getProp(elem2, data2.s, 1, 0, this);
if (this.dynamicProperties.length) {
this.k = true;
} else {
this.k = false;
this.convertEllToPath();
}
}
EllShapePropertyFactory.prototype = {
reset: resetShape,
getValue: function getValue() {
if (this.elem.globalData.frameId === this.frameId) {
return;
}
this.frameId = this.elem.globalData.frameId;
this.iterateDynamicProperties();
if (this._mdf) {
this.convertEllToPath();
}
},
convertEllToPath: function convertEllToPath() {
var p0 = this.p.v[0];
var p1 = this.p.v[1];
var s0 = this.s.v[0] / 2;
var s1 = this.s.v[1] / 2;
var _cw = this.d !== 3;
var _v = this.v;
_v.v[0][0] = p0;
_v.v[0][1] = p1 - s1;
_v.v[1][0] = _cw ? p0 + s0 : p0 - s0;
_v.v[1][1] = p1;
_v.v[2][0] = p0;
_v.v[2][1] = p1 + s1;
_v.v[3][0] = _cw ? p0 - s0 : p0 + s0;
_v.v[3][1] = p1;
_v.i[0][0] = _cw ? p0 - s0 * cPoint : p0 + s0 * cPoint;
_v.i[0][1] = p1 - s1;
_v.i[1][0] = _cw ? p0 + s0 : p0 - s0;
_v.i[1][1] = p1 - s1 * cPoint;
_v.i[2][0] = _cw ? p0 + s0 * cPoint : p0 - s0 * cPoint;
_v.i[2][1] = p1 + s1;
_v.i[3][0] = _cw ? p0 - s0 : p0 + s0;
_v.i[3][1] = p1 + s1 * cPoint;
_v.o[0][0] = _cw ? p0 + s0 * cPoint : p0 - s0 * cPoint;
_v.o[0][1] = p1 - s1;
_v.o[1][0] = _cw ? p0 + s0 : p0 - s0;
_v.o[1][1] = p1 + s1 * cPoint;
_v.o[2][0] = _cw ? p0 - s0 * cPoint : p0 + s0 * cPoint;
_v.o[2][1] = p1 + s1;
_v.o[3][0] = _cw ? p0 - s0 : p0 + s0;
_v.o[3][1] = p1 - s1 * cPoint;
}
};
extendPrototype([DynamicPropertyContainer], EllShapePropertyFactory);
return EllShapePropertyFactory;
}();
var StarShapeProperty = function() {
function StarShapePropertyFactory(elem2, data2) {
this.v = shapePool.newElement();
this.v.setPathData(true, 0);
this.elem = elem2;
this.comp = elem2.comp;
this.data = data2;
this.frameId = -1;
this.d = data2.d;
this.initDynamicPropertyContainer(elem2);
if (data2.sy === 1) {
this.ir = PropertyFactory.getProp(elem2, data2.ir, 0, 0, this);
this.is = PropertyFactory.getProp(elem2, data2.is, 0, 0.01, this);
this.convertToPath = this.convertStarToPath;
} else {
this.convertToPath = this.convertPolygonToPath;
}
this.pt = PropertyFactory.getProp(elem2, data2.pt, 0, 0, this);
this.p = PropertyFactory.getProp(elem2, data2.p, 1, 0, this);
this.r = PropertyFactory.getProp(elem2, data2.r, 0, degToRads, this);
this.or = PropertyFactory.getProp(elem2, data2.or, 0, 0, this);
this.os = PropertyFactory.getProp(elem2, data2.os, 0, 0.01, this);
this.localShapeCollection = shapeCollectionPool.newShapeCollection();
this.localShapeCollection.addShape(this.v);
this.paths = this.localShapeCollection;
if (this.dynamicProperties.length) {
this.k = true;
} else {
this.k = false;
this.convertToPath();
}
}
StarShapePropertyFactory.prototype = {
reset: resetShape,
getValue: function getValue() {
if (this.elem.globalData.frameId === this.frameId) {
return;
}
this.frameId = this.elem.globalData.frameId;
this.iterateDynamicProperties();
if (this._mdf) {
this.convertToPath();
}
},
convertStarToPath: function convertStarToPath() {
var numPts = Math.floor(this.pt.v) * 2;
var angle = Math.PI * 2 / numPts;
var longFlag = true;
var longRad = this.or.v;
var shortRad = this.ir.v;
var longRound = this.os.v;
var shortRound = this.is.v;
var longPerimSegment = 2 * Math.PI * longRad / (numPts * 2);
var shortPerimSegment = 2 * Math.PI * shortRad / (numPts * 2);
var i;
var rad;
var roundness;
var perimSegment;
var currentAng = -Math.PI / 2;
currentAng += this.r.v;
var dir = this.data.d === 3 ? -1 : 1;
this.v._length = 0;
for (i = 0; i < numPts; i += 1) {
rad = longFlag ? longRad : shortRad;
roundness = longFlag ? longRound : shortRound;
perimSegment = longFlag ? longPerimSegment : shortPerimSegment;
var x = rad * Math.cos(currentAng);
var y = rad * Math.sin(currentAng);
var ox = x === 0 && y === 0 ? 0 : y / Math.sqrt(x * x + y * y);
var oy = x === 0 && y === 0 ? 0 : -x / Math.sqrt(x * x + y * y);
x += +this.p.v[0];
y += +this.p.v[1];
this.v.setTripleAt(x, y, x - ox * perimSegment * roundness * dir, y - oy * perimSegment * roundness * dir, x + ox * perimSegment * roundness * dir, y + oy * perimSegment * roundness * dir, i, true);
longFlag = !longFlag;
currentAng += angle * dir;
}
},
convertPolygonToPath: function convertPolygonToPath() {
var numPts = Math.floor(this.pt.v);
var angle = Math.PI * 2 / numPts;
var rad = this.or.v;
var roundness = this.os.v;
var perimSegment = 2 * Math.PI * rad / (numPts * 4);
var i;
var currentAng = -Math.PI * 0.5;
var dir = this.data.d === 3 ? -1 : 1;
currentAng += this.r.v;
this.v._length = 0;
for (i = 0; i < numPts; i += 1) {
var x = rad * Math.cos(currentAng);
var y = rad * Math.sin(currentAng);
var ox = x === 0 && y === 0 ? 0 : y / Math.sqrt(x * x + y * y);
var oy = x === 0 && y === 0 ? 0 : -x / Math.sqrt(x * x + y * y);
x += +this.p.v[0];
y += +this.p.v[1];
this.v.setTripleAt(x, y, x - ox * perimSegment * roundness * dir, y - oy * perimSegment * roundness * dir, x + ox * perimSegment * roundness * dir, y + oy * perimSegment * roundness * dir, i, true);
currentAng += angle * dir;
}
this.paths.length = 0;
this.paths[0] = this.v;
}
};
extendPrototype([DynamicPropertyContainer], StarShapePropertyFactory);
return StarShapePropertyFactory;
}();
var RectShapeProperty = function() {
function RectShapePropertyFactory(elem2, data2) {
this.v = shapePool.newElement();
this.v.c = true;
this.localShapeCollection = shapeCollectionPool.newShapeCollection();
this.localShapeCollection.addShape(this.v);
this.paths = this.localShapeCollection;
this.elem = elem2;
this.comp = elem2.comp;
this.frameId = -1;
this.d = data2.d;
this.initDynamicPropertyContainer(elem2);
this.p = PropertyFactory.getProp(elem2, data2.p, 1, 0, this);
this.s = PropertyFactory.getProp(elem2, data2.s, 1, 0, this);
this.r = PropertyFactory.getProp(elem2, data2.r, 0, 0, this);
if (this.dynamicProperties.length) {
this.k = true;
} else {
this.k = false;
this.convertRectToPath();
}
}
RectShapePropertyFactory.prototype = {
convertRectToPath: function convertRectToPath() {
var p0 = this.p.v[0];
var p1 = this.p.v[1];
var v0 = this.s.v[0] / 2;
var v1 = this.s.v[1] / 2;
var round2 = bmMin(v0, v1, this.r.v);
var cPoint = round2 * (1 - roundCorner);
this.v._length = 0;
if (this.d === 2 || this.d === 1) {
this.v.setTripleAt(p0 + v0, p1 - v1 + round2, p0 + v0, p1 - v1 + round2, p0 + v0, p1 - v1 + cPoint, 0, true);
this.v.setTripleAt(p0 + v0, p1 + v1 - round2, p0 + v0, p1 + v1 - cPoint, p0 + v0, p1 + v1 - round2, 1, true);
if (round2 !== 0) {
this.v.setTripleAt(p0 + v0 - round2, p1 + v1, p0 + v0 - round2, p1 + v1, p0 + v0 - cPoint, p1 + v1, 2, true);
this.v.setTripleAt(p0 - v0 + round2, p1 + v1, p0 - v0 + cPoint, p1 + v1, p0 - v0 + round2, p1 + v1, 3, true);
this.v.setTripleAt(p0 - v0, p1 + v1 - round2, p0 - v0, p1 + v1 - round2, p0 - v0, p1 + v1 - cPoint, 4, true);
this.v.setTripleAt(p0 - v0, p1 - v1 + round2, p0 - v0, p1 - v1 + cPoint, p0 - v0, p1 - v1 + round2, 5, true);
this.v.setTripleAt(p0 - v0 + round2, p1 - v1, p0 - v0 + round2, p1 - v1, p0 - v0 + cPoint, p1 - v1, 6, true);
this.v.setTripleAt(p0 + v0 - round2, p1 - v1, p0 + v0 - cPoint, p1 - v1, p0 + v0 - round2, p1 - v1, 7, true);
} else {
this.v.setTripleAt(p0 - v0, p1 + v1, p0 - v0 + cPoint, p1 + v1, p0 - v0, p1 + v1, 2);
this.v.setTripleAt(p0 - v0, p1 - v1, p0 - v0, p1 - v1 + cPoint, p0 - v0, p1 - v1, 3);
}
} else {
this.v.setTripleAt(p0 + v0, p1 - v1 + round2, p0 + v0, p1 - v1 + cPoint, p0 + v0, p1 - v1 + round2, 0, true);
if (round2 !== 0) {
this.v.setTripleAt(p0 + v0 - round2, p1 - v1, p0 + v0 - round2, p1 - v1, p0 + v0 - cPoint, p1 - v1, 1, true);
this.v.setTripleAt(p0 - v0 + round2, p1 - v1, p0 - v0 + cPoint, p1 - v1, p0 - v0 + round2, p1 - v1, 2, true);
this.v.setTripleAt(p0 - v0, p1 - v1 + round2, p0 - v0, p1 - v1 + round2, p0 - v0, p1 - v1 + cPoint, 3, true);
this.v.setTripleAt(p0 - v0, p1 + v1 - round2, p0 - v0, p1 + v1 - cPoint, p0 - v0, p1 + v1 - round2, 4, true);
this.v.setTripleAt(p0 - v0 + round2, p1 + v1, p0 - v0 + round2, p1 + v1, p0 - v0 + cPoint, p1 + v1, 5, true);
this.v.setTripleAt(p0 + v0 - round2, p1 + v1, p0 + v0 - cPoint, p1 + v1, p0 + v0 - round2, p1 + v1, 6, true);
this.v.setTripleAt(p0 + v0, p1 + v1 - round2, p0 + v0, p1 + v1 - round2, p0 + v0, p1 + v1 - cPoint, 7, true);
} else {
this.v.setTripleAt(p0 - v0, p1 - v1, p0 - v0 + cPoint, p1 - v1, p0 - v0, p1 - v1, 1, true);
this.v.setTripleAt(p0 - v0, p1 + v1, p0 - v0, p1 + v1 - cPoint, p0 - v0, p1 + v1, 2, true);
this.v.setTripleAt(p0 + v0, p1 + v1, p0 + v0 - cPoint, p1 + v1, p0 + v0, p1 + v1, 3, true);
}
}
},
getValue: function getValue() {
if (this.elem.globalData.frameId === this.frameId) {
return;
}
this.frameId = this.elem.globalData.frameId;
this.iterateDynamicProperties();
if (this._mdf) {
this.convertRectToPath();
}
},
reset: resetShape
};
extendPrototype([DynamicPropertyContainer], RectShapePropertyFactory);
return RectShapePropertyFactory;
}();
function getShapeProp(elem2, data2, type) {
var prop;
if (type === 3 || type === 4) {
var dataProp = type === 3 ? data2.pt : data2.ks;
var keys = dataProp.k;
if (keys.length) {
prop = new KeyframedShapeProperty(elem2, data2, type);
} else {
prop = new ShapeProperty(elem2, data2, type);
}
} else if (type === 5) {
prop = new RectShapeProperty(elem2, data2);
} else if (type === 6) {
prop = new EllShapeProperty(elem2, data2);
} else if (type === 7) {
prop = new StarShapeProperty(elem2, data2);
}
if (prop.k) {
elem2.addDynamicProperty(prop);
}
return prop;
}
function getConstructorFunction() {
return ShapeProperty;
}
function getKeyframedConstructorFunction() {
return KeyframedShapeProperty;
}
var ob2 = {};
ob2.getShapeProp = getShapeProp;
ob2.getConstructorFunction = getConstructorFunction;
ob2.getKeyframedConstructorFunction = getKeyframedConstructorFunction;
return ob2;
}();
var Matrix = /* @__PURE__ */ function() {
var _cos = Math.cos;
var _sin = Math.sin;
var _tan = Math.tan;
var _rnd = Math.round;
function reset() {
this.props[0] = 1;
this.props[1] = 0;
this.props[2] = 0;
this.props[3] = 0;
this.props[4] = 0;
this.props[5] = 1;
this.props[6] = 0;
this.props[7] = 0;
this.props[8] = 0;
this.props[9] = 0;
this.props[10] = 1;
this.props[11] = 0;
this.props[12] = 0;
this.props[13] = 0;
this.props[14] = 0;
this.props[15] = 1;
return this;
}
function rotate(angle) {
if (angle === 0) {
return this;
}
var mCos = _cos(angle);
var mSin = _sin(angle);
return this._t(mCos, -mSin, 0, 0, mSin, mCos, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1);
}
function rotateX(angle) {
if (angle === 0) {
return this;
}
var mCos = _cos(angle);
var mSin = _sin(angle);
return this._t(1, 0, 0, 0, 0, mCos, -mSin, 0, 0, mSin, mCos, 0, 0, 0, 0, 1);
}
function rotateY(angle) {
if (angle === 0) {
return this;
}
var mCos = _cos(angle);
var mSin = _sin(angle);
return this._t(mCos, 0, mSin, 0, 0, 1, 0, 0, -mSin, 0, mCos, 0, 0, 0, 0, 1);
}
function rotateZ(angle) {
if (angle === 0) {
return this;
}
var mCos = _cos(angle);
var mSin = _sin(angle);
return this._t(mCos, -mSin, 0, 0, mSin, mCos, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1);
}
function shear(sx, sy) {
return this._t(1, sy, sx, 1, 0, 0);
}
function skew(ax, ay) {
return this.shear(_tan(ax), _tan(ay));
}
function skewFromAxis(ax, angle) {
var mCos = _cos(angle);
var mSin = _sin(angle);
return this._t(mCos, mSin, 0, 0, -mSin, mCos, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1)._t(1, 0, 0, 0, _tan(ax), 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1)._t(mCos, -mSin, 0, 0, mSin, mCos, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1);
}
function scale2(sx, sy, sz) {
if (!sz && sz !== 0) {
sz = 1;
}
if (sx === 1 && sy === 1 && sz === 1) {
return this;
}
return this._t(sx, 0, 0, 0, 0, sy, 0, 0, 0, 0, sz, 0, 0, 0, 0, 1);
}
function setTransform(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) {
this.props[0] = a;
this.props[1] = b;
this.props[2] = c;
this.props[3] = d;
this.props[4] = e;
this.props[5] = f;
this.props[6] = g;
this.props[7] = h;
this.props[8] = i;
this.props[9] = j;
this.props[10] = k;
this.props[11] = l;
this.props[12] = m;
this.props[13] = n;
this.props[14] = o;
this.props[15] = p;
return this;
}
function translate(tx, ty, tz) {
tz = tz || 0;
if (tx !== 0 || ty !== 0 || tz !== 0) {
return this._t(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, tx, ty, tz, 1);
}
return this;
}
function transform2(a2, b2, c2, d2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, p2) {
var _p = this.props;
if (a2 === 1 && b2 === 0 && c2 === 0 && d2 === 0 && e2 === 0 && f2 === 1 && g2 === 0 && h2 === 0 && i2 === 0 && j2 === 0 && k2 === 1 && l2 === 0) {
_p[12] = _p[12] * a2 + _p[15] * m2;
_p[13] = _p[13] * f2 + _p[15] * n2;
_p[14] = _p[14] * k2 + _p[15] * o2;
_p[15] *= p2;
this._identityCalculated = false;
return this;
}
var a1 = _p[0];
var b1 = _p[1];
var c1 = _p[2];
var d1 = _p[3];
var e1 = _p[4];
var f1 = _p[5];
var g1 = _p[6];
var h1 = _p[7];
var i1 = _p[8];
var j1 = _p[9];
var k1 = _p[10];
var l1 = _p[11];
var m1 = _p[12];
var n1 = _p[13];
var o1 = _p[14];
var p1 = _p[15];
_p[0] = a1 * a2 + b1 * e2 + c1 * i2 + d1 * m2;
_p[1] = a1 * b2 + b1 * f2 + c1 * j2 + d1 * n2;
_p[2] = a1 * c2 + b1 * g2 + c1 * k2 + d1 * o2;
_p[3] = a1 * d2 + b1 * h2 + c1 * l2 + d1 * p2;
_p[4] = e1 * a2 + f1 * e2 + g1 * i2 + h1 * m2;
_p[5] = e1 * b2 + f1 * f2 + g1 * j2 + h1 * n2;
_p[6] = e1 * c2 + f1 * g2 + g1 * k2 + h1 * o2;
_p[7] = e1 * d2 + f1 * h2 + g1 * l2 + h1 * p2;
_p[8] = i1 * a2 + j1 * e2 + k1 * i2 + l1 * m2;
_p[9] = i1 * b2 + j1 * f2 + k1 * j2 + l1 * n2;
_p[10] = i1 * c2 + j1 * g2 + k1 * k2 + l1 * o2;
_p[11] = i1 * d2 + j1 * h2 + k1 * l2 + l1 * p2;
_p[12] = m1 * a2 + n1 * e2 + o1 * i2 + p1 * m2;
_p[13] = m1 * b2 + n1 * f2 + o1 * j2 + p1 * n2;
_p[14] = m1 * c2 + n1 * g2 + o1 * k2 + p1 * o2;
_p[15] = m1 * d2 + n1 * h2 + o1 * l2 + p1 * p2;
this._identityCalculated = false;
return this;
}
function multiply(matrix) {
var matrixProps = matrix.props;
return this.transform(matrixProps[0], matrixProps[1], matrixProps[2], matrixProps[3], matrixProps[4], matrixProps[5], matrixProps[6], matrixProps[7], matrixProps[8], matrixProps[9], matrixProps[10], matrixProps[11], matrixProps[12], matrixProps[13], matrixProps[14], matrixProps[15]);
}
function isIdentity() {
if (!this._identityCalculated) {
this._identity = !(this.props[0] !== 1 || this.props[1] !== 0 || this.props[2] !== 0 || this.props[3] !== 0 || this.props[4] !== 0 || this.props[5] !== 1 || this.props[6] !== 0 || this.props[7] !== 0 || this.props[8] !== 0 || this.props[9] !== 0 || this.props[10] !== 1 || this.props[11] !== 0 || this.props[12] !== 0 || this.props[13] !== 0 || this.props[14] !== 0 || this.props[15] !== 1);
this._identityCalculated = true;
}
return this._identity;
}
function equals(matr) {
var i = 0;
while (i < 16) {
if (matr.props[i] !== this.props[i]) {
return false;
}
i += 1;
}
return true;
}
function clone(matr) {
var i;
for (i = 0; i < 16; i += 1) {
matr.props[i] = this.props[i];
}
return matr;
}
function cloneFromProps(props) {
var i;
for (i = 0; i < 16; i += 1) {
this.props[i] = props[i];
}
}
function applyToPoint(x, y, z) {
return {
x: x * this.props[0] + y * this.props[4] + z * this.props[8] + this.props[12],
y: x * this.props[1] + y * this.props[5] + z * this.props[9] + this.props[13],
z: x * this.props[2] + y * this.props[6] + z * this.props[10] + this.props[14]
};
}
function applyToX(x, y, z) {
return x * this.props[0] + y * this.props[4] + z * this.props[8] + this.props[12];
}
function applyToY(x, y, z) {
return x * this.props[1] + y * this.props[5] + z * this.props[9] + this.props[13];
}
function applyToZ(x, y, z) {
return x * this.props[2] + y * this.props[6] + z * this.props[10] + this.props[14];
}
function getInverseMatrix() {
var determinant = this.props[0] * this.props[5] - this.props[1] * this.props[4];
var a = this.props[5] / determinant;
var b = -this.props[1] / determinant;
var c = -this.props[4] / determinant;
var d = this.props[0] / determinant;
var e = (this.props[4] * this.props[13] - this.props[5] * this.props[12]) / determinant;
var f = -(this.props[0] * this.props[13] - this.props[1] * this.props[12]) / determinant;
var inverseMatrix = new Matrix();
inverseMatrix.props[0] = a;
inverseMatrix.props[1] = b;
inverseMatrix.props[4] = c;
inverseMatrix.props[5] = d;
inverseMatrix.props[12] = e;
inverseMatrix.props[13] = f;
return inverseMatrix;
}
function inversePoint(pt) {
var inverseMatrix = this.getInverseMatrix();
return inverseMatrix.applyToPointArray(pt[0], pt[1], pt[2] || 0);
}
function inversePoints(pts) {
var i;
var len = pts.length;
var retPts = [];
for (i = 0; i < len; i += 1) {
retPts[i] = inversePoint(pts[i]);
}
return retPts;
}
function applyToTriplePoints(pt1, pt2, pt3) {
var arr = createTypedArray("float32", 6);
if (this.isIdentity()) {
arr[0] = pt1[0];
arr[1] = pt1[1];
arr[2] = pt2[0];
arr[3] = pt2[1];
arr[4] = pt3[0];
arr[5] = pt3[1];
} else {
var p0 = this.props[0];
var p1 = this.props[1];
var p4 = this.props[4];
var p5 = this.props[5];
var p12 = this.props[12];
var p13 = this.props[13];
arr[0] = pt1[0] * p0 + pt1[1] * p4 + p12;
arr[1] = pt1[0] * p1 + pt1[1] * p5 + p13;
arr[2] = pt2[0] * p0 + pt2[1] * p4 + p12;
arr[3] = pt2[0] * p1 + pt2[1] * p5 + p13;
arr[4] = pt3[0] * p0 + pt3[1] * p4 + p12;
arr[5] = pt3[0] * p1 + pt3[1] * p5 + p13;
}
return arr;
}
function applyToPointArray(x, y, z) {
var arr;
if (this.isIdentity()) {
arr = [x, y, z];
} else {
arr = [x * this.props[0] + y * this.props[4] + z * this.props[8] + this.props[12], x * this.props[1] + y * this.props[5] + z * this.props[9] + this.props[13], x * this.props[2] + y * this.props[6] + z * this.props[10] + this.props[14]];
}
return arr;
}
function applyToPointStringified(x, y) {
if (this.isIdentity()) {
return x + "," + y;
}
var _p = this.props;
return Math.round((x * _p[0] + y * _p[4] + _p[12]) * 100) / 100 + "," + Math.round((x * _p[1] + y * _p[5] + _p[13]) * 100) / 100;
}
function toCSS() {
var i = 0;
var props = this.props;
var cssValue = "matrix3d(";
var v = 1e4;
while (i < 16) {
cssValue += _rnd(props[i] * v) / v;
cssValue += i === 15 ? ")" : ",";
i += 1;
}
return cssValue;
}
function roundMatrixProperty(val2) {
var v = 1e4;
if (val2 < 1e-6 && val2 > 0 || val2 > -1e-6 && val2 < 0) {
return _rnd(val2 * v) / v;
}
return val2;
}
function to2dCSS() {
var props = this.props;
var _a = roundMatrixProperty(props[0]);
var _b = roundMatrixProperty(props[1]);
var _c = roundMatrixProperty(props[4]);
var _d = roundMatrixProperty(props[5]);
var _e = roundMatrixProperty(props[12]);
var _f = roundMatrixProperty(props[13]);
return "matrix(" + _a + "," + _b + "," + _c + "," + _d + "," + _e + "," + _f + ")";
}
return function() {
this.reset = reset;
this.rotate = rotate;
this.rotateX = rotateX;
this.rotateY = rotateY;
this.rotateZ = rotateZ;
this.skew = skew;
this.skewFromAxis = skewFromAxis;
this.shear = shear;
this.scale = scale2;
this.setTransform = setTransform;
this.translate = translate;
this.transform = transform2;
this.multiply = multiply;
this.applyToPoint = applyToPoint;
this.applyToX = applyToX;
this.applyToY = applyToY;
this.applyToZ = applyToZ;
this.applyToPointArray = applyToPointArray;
this.applyToTriplePoints = applyToTriplePoints;
this.applyToPointStringified = applyToPointStringified;
this.toCSS = toCSS;
this.to2dCSS = to2dCSS;
this.clone = clone;
this.cloneFromProps = cloneFromProps;
this.equals = equals;
this.inversePoints = inversePoints;
this.inversePoint = inversePoint;
this.getInverseMatrix = getInverseMatrix;
this._t = this.transform;
this.isIdentity = isIdentity;
this._identity = true;
this._identityCalculated = false;
this.props = createTypedArray("float32", 16);
this.reset();
};
}();
function _typeof$3(obj) {
"@babel/helpers - typeof";
if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
_typeof$3 = function _typeof2(obj2) {
return typeof obj2;
};
} else {
_typeof$3 = function _typeof2(obj2) {
return obj2 && typeof Symbol === "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
};
}
return _typeof$3(obj);
}
var lottie = {};
var standalone = "__[STANDALONE]__";
var animationData = "__[ANIMATIONDATA]__";
var renderer = "";
function setLocation(href) {
setLocationHref(href);
}
function searchAnimations() {
if (standalone === true) {
animationManager.searchAnimations(animationData, standalone, renderer);
} else {
animationManager.searchAnimations();
}
}
function setSubframeRendering(flag) {
setSubframeEnabled(flag);
}
function setPrefix(prefix) {
setIdPrefix(prefix);
}
function loadAnimation(params) {
if (standalone === true) {
params.animationData = JSON.parse(animationData);
}
return animationManager.loadAnimation(params);
}
function setQuality(value2) {
if (typeof value2 === "string") {
switch (value2) {
case "high":
setDefaultCurveSegments(200);
break;
default:
case "medium":
setDefaultCurveSegments(50);
break;
case "low":
setDefaultCurveSegments(10);
break;
}
} else if (!isNaN(value2) && value2 > 1) {
setDefaultCurveSegments(value2);
}
if (getDefaultCurveSegments() >= 50) {
roundValues(false);
} else {
roundValues(true);
}
}
function inBrowser() {
return typeof navigator !== "undefined";
}
function installPlugin(type, plugin) {
if (type === "expressions") {
setExpressionsPlugin(plugin);
}
}
function getFactory(name2) {
switch (name2) {
case "propertyFactory":
return PropertyFactory;
case "shapePropertyFactory":
return ShapePropertyFactory;
case "matrix":
return Matrix;
default:
return null;
}
}
lottie.play = animationManager.play;
lottie.pause = animationManager.pause;
lottie.setLocationHref = setLocation;
lottie.togglePause = animationManager.togglePause;
lottie.setSpeed = animationManager.setSpeed;
lottie.setDirection = animationManager.setDirection;
lottie.stop = animationManager.stop;
lottie.searchAnimations = searchAnimations;
lottie.registerAnimation = animationManager.registerAnimation;
lottie.loadAnimation = loadAnimation;
lottie.setSubframeRendering = setSubframeRendering;
lottie.resize = animationManager.resize;
lottie.goToAndStop = animationManager.goToAndStop;
lottie.destroy = animationManager.destroy;
lottie.setQuality = setQuality;
lottie.inBrowser = inBrowser;
lottie.installPlugin = installPlugin;
lottie.freeze = animationManager.freeze;
lottie.unfreeze = animationManager.unfreeze;
lottie.setVolume = animationManager.setVolume;
lottie.mute = animationManager.mute;
lottie.unmute = animationManager.unmute;
lottie.getRegisteredAnimations = animationManager.getRegisteredAnimations;
lottie.useWebWorker = setWebWorker;
lottie.setIDPrefix = setPrefix;
lottie.__getFactory = getFactory;
lottie.version = "5.12.2";
function checkReady() {
if (document.readyState === "complete") {
clearInterval(readyStateCheckInterval);
searchAnimations();
}
}
function getQueryVariable(variable) {
var vars = queryString.split("&");
for (var i = 0; i < vars.length; i += 1) {
var pair = vars[i].split("=");
if (decodeURIComponent(pair[0]) == variable) {
return decodeURIComponent(pair[1]);
}
}
return null;
}
var queryString = "";
if (standalone) {
var scripts = document.getElementsByTagName("script");
var index = scripts.length - 1;
var myScript = scripts[index] || {
src: ""
};
queryString = myScript.src ? myScript.src.replace(/^[^\?]+\??/, "") : "";
renderer = getQueryVariable("renderer");
}
var readyStateCheckInterval = setInterval(checkReady, 100);
try {
if (!((typeof exports === "undefined" ? "undefined" : _typeof$3(exports)) === "object" && typeof module !== "undefined") && !(typeof define === "function" && define.amd)) {
window.bodymovin = lottie;
}
} catch (err) {
}
var ShapeModifiers = function() {
var ob2 = {};
var modifiers = {};
ob2.registerModifier = registerModifier;
ob2.getModifier = getModifier;
function registerModifier(nm, factory) {
if (!modifiers[nm]) {
modifiers[nm] = factory;
}
}
function getModifier(nm, elem2, data2) {
return new modifiers[nm](elem2, data2);
}
return ob2;
}();
function ShapeModifier() {
}
ShapeModifier.prototype.initModifierProperties = function() {
};
ShapeModifier.prototype.addShapeToModifier = function() {
};
ShapeModifier.prototype.addShape = function(data2) {
if (!this.closed) {
data2.sh.container.addDynamicProperty(data2.sh);
var shapeData = {
shape: data2.sh,
data: data2,
localShapeCollection: shapeCollectionPool.newShapeCollection()
};
this.shapes.push(shapeData);
this.addShapeToModifier(shapeData);
if (this._isAnimated) {
data2.setAsAnimated();
}
}
};
ShapeModifier.prototype.init = function(elem2, data2) {
this.shapes = [];
this.elem = elem2;
this.initDynamicPropertyContainer(elem2);
this.initModifierProperties(elem2, data2);
this.frameId = initialDefaultFrame;
this.closed = false;
this.k = false;
if (this.dynamicProperties.length) {
this.k = true;
} else {
this.getValue(true);
}
};
ShapeModifier.prototype.processKeys = function() {
if (this.elem.globalData.frameId === this.frameId) {
return;
}
this.frameId = this.elem.globalData.frameId;
this.iterateDynamicProperties();
};
extendPrototype([DynamicPropertyContainer], ShapeModifier);
function TrimModifier() {
}
extendPrototype([ShapeModifier], TrimModifier);
TrimModifier.prototype.initModifierProperties = function(elem2, data2) {
this.s = PropertyFactory.getProp(elem2, data2.s, 0, 0.01, this);
this.e = PropertyFactory.getProp(elem2, data2.e, 0, 0.01, this);
this.o = PropertyFactory.getProp(elem2, data2.o, 0, 0, this);
this.sValue = 0;
this.eValue = 0;
this.getValue = this.processKeys;
this.m = data2.m;
this._isAnimated = !!this.s.effectsSequence.length || !!this.e.effectsSequence.length || !!this.o.effectsSequence.length;
};
TrimModifier.prototype.addShapeToModifier = function(shapeData) {
shapeData.pathsData = [];
};
TrimModifier.prototype.calculateShapeEdges = function(s, e, shapeLength, addedLength, totalModifierLength) {
var segments = [];
if (e <= 1) {
segments.push({
s,
e
});
} else if (s >= 1) {
segments.push({
s: s - 1,
e: e - 1
});
} else {
segments.push({
s,
e: 1
});
segments.push({
s: 0,
e: e - 1
});
}
var shapeSegments = [];
var i;
var len = segments.length;
var segmentOb;
for (i = 0; i < len; i += 1) {
segmentOb = segments[i];
if (!(segmentOb.e * totalModifierLength < addedLength || segmentOb.s * totalModifierLength > addedLength + shapeLength)) {
var shapeS;
var shapeE;
if (segmentOb.s * totalModifierLength <= addedLength) {
shapeS = 0;
} else {
shapeS = (segmentOb.s * totalModifierLength - addedLength) / shapeLength;
}
if (segmentOb.e * totalModifierLength >= addedLength + shapeLength) {
shapeE = 1;
} else {
shapeE = (segmentOb.e * totalModifierLength - addedLength) / shapeLength;
}
shapeSegments.push([shapeS, shapeE]);
}
}
if (!shapeSegments.length) {
shapeSegments.push([0, 0]);
}
return shapeSegments;
};
TrimModifier.prototype.releasePathsData = function(pathsData) {
var i;
var len = pathsData.length;
for (i = 0; i < len; i += 1) {
segmentsLengthPool.release(pathsData[i]);
}
pathsData.length = 0;
return pathsData;
};
TrimModifier.prototype.processShapes = function(_isFirstFrame) {
var s;
var e;
if (this._mdf || _isFirstFrame) {
var o = this.o.v % 360 / 360;
if (o < 0) {
o += 1;
}
if (this.s.v > 1) {
s = 1 + o;
} else if (this.s.v < 0) {
s = 0 + o;
} else {
s = this.s.v + o;
}
if (this.e.v > 1) {
e = 1 + o;
} else if (this.e.v < 0) {
e = 0 + o;
} else {
e = this.e.v + o;
}
if (s > e) {
var _s = s;
s = e;
e = _s;
}
s = Math.round(s * 1e4) * 1e-4;
e = Math.round(e * 1e4) * 1e-4;
this.sValue = s;
this.eValue = e;
} else {
s = this.sValue;
e = this.eValue;
}
var shapePaths;
var i;
var len = this.shapes.length;
var j;
var jLen;
var pathsData;
var pathData;
var totalShapeLength;
var totalModifierLength = 0;
if (e === s) {
for (i = 0; i < len; i += 1) {
this.shapes[i].localShapeCollection.releaseShapes();
this.shapes[i].shape._mdf = true;
this.shapes[i].shape.paths = this.shapes[i].localShapeCollection;
if (this._mdf) {
this.shapes[i].pathsData.length = 0;
}
}
} else if (!(e === 1 && s === 0 || e === 0 && s === 1)) {
var segments = [];
var shapeData;
var localShapeCollection;
for (i = 0; i < len; i += 1) {
shapeData = this.shapes[i];
if (!shapeData.shape._mdf && !this._mdf && !_isFirstFrame && this.m !== 2) {
shapeData.shape.paths = shapeData.localShapeCollection;
} else {
shapePaths = shapeData.shape.paths;
jLen = shapePaths._length;
totalShapeLength = 0;
if (!shapeData.shape._mdf && shapeData.pathsData.length) {
totalShapeLength = shapeData.totalShapeLength;
} else {
pathsData = this.releasePathsData(shapeData.pathsData);
for (j = 0; j < jLen; j += 1) {
pathData = bez.getSegmentsLength(shapePaths.shapes[j]);
pathsData.push(pathData);
totalShapeLength += pathData.totalLength;
}
shapeData.totalShapeLength = totalShapeLength;
shapeData.pathsData = pathsData;
}
totalModifierLength += totalShapeLength;
shapeData.shape._mdf = true;
}
}
var shapeS = s;
var shapeE = e;
var addedLength = 0;
var edges;
for (i = len - 1; i >= 0; i -= 1) {
shapeData = this.shapes[i];
if (shapeData.shape._mdf) {
localShapeCollection = shapeData.localShapeCollection;
localShapeCollection.releaseShapes();
if (this.m === 2 && len > 1) {
edges = this.calculateShapeEdges(s, e, shapeData.totalShapeLength, addedLength, totalModifierLength);
addedLength += shapeData.totalShapeLength;
} else {
edges = [[shapeS, shapeE]];
}
jLen = edges.length;
for (j = 0; j < jLen; j += 1) {
shapeS = edges[j][0];
shapeE = edges[j][1];
segments.length = 0;
if (shapeE <= 1) {
segments.push({
s: shapeData.totalShapeLength * shapeS,
e: shapeData.totalShapeLength * shapeE
});
} else if (shapeS >= 1) {
segments.push({
s: shapeData.totalShapeLength * (shapeS - 1),
e: shapeData.totalShapeLength * (shapeE - 1)
});
} else {
segments.push({
s: shapeData.totalShapeLength * shapeS,
e: shapeData.totalShapeLength
});
segments.push({
s: 0,
e: shapeData.totalShapeLength * (shapeE - 1)
});
}
var newShapesData = this.addShapes(shapeData, segments[0]);
if (segments[0].s !== segments[0].e) {
if (segments.length > 1) {
var lastShapeInCollection = shapeData.shape.paths.shapes[shapeData.shape.paths._length - 1];
if (lastShapeInCollection.c) {
var lastShape = newShapesData.pop();
this.addPaths(newShapesData, localShapeCollection);
newShapesData = this.addShapes(shapeData, segments[1], lastShape);
} else {
this.addPaths(newShapesData, localShapeCollection);
newShapesData = this.addShapes(shapeData, segments[1]);
}
}
this.addPaths(newShapesData, localShapeCollection);
}
}
shapeData.shape.paths = localShapeCollection;
}
}
} else if (this._mdf) {
for (i = 0; i < len; i += 1) {
this.shapes[i].pathsData.length = 0;
this.shapes[i].shape._mdf = true;
}
}
};
TrimModifier.prototype.addPaths = function(newPaths, localShapeCollection) {
var i;
var len = newPaths.length;
for (i = 0; i < len; i += 1) {
localShapeCollection.addShape(newPaths[i]);
}
};
TrimModifier.prototype.addSegment = function(pt1, pt2, pt3, pt4, shapePath, pos, newShape) {
shapePath.setXYAt(pt2[0], pt2[1], "o", pos);
shapePath.setXYAt(pt3[0], pt3[1], "i", pos + 1);
if (newShape) {
shapePath.setXYAt(pt1[0], pt1[1], "v", pos);
}
shapePath.setXYAt(pt4[0], pt4[1], "v", pos + 1);
};
TrimModifier.prototype.addSegmentFromArray = function(points, shapePath, pos, newShape) {
shapePath.setXYAt(points[1], points[5], "o", pos);
shapePath.setXYAt(points[2], points[6], "i", pos + 1);
if (newShape) {
shapePath.setXYAt(points[0], points[4], "v", pos);
}
shapePath.setXYAt(points[3], points[7], "v", pos + 1);
};
TrimModifier.prototype.addShapes = function(shapeData, shapeSegment, shapePath) {
var pathsData = shapeData.pathsData;
var shapePaths = shapeData.shape.paths.shapes;
var i;
var len = shapeData.shape.paths._length;
var j;
var jLen;
var addedLength = 0;
var currentLengthData;
var segmentCount;
var lengths;
var segment;
var shapes = [];
var initPos;
var newShape = true;
if (!shapePath) {
shapePath = shapePool.newElement();
segmentCount = 0;
initPos = 0;
} else {
segmentCount = shapePath._length;
initPos = shapePath._length;
}
shapes.push(shapePath);
for (i = 0; i < len; i += 1) {
lengths = pathsData[i].lengths;
shapePath.c = shapePaths[i].c;
jLen = shapePaths[i].c ? lengths.length : lengths.length + 1;
for (j = 1; j < jLen; j += 1) {
currentLengthData = lengths[j - 1];
if (addedLength + currentLengthData.addedLength < shapeSegment.s) {
addedLength += currentLengthData.addedLength;
shapePath.c = false;
} else if (addedLength > shapeSegment.e) {
shapePath.c = false;
break;
} else {
if (shapeSegment.s <= addedLength && shapeSegment.e >= addedLength + currentLengthData.addedLength) {
this.addSegment(shapePaths[i].v[j - 1], shapePaths[i].o[j - 1], shapePaths[i].i[j], shapePaths[i].v[j], shapePath, segmentCount, newShape);
newShape = false;
} else {
segment = bez.getNewSegment(shapePaths[i].v[j - 1], shapePaths[i].v[j], shapePaths[i].o[j - 1], shapePaths[i].i[j], (shapeSegment.s - addedLength) / currentLengthData.addedLength, (shapeSegment.e - addedLength) / currentLengthData.addedLength, lengths[j - 1]);
this.addSegmentFromArray(segment, shapePath, segmentCount, newShape);
newShape = false;
shapePath.c = false;
}
addedLength += currentLengthData.addedLength;
segmentCount += 1;
}
}
if (shapePaths[i].c && lengths.length) {
currentLengthData = lengths[j - 1];
if (addedLength <= shapeSegment.e) {
var segmentLength = lengths[j - 1].addedLength;
if (shapeSegment.s <= addedLength && shapeSegment.e >= addedLength + segmentLength) {
this.addSegment(shapePaths[i].v[j - 1], shapePaths[i].o[j - 1], shapePaths[i].i[0], shapePaths[i].v[0], shapePath, segmentCount, newShape);
newShape = false;
} else {
segment = bez.getNewSegment(shapePaths[i].v[j - 1], shapePaths[i].v[0], shapePaths[i].o[j - 1], shapePaths[i].i[0], (shapeSegment.s - addedLength) / segmentLength, (shapeSegment.e - addedLength) / segmentLength, lengths[j - 1]);
this.addSegmentFromArray(segment, shapePath, segmentCount, newShape);
newShape = false;
shapePath.c = false;
}
} else {
shapePath.c = false;
}
addedLength += currentLengthData.addedLength;
segmentCount += 1;
}
if (shapePath._length) {
shapePath.setXYAt(shapePath.v[initPos][0], shapePath.v[initPos][1], "i", initPos);
shapePath.setXYAt(shapePath.v[shapePath._length - 1][0], shapePath.v[shapePath._length - 1][1], "o", shapePath._length - 1);
}
if (addedLength > shapeSegment.e) {
break;
}
if (i < len - 1) {
shapePath = shapePool.newElement();
newShape = true;
shapes.push(shapePath);
segmentCount = 0;
}
}
return shapes;
};
function PuckerAndBloatModifier() {
}
extendPrototype([ShapeModifier], PuckerAndBloatModifier);
PuckerAndBloatModifier.prototype.initModifierProperties = function(elem2, data2) {
this.getValue = this.processKeys;
this.amount = PropertyFactory.getProp(elem2, data2.a, 0, null, this);
this._isAnimated = !!this.amount.effectsSequence.length;
};
PuckerAndBloatModifier.prototype.processPath = function(path, amount) {
var percent = amount / 100;
var centerPoint = [0, 0];
var pathLength = path._length;
var i = 0;
for (i = 0; i < pathLength; i += 1) {
centerPoint[0] += path.v[i][0];
centerPoint[1] += path.v[i][1];
}
centerPoint[0] /= pathLength;
centerPoint[1] /= pathLength;
var clonedPath = shapePool.newElement();
clonedPath.c = path.c;
var vX;
var vY;
var oX;
var oY;
var iX;
var iY;
for (i = 0; i < pathLength; i += 1) {
vX = path.v[i][0] + (centerPoint[0] - path.v[i][0]) * percent;
vY = path.v[i][1] + (centerPoint[1] - path.v[i][1]) * percent;
oX = path.o[i][0] + (centerPoint[0] - path.o[i][0]) * -percent;
oY = path.o[i][1] + (centerPoint[1] - path.o[i][1]) * -percent;
iX = path.i[i][0] + (centerPoint[0] - path.i[i][0]) * -percent;
iY = path.i[i][1] + (centerPoint[1] - path.i[i][1]) * -percent;
clonedPath.setTripleAt(vX, vY, oX, oY, iX, iY, i);
}
return clonedPath;
};
PuckerAndBloatModifier.prototype.processShapes = function(_isFirstFrame) {
var shapePaths;
var i;
var len = this.shapes.length;
var j;
var jLen;
var amount = this.amount.v;
if (amount !== 0) {
var shapeData;
var localShapeCollection;
for (i = 0; i < len; i += 1) {
shapeData = this.shapes[i];
localShapeCollection = shapeData.localShapeCollection;
if (!(!shapeData.shape._mdf && !this._mdf && !_isFirstFrame)) {
localShapeCollection.releaseShapes();
shapeData.shape._mdf = true;
shapePaths = shapeData.shape.paths.shapes;
jLen = shapeData.shape.paths._length;
for (j = 0; j < jLen; j += 1) {
localShapeCollection.addShape(this.processPath(shapePaths[j], amount));
}
}
shapeData.shape.paths = shapeData.localShapeCollection;
}
}
if (!this.dynamicProperties.length) {
this._mdf = false;
}
};
var TransformPropertyFactory = function() {
var defaultVector = [0, 0];
function applyToMatrix(mat) {
var _mdf = this._mdf;
this.iterateDynamicProperties();
this._mdf = this._mdf || _mdf;
if (this.a) {
mat.translate(-this.a.v[0], -this.a.v[1], this.a.v[2]);
}
if (this.s) {
mat.scale(this.s.v[0], this.s.v[1], this.s.v[2]);
}
if (this.sk) {
mat.skewFromAxis(-this.sk.v, this.sa.v);
}
if (this.r) {
mat.rotate(-this.r.v);
} else {
mat.rotateZ(-this.rz.v).rotateY(this.ry.v).rotateX(this.rx.v).rotateZ(-this.or.v[2]).rotateY(this.or.v[1]).rotateX(this.or.v[0]);
}
if (this.data.p.s) {
if (this.data.p.z) {
mat.translate(this.px.v, this.py.v, -this.pz.v);
} else {
mat.translate(this.px.v, this.py.v, 0);
}
} else {
mat.translate(this.p.v[0], this.p.v[1], -this.p.v[2]);
}
}
function processKeys(forceRender) {
if (this.elem.globalData.frameId === this.frameId) {
return;
}
if (this._isDirty) {
this.precalculateMatrix();
this._isDirty = false;
}
this.iterateDynamicProperties();
if (this._mdf || forceRender) {
var frameRate;
this.v.cloneFromProps(this.pre.props);
if (this.appliedTransformations < 1) {
this.v.translate(-this.a.v[0], -this.a.v[1], this.a.v[2]);
}
if (this.appliedTransformations < 2) {
this.v.scale(this.s.v[0], this.s.v[1], this.s.v[2]);
}
if (this.sk && this.appliedTransformations < 3) {
this.v.skewFromAxis(-this.sk.v, this.sa.v);
}
if (this.r && this.appliedTransformations < 4) {
this.v.rotate(-this.r.v);
} else if (!this.r && this.appliedTransformations < 4) {
this.v.rotateZ(-this.rz.v).rotateY(this.ry.v).rotateX(this.rx.v).rotateZ(-this.or.v[2]).rotateY(this.or.v[1]).rotateX(this.or.v[0]);
}
if (this.autoOriented) {
var v1;
var v2;
frameRate = this.elem.globalData.frameRate;
if (this.p && this.p.keyframes && this.p.getValueAtTime) {
if (this.p._caching.lastFrame + this.p.offsetTime <= this.p.keyframes[0].t) {
v1 = this.p.getValueAtTime((this.p.keyframes[0].t + 0.01) / frameRate, 0);
v2 = this.p.getValueAtTime(this.p.keyframes[0].t / frameRate, 0);
} else if (this.p._caching.lastFrame + this.p.offsetTime >= this.p.keyframes[this.p.keyframes.length - 1].t) {
v1 = this.p.getValueAtTime(this.p.keyframes[this.p.keyframes.length - 1].t / frameRate, 0);
v2 = this.p.getValueAtTime((this.p.keyframes[this.p.keyframes.length - 1].t - 0.05) / frameRate, 0);
} else {
v1 = this.p.pv;
v2 = this.p.getValueAtTime((this.p._caching.lastFrame + this.p.offsetTime - 0.01) / frameRate, this.p.offsetTime);
}
} else if (this.px && this.px.keyframes && this.py.keyframes && this.px.getValueAtTime && this.py.getValueAtTime) {
v1 = [];
v2 = [];
var px = this.px;
var py = this.py;
if (px._caching.lastFrame + px.offsetTime <= px.keyframes[0].t) {
v1[0] = px.getValueAtTime((px.keyframes[0].t + 0.01) / frameRate, 0);
v1[1] = py.getValueAtTime((py.keyframes[0].t + 0.01) / frameRate, 0);
v2[0] = px.getValueAtTime(px.keyframes[0].t / frameRate, 0);
v2[1] = py.getValueAtTime(py.keyframes[0].t / frameRate, 0);
} else if (px._caching.lastFrame + px.offsetTime >= px.keyframes[px.keyframes.length - 1].t) {
v1[0] = px.getValueAtTime(px.keyframes[px.keyframes.length - 1].t / frameRate, 0);
v1[1] = py.getValueAtTime(py.keyframes[py.keyframes.length - 1].t / frameRate, 0);
v2[0] = px.getValueAtTime((px.keyframes[px.keyframes.length - 1].t - 0.01) / frameRate, 0);
v2[1] = py.getValueAtTime((py.keyframes[py.keyframes.length - 1].t - 0.01) / frameRate, 0);
} else {
v1 = [px.pv, py.pv];
v2[0] = px.getValueAtTime((px._caching.lastFrame + px.offsetTime - 0.01) / frameRate, px.offsetTime);
v2[1] = py.getValueAtTime((py._caching.lastFrame + py.offsetTime - 0.01) / frameRate, py.offsetTime);
}
} else {
v2 = defaultVector;
v1 = v2;
}
this.v.rotate(-Math.atan2(v1[1] - v2[1], v1[0] - v2[0]));
}
if (this.data.p && this.data.p.s) {
if (this.data.p.z) {
this.v.translate(this.px.v, this.py.v, -this.pz.v);
} else {
this.v.translate(this.px.v, this.py.v, 0);
}
} else {
this.v.translate(this.p.v[0], this.p.v[1], -this.p.v[2]);
}
}
this.frameId = this.elem.globalData.frameId;
}
function precalculateMatrix() {
this.appliedTransformations = 0;
this.pre.reset();
if (!this.a.effectsSequence.length) {
this.pre.translate(-this.a.v[0], -this.a.v[1], this.a.v[2]);
this.appliedTransformations = 1;
} else {
return;
}
if (!this.s.effectsSequence.length) {
this.pre.scale(this.s.v[0], this.s.v[1], this.s.v[2]);
this.appliedTransformations = 2;
} else {
return;
}
if (this.sk) {
if (!this.sk.effectsSequence.length && !this.sa.effectsSequence.length) {
this.pre.skewFromAxis(-this.sk.v, this.sa.v);
this.appliedTransformations = 3;
} else {
return;
}
}
if (this.r) {
if (!this.r.effectsSequence.length) {
this.pre.rotate(-this.r.v);
this.appliedTransformations = 4;
}
} else if (!this.rz.effectsSequence.length && !this.ry.effectsSequence.length && !this.rx.effectsSequence.length && !this.or.effectsSequence.length) {
this.pre.rotateZ(-this.rz.v).rotateY(this.ry.v).rotateX(this.rx.v).rotateZ(-this.or.v[2]).rotateY(this.or.v[1]).rotateX(this.or.v[0]);
this.appliedTransformations = 4;
}
}
function autoOrient() {
}
function addDynamicProperty(prop) {
this._addDynamicProperty(prop);
this.elem.addDynamicProperty(prop);
this._isDirty = true;
}
function TransformProperty(elem2, data2, container) {
this.elem = elem2;
this.frameId = -1;
this.propType = "transform";
this.data = data2;
this.v = new Matrix();
this.pre = new Matrix();
this.appliedTransformations = 0;
this.initDynamicPropertyContainer(container || elem2);
if (data2.p && data2.p.s) {
this.px = PropertyFactory.getProp(elem2, data2.p.x, 0, 0, this);
this.py = PropertyFactory.getProp(elem2, data2.p.y, 0, 0, this);
if (data2.p.z) {
this.pz = PropertyFactory.getProp(elem2, data2.p.z, 0, 0, this);
}
} else {
this.p = PropertyFactory.getProp(elem2, data2.p || {
k: [0, 0, 0]
}, 1, 0, this);
}
if (data2.rx) {
this.rx = PropertyFactory.getProp(elem2, data2.rx, 0, degToRads, this);
this.ry = PropertyFactory.getProp(elem2, data2.ry, 0, degToRads, this);
this.rz = PropertyFactory.getProp(elem2, data2.rz, 0, degToRads, this);
if (data2.or.k[0].ti) {
var i;
var len = data2.or.k.length;
for (i = 0; i < len; i += 1) {
data2.or.k[i].to = null;
data2.or.k[i].ti = null;
}
}
this.or = PropertyFactory.getProp(elem2, data2.or, 1, degToRads, this);
this.or.sh = true;
} else {
this.r = PropertyFactory.getProp(elem2, data2.r || {
k: 0
}, 0, degToRads, this);
}
if (data2.sk) {
this.sk = PropertyFactory.getProp(elem2, data2.sk, 0, degToRads, this);
this.sa = PropertyFactory.getProp(elem2, data2.sa, 0, degToRads, this);
}
this.a = PropertyFactory.getProp(elem2, data2.a || {
k: [0, 0, 0]
}, 1, 0, this);
this.s = PropertyFactory.getProp(elem2, data2.s || {
k: [100, 100, 100]
}, 1, 0.01, this);
if (data2.o) {
this.o = PropertyFactory.getProp(elem2, data2.o, 0, 0.01, elem2);
} else {
this.o = {
_mdf: false,
v: 1
};
}
this._isDirty = true;
if (!this.dynamicProperties.length) {
this.getValue(true);
}
}
TransformProperty.prototype = {
applyToMatrix,
getValue: processKeys,
precalculateMatrix,
autoOrient
};
extendPrototype([DynamicPropertyContainer], TransformProperty);
TransformProperty.prototype.addDynamicProperty = addDynamicProperty;
TransformProperty.prototype._addDynamicProperty = DynamicPropertyContainer.prototype.addDynamicProperty;
function getTransformProperty(elem2, data2, container) {
return new TransformProperty(elem2, data2, container);
}
return {
getTransformProperty
};
}();
function RepeaterModifier() {
}
extendPrototype([ShapeModifier], RepeaterModifier);
RepeaterModifier.prototype.initModifierProperties = function(elem2, data2) {
this.getValue = this.processKeys;
this.c = PropertyFactory.getProp(elem2, data2.c, 0, null, this);
this.o = PropertyFactory.getProp(elem2, data2.o, 0, null, this);
this.tr = TransformPropertyFactory.getTransformProperty(elem2, data2.tr, this);
this.so = PropertyFactory.getProp(elem2, data2.tr.so, 0, 0.01, this);
this.eo = PropertyFactory.getProp(elem2, data2.tr.eo, 0, 0.01, this);
this.data = data2;
if (!this.dynamicProperties.length) {
this.getValue(true);
}
this._isAnimated = !!this.dynamicProperties.length;
this.pMatrix = new Matrix();
this.rMatrix = new Matrix();
this.sMatrix = new Matrix();
this.tMatrix = new Matrix();
this.matrix = new Matrix();
};
RepeaterModifier.prototype.applyTransforms = function(pMatrix, rMatrix, sMatrix, transform2, perc, inv) {
var dir = inv ? -1 : 1;
var scaleX = transform2.s.v[0] + (1 - transform2.s.v[0]) * (1 - perc);
var scaleY = transform2.s.v[1] + (1 - transform2.s.v[1]) * (1 - perc);
pMatrix.translate(transform2.p.v[0] * dir * perc, transform2.p.v[1] * dir * perc, transform2.p.v[2]);
rMatrix.translate(-transform2.a.v[0], -transform2.a.v[1], transform2.a.v[2]);
rMatrix.rotate(-transform2.r.v * dir * perc);
rMatrix.translate(transform2.a.v[0], transform2.a.v[1], transform2.a.v[2]);
sMatrix.translate(-transform2.a.v[0], -transform2.a.v[1], transform2.a.v[2]);
sMatrix.scale(inv ? 1 / scaleX : scaleX, inv ? 1 / scaleY : scaleY);
sMatrix.translate(transform2.a.v[0], transform2.a.v[1], transform2.a.v[2]);
};
RepeaterModifier.prototype.init = function(elem2, arr, pos, elemsData) {
this.elem = elem2;
this.arr = arr;
this.pos = pos;
this.elemsData = elemsData;
this._currentCopies = 0;
this._elements = [];
this._groups = [];
this.frameId = -1;
this.initDynamicPropertyContainer(elem2);
this.initModifierProperties(elem2, arr[pos]);
while (pos > 0) {
pos -= 1;
this._elements.unshift(arr[pos]);
}
if (this.dynamicProperties.length) {
this.k = true;
} else {
this.getValue(true);
}
};
RepeaterModifier.prototype.resetElements = function(elements) {
var i;
var len = elements.length;
for (i = 0; i < len; i += 1) {
elements[i]._processed = false;
if (elements[i].ty === "gr") {
this.resetElements(elements[i].it);
}
}
};
RepeaterModifier.prototype.cloneElements = function(elements) {
var newElements = JSON.parse(JSON.stringify(elements));
this.resetElements(newElements);
return newElements;
};
RepeaterModifier.prototype.changeGroupRender = function(elements, renderFlag) {
var i;
var len = elements.length;
for (i = 0; i < len; i += 1) {
elements[i]._render = renderFlag;
if (elements[i].ty === "gr") {
this.changeGroupRender(elements[i].it, renderFlag);
}
}
};
RepeaterModifier.prototype.processShapes = function(_isFirstFrame) {
var items;
var itemsTransform;
var i;
var dir;
var cont;
var hasReloaded = false;
if (this._mdf || _isFirstFrame) {
var copies = Math.ceil(this.c.v);
if (this._groups.length < copies) {
while (this._groups.length < copies) {
var group = {
it: this.cloneElements(this._elements),
ty: "gr"
};
group.it.push({
a: {
a: 0,
ix: 1,
k: [0, 0]
},
nm: "Transform",
o: {
a: 0,
ix: 7,
k: 100
},
p: {
a: 0,
ix: 2,
k: [0, 0]
},
r: {
a: 1,
ix: 6,
k: [{
s: 0,
e: 0,
t: 0
}, {
s: 0,
e: 0,
t: 1
}]
},
s: {
a: 0,
ix: 3,
k: [100, 100]
},
sa: {
a: 0,
ix: 5,
k: 0
},
sk: {
a: 0,
ix: 4,
k: 0
},
ty: "tr"
});
this.arr.splice(0, 0, group);
this._groups.splice(0, 0, group);
this._currentCopies += 1;
}
this.elem.reloadShapes();
hasReloaded = true;
}
cont = 0;
var renderFlag;
for (i = 0; i <= this._groups.length - 1; i += 1) {
renderFlag = cont < copies;
this._groups[i]._render = renderFlag;
this.changeGroupRender(this._groups[i].it, renderFlag);
if (!renderFlag) {
var elems = this.elemsData[i].it;
var transformData = elems[elems.length - 1];
if (transformData.transform.op.v !== 0) {
transformData.transform.op._mdf = true;
transformData.transform.op.v = 0;
} else {
transformData.transform.op._mdf = false;
}
}
cont += 1;
}
this._currentCopies = copies;
var offset = this.o.v;
var offsetModulo = offset % 1;
var roundOffset = offset > 0 ? Math.floor(offset) : Math.ceil(offset);
var pProps = this.pMatrix.props;
var rProps = this.rMatrix.props;
var sProps = this.sMatrix.props;
this.pMatrix.reset();
this.rMatrix.reset();
this.sMatrix.reset();
this.tMatrix.reset();
this.matrix.reset();
var iteration = 0;
if (offset > 0) {
while (iteration < roundOffset) {
this.applyTransforms(this.pMatrix, this.rMatrix, this.sMatrix, this.tr, 1, false);
iteration += 1;
}
if (offsetModulo) {
this.applyTransforms(this.pMatrix, this.rMatrix, this.sMatrix, this.tr, offsetModulo, false);
iteration += offsetModulo;
}
} else if (offset < 0) {
while (iteration > roundOffset) {
this.applyTransforms(this.pMatrix, this.rMatrix, this.sMatrix, this.tr, 1, true);
iteration -= 1;
}
if (offsetModulo) {
this.applyTransforms(this.pMatrix, this.rMatrix, this.sMatrix, this.tr, -offsetModulo, true);
iteration -= offsetModulo;
}
}
i = this.data.m === 1 ? 0 : this._currentCopies - 1;
dir = this.data.m === 1 ? 1 : -1;
cont = this._currentCopies;
var j;
var jLen;
while (cont) {
items = this.elemsData[i].it;
itemsTransform = items[items.length - 1].transform.mProps.v.props;
jLen = itemsTransform.length;
items[items.length - 1].transform.mProps._mdf = true;
items[items.length - 1].transform.op._mdf = true;
items[items.length - 1].transform.op.v = this._currentCopies === 1 ? this.so.v : this.so.v + (this.eo.v - this.so.v) * (i / (this._currentCopies - 1));
if (iteration !== 0) {
if (i !== 0 && dir === 1 || i !== this._currentCopies - 1 && dir === -1) {
this.applyTransforms(this.pMatrix, this.rMatrix, this.sMatrix, this.tr, 1, false);
}
this.matrix.transform(rProps[0], rProps[1], rProps[2], rProps[3], rProps[4], rProps[5], rProps[6], rProps[7], rProps[8], rProps[9], rProps[10], rProps[11], rProps[12], rProps[13], rProps[14], rProps[15]);
this.matrix.transform(sProps[0], sProps[1], sProps[2], sProps[3], sProps[4], sProps[5], sProps[6], sProps[7], sProps[8], sProps[9], sProps[10], sProps[11], sProps[12], sProps[13], sProps[14], sProps[15]);
this.matrix.transform(pProps[0], pProps[1], pProps[2], pProps[3], pProps[4], pProps[5], pProps[6], pProps[7], pProps[8], pProps[9], pProps[10], pProps[11], pProps[12], pProps[13], pProps[14], pProps[15]);
for (j = 0; j < jLen; j += 1) {
itemsTransform[j] = this.matrix.props[j];
}
this.matrix.reset();
} else {
this.matrix.reset();
for (j = 0; j < jLen; j += 1) {
itemsTransform[j] = this.matrix.props[j];
}
}
iteration += 1;
cont -= 1;
i += dir;
}
} else {
cont = this._currentCopies;
i = 0;
dir = 1;
while (cont) {
items = this.elemsData[i].it;
itemsTransform = items[items.length - 1].transform.mProps.v.props;
items[items.length - 1].transform.mProps._mdf = false;
items[items.length - 1].transform.op._mdf = false;
cont -= 1;
i += dir;
}
}
return hasReloaded;
};
RepeaterModifier.prototype.addShape = function() {
};
function RoundCornersModifier() {
}
extendPrototype([ShapeModifier], RoundCornersModifier);
RoundCornersModifier.prototype.initModifierProperties = function(elem2, data2) {
this.getValue = this.processKeys;
this.rd = PropertyFactory.getProp(elem2, data2.r, 0, null, this);
this._isAnimated = !!this.rd.effectsSequence.length;
};
RoundCornersModifier.prototype.processPath = function(path, round2) {
var clonedPath = shapePool.newElement();
clonedPath.c = path.c;
var i;
var len = path._length;
var currentV;
var currentI;
var currentO;
var closerV;
var distance;
var newPosPerc;
var index2 = 0;
var vX;
var vY;
var oX;
var oY;
var iX;
var iY;
for (i = 0; i < len; i += 1) {
currentV = path.v[i];
currentO = path.o[i];
currentI = path.i[i];
if (currentV[0] === currentO[0] && currentV[1] === currentO[1] && currentV[0] === currentI[0] && currentV[1] === currentI[1]) {
if ((i === 0 || i === len - 1) && !path.c) {
clonedPath.setTripleAt(currentV[0], currentV[1], currentO[0], currentO[1], currentI[0], currentI[1], index2);
index2 += 1;
} else {
if (i === 0) {
closerV = path.v[len - 1];
} else {
closerV = path.v[i - 1];
}
distance = Math.sqrt(Math.pow(currentV[0] - closerV[0], 2) + Math.pow(currentV[1] - closerV[1], 2));
newPosPerc = distance ? Math.min(distance / 2, round2) / distance : 0;
iX = currentV[0] + (closerV[0] - currentV[0]) * newPosPerc;
vX = iX;
iY = currentV[1] - (currentV[1] - closerV[1]) * newPosPerc;
vY = iY;
oX = vX - (vX - currentV[0]) * roundCorner;
oY = vY - (vY - currentV[1]) * roundCorner;
clonedPath.setTripleAt(vX, vY, oX, oY, iX, iY, index2);
index2 += 1;
if (i === len - 1) {
closerV = path.v[0];
} else {
closerV = path.v[i + 1];
}
distance = Math.sqrt(Math.pow(currentV[0] - closerV[0], 2) + Math.pow(currentV[1] - closerV[1], 2));
newPosPerc = distance ? Math.min(distance / 2, round2) / distance : 0;
oX = currentV[0] + (closerV[0] - currentV[0]) * newPosPerc;
vX = oX;
oY = currentV[1] + (closerV[1] - currentV[1]) * newPosPerc;
vY = oY;
iX = vX - (vX - currentV[0]) * roundCorner;
iY = vY - (vY - currentV[1]) * roundCorner;
clonedPath.setTripleAt(vX, vY, oX, oY, iX, iY, index2);
index2 += 1;
}
} else {
clonedPath.setTripleAt(path.v[i][0], path.v[i][1], path.o[i][0], path.o[i][1], path.i[i][0], path.i[i][1], index2);
index2 += 1;
}
}
return clonedPath;
};
RoundCornersModifier.prototype.processShapes = function(_isFirstFrame) {
var shapePaths;
var i;
var len = this.shapes.length;
var j;
var jLen;
var rd = this.rd.v;
if (rd !== 0) {
var shapeData;
var localShapeCollection;
for (i = 0; i < len; i += 1) {
shapeData = this.shapes[i];
localShapeCollection = shapeData.localShapeCollection;
if (!(!shapeData.shape._mdf && !this._mdf && !_isFirstFrame)) {
localShapeCollection.releaseShapes();
shapeData.shape._mdf = true;
shapePaths = shapeData.shape.paths.shapes;
jLen = shapeData.shape.paths._length;
for (j = 0; j < jLen; j += 1) {
localShapeCollection.addShape(this.processPath(shapePaths[j], rd));
}
}
shapeData.shape.paths = shapeData.localShapeCollection;
}
}
if (!this.dynamicProperties.length) {
this._mdf = false;
}
};
function floatEqual(a, b) {
return Math.abs(a - b) * 1e5 <= Math.min(Math.abs(a), Math.abs(b));
}
function floatZero(f) {
return Math.abs(f) <= 1e-5;
}
function lerp(p0, p1, amount) {
return p0 * (1 - amount) + p1 * amount;
}
function lerpPoint(p0, p1, amount) {
return [lerp(p0[0], p1[0], amount), lerp(p0[1], p1[1], amount)];
}
function quadRoots(a, b, c) {
if (a === 0)
return [];
var s = b * b - 4 * a * c;
if (s < 0)
return [];
var singleRoot = -b / (2 * a);
if (s === 0)
return [singleRoot];
var delta = Math.sqrt(s) / (2 * a);
return [singleRoot - delta, singleRoot + delta];
}
function polynomialCoefficients(p0, p1, p2, p3) {
return [-p0 + 3 * p1 - 3 * p2 + p3, 3 * p0 - 6 * p1 + 3 * p2, -3 * p0 + 3 * p1, p0];
}
function singlePoint(p) {
return new PolynomialBezier(p, p, p, p, false);
}
function PolynomialBezier(p0, p1, p2, p3, linearize) {
if (linearize && pointEqual(p0, p1)) {
p1 = lerpPoint(p0, p3, 1 / 3);
}
if (linearize && pointEqual(p2, p3)) {
p2 = lerpPoint(p0, p3, 2 / 3);
}
var coeffx = polynomialCoefficients(p0[0], p1[0], p2[0], p3[0]);
var coeffy = polynomialCoefficients(p0[1], p1[1], p2[1], p3[1]);
this.a = [coeffx[0], coeffy[0]];
this.b = [coeffx[1], coeffy[1]];
this.c = [coeffx[2], coeffy[2]];
this.d = [coeffx[3], coeffy[3]];
this.points = [p0, p1, p2, p3];
}
PolynomialBezier.prototype.point = function(t) {
return [((this.a[0] * t + this.b[0]) * t + this.c[0]) * t + this.d[0], ((this.a[1] * t + this.b[1]) * t + this.c[1]) * t + this.d[1]];
};
PolynomialBezier.prototype.derivative = function(t) {
return [(3 * t * this.a[0] + 2 * this.b[0]) * t + this.c[0], (3 * t * this.a[1] + 2 * this.b[1]) * t + this.c[1]];
};
PolynomialBezier.prototype.tangentAngle = function(t) {
var p = this.derivative(t);
return Math.atan2(p[1], p[0]);
};
PolynomialBezier.prototype.normalAngle = function(t) {
var p = this.derivative(t);
return Math.atan2(p[0], p[1]);
};
PolynomialBezier.prototype.inflectionPoints = function() {
var denom = this.a[1] * this.b[0] - this.a[0] * this.b[1];
if (floatZero(denom))
return [];
var tcusp = -0.5 * (this.a[1] * this.c[0] - this.a[0] * this.c[1]) / denom;
var square = tcusp * tcusp - 1 / 3 * (this.b[1] * this.c[0] - this.b[0] * this.c[1]) / denom;
if (square < 0)
return [];
var root = Math.sqrt(square);
if (floatZero(root)) {
if (root > 0 && root < 1)
return [tcusp];
return [];
}
return [tcusp - root, tcusp + root].filter(function(r) {
return r > 0 && r < 1;
});
};
PolynomialBezier.prototype.split = function(t) {
if (t <= 0)
return [singlePoint(this.points[0]), this];
if (t >= 1)
return [this, singlePoint(this.points[this.points.length - 1])];
var p10 = lerpPoint(this.points[0], this.points[1], t);
var p11 = lerpPoint(this.points[1], this.points[2], t);
var p12 = lerpPoint(this.points[2], this.points[3], t);
var p20 = lerpPoint(p10, p11, t);
var p21 = lerpPoint(p11, p12, t);
var p3 = lerpPoint(p20, p21, t);
return [new PolynomialBezier(this.points[0], p10, p20, p3, true), new PolynomialBezier(p3, p21, p12, this.points[3], true)];
};
function extrema(bez2, comp2) {
var min = bez2.points[0][comp2];
var max = bez2.points[bez2.points.length - 1][comp2];
if (min > max) {
var e = max;
max = min;
min = e;
}
var f = quadRoots(3 * bez2.a[comp2], 2 * bez2.b[comp2], bez2.c[comp2]);
for (var i = 0; i < f.length; i += 1) {
if (f[i] > 0 && f[i] < 1) {
var val2 = bez2.point(f[i])[comp2];
if (val2 < min)
min = val2;
else if (val2 > max)
max = val2;
}
}
return {
min,
max
};
}
PolynomialBezier.prototype.bounds = function() {
return {
x: extrema(this, 0),
y: extrema(this, 1)
};
};
PolynomialBezier.prototype.boundingBox = function() {
var bounds = this.bounds();
return {
left: bounds.x.min,
right: bounds.x.max,
top: bounds.y.min,
bottom: bounds.y.max,
width: bounds.x.max - bounds.x.min,
height: bounds.y.max - bounds.y.min,
cx: (bounds.x.max + bounds.x.min) / 2,
cy: (bounds.y.max + bounds.y.min) / 2
};
};
function intersectData(bez2, t1, t2) {
var box = bez2.boundingBox();
return {
cx: box.cx,
cy: box.cy,
width: box.width,
height: box.height,
bez: bez2,
t: (t1 + t2) / 2,
t1,
t2
};
}
function splitData(data2) {
var split2 = data2.bez.split(0.5);
return [intersectData(split2[0], data2.t1, data2.t), intersectData(split2[1], data2.t, data2.t2)];
}
function boxIntersect(b1, b2) {
return Math.abs(b1.cx - b2.cx) * 2 < b1.width + b2.width && Math.abs(b1.cy - b2.cy) * 2 < b1.height + b2.height;
}
function intersectsImpl(d1, d2, depth, tolerance, intersections, maxRecursion) {
if (!boxIntersect(d1, d2))
return;
if (depth >= maxRecursion || d1.width <= tolerance && d1.height <= tolerance && d2.width <= tolerance && d2.height <= tolerance) {
intersections.push([d1.t, d2.t]);
return;
}
var d1s = splitData(d1);
var d2s = splitData(d2);
intersectsImpl(d1s[0], d2s[0], depth + 1, tolerance, intersections, maxRecursion);
intersectsImpl(d1s[0], d2s[1], depth + 1, tolerance, intersections, maxRecursion);
intersectsImpl(d1s[1], d2s[0], depth + 1, tolerance, intersections, maxRecursion);
intersectsImpl(d1s[1], d2s[1], depth + 1, tolerance, intersections, maxRecursion);
}
PolynomialBezier.prototype.intersections = function(other, tolerance, maxRecursion) {
if (tolerance === void 0)
tolerance = 2;
if (maxRecursion === void 0)
maxRecursion = 7;
var intersections = [];
intersectsImpl(intersectData(this, 0, 1), intersectData(other, 0, 1), 0, tolerance, intersections, maxRecursion);
return intersections;
};
PolynomialBezier.shapeSegment = function(shapePath, index2) {
var nextIndex = (index2 + 1) % shapePath.length();
return new PolynomialBezier(shapePath.v[index2], shapePath.o[index2], shapePath.i[nextIndex], shapePath.v[nextIndex], true);
};
PolynomialBezier.shapeSegmentInverted = function(shapePath, index2) {
var nextIndex = (index2 + 1) % shapePath.length();
return new PolynomialBezier(shapePath.v[nextIndex], shapePath.i[nextIndex], shapePath.o[index2], shapePath.v[index2], true);
};
function crossProduct(a, b) {
return [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]];
}
function lineIntersection(start1, end1, start2, end2) {
var v1 = [start1[0], start1[1], 1];
var v2 = [end1[0], end1[1], 1];
var v3 = [start2[0], start2[1], 1];
var v42 = [end2[0], end2[1], 1];
var r = crossProduct(crossProduct(v1, v2), crossProduct(v3, v42));
if (floatZero(r[2]))
return null;
return [r[0] / r[2], r[1] / r[2]];
}
function polarOffset(p, angle, length2) {
return [p[0] + Math.cos(angle) * length2, p[1] - Math.sin(angle) * length2];
}
function pointDistance(p1, p2) {
return Math.hypot(p1[0] - p2[0], p1[1] - p2[1]);
}
function pointEqual(p1, p2) {
return floatEqual(p1[0], p2[0]) && floatEqual(p1[1], p2[1]);
}
function ZigZagModifier() {
}
extendPrototype([ShapeModifier], ZigZagModifier);
ZigZagModifier.prototype.initModifierProperties = function(elem2, data2) {
this.getValue = this.processKeys;
this.amplitude = PropertyFactory.getProp(elem2, data2.s, 0, null, this);
this.frequency = PropertyFactory.getProp(elem2, data2.r, 0, null, this);
this.pointsType = PropertyFactory.getProp(elem2, data2.pt, 0, null, this);
this._isAnimated = this.amplitude.effectsSequence.length !== 0 || this.frequency.effectsSequence.length !== 0 || this.pointsType.effectsSequence.length !== 0;
};
function setPoint(outputBezier, point, angle, direction, amplitude, outAmplitude, inAmplitude) {
var angO = angle - Math.PI / 2;
var angI = angle + Math.PI / 2;
var px = point[0] + Math.cos(angle) * direction * amplitude;
var py = point[1] - Math.sin(angle) * direction * amplitude;
outputBezier.setTripleAt(px, py, px + Math.cos(angO) * outAmplitude, py - Math.sin(angO) * outAmplitude, px + Math.cos(angI) * inAmplitude, py - Math.sin(angI) * inAmplitude, outputBezier.length());
}
function getPerpendicularVector(pt1, pt2) {
var vector = [pt2[0] - pt1[0], pt2[1] - pt1[1]];
var rot = -Math.PI * 0.5;
var rotatedVector = [Math.cos(rot) * vector[0] - Math.sin(rot) * vector[1], Math.sin(rot) * vector[0] + Math.cos(rot) * vector[1]];
return rotatedVector;
}
function getProjectingAngle(path, cur) {
var prevIndex = cur === 0 ? path.length() - 1 : cur - 1;
var nextIndex = (cur + 1) % path.length();
var prevPoint = path.v[prevIndex];
var nextPoint = path.v[nextIndex];
var pVector = getPerpendicularVector(prevPoint, nextPoint);
return Math.atan2(0, 1) - Math.atan2(pVector[1], pVector[0]);
}
function zigZagCorner(outputBezier, path, cur, amplitude, frequency, pointType, direction) {
var angle = getProjectingAngle(path, cur);
var point = path.v[cur % path._length];
var prevPoint = path.v[cur === 0 ? path._length - 1 : cur - 1];
var nextPoint = path.v[(cur + 1) % path._length];
var prevDist = pointType === 2 ? Math.sqrt(Math.pow(point[0] - prevPoint[0], 2) + Math.pow(point[1] - prevPoint[1], 2)) : 0;
var nextDist = pointType === 2 ? Math.sqrt(Math.pow(point[0] - nextPoint[0], 2) + Math.pow(point[1] - nextPoint[1], 2)) : 0;
setPoint(outputBezier, path.v[cur % path._length], angle, direction, amplitude, nextDist / ((frequency + 1) * 2), prevDist / ((frequency + 1) * 2), pointType);
}
function zigZagSegment(outputBezier, segment, amplitude, frequency, pointType, direction) {
for (var i = 0; i < frequency; i += 1) {
var t = (i + 1) / (frequency + 1);
var dist = pointType === 2 ? Math.sqrt(Math.pow(segment.points[3][0] - segment.points[0][0], 2) + Math.pow(segment.points[3][1] - segment.points[0][1], 2)) : 0;
var angle = segment.normalAngle(t);
var point = segment.point(t);
setPoint(outputBezier, point, angle, direction, amplitude, dist / ((frequency + 1) * 2), dist / ((frequency + 1) * 2), pointType);
direction = -direction;
}
return direction;
}
ZigZagModifier.prototype.processPath = function(path, amplitude, frequency, pointType) {
var count = path._length;
var clonedPath = shapePool.newElement();
clonedPath.c = path.c;
if (!path.c) {
count -= 1;
}
if (count === 0)
return clonedPath;
var direction = -1;
var segment = PolynomialBezier.shapeSegment(path, 0);
zigZagCorner(clonedPath, path, 0, amplitude, frequency, pointType, direction);
for (var i = 0; i < count; i += 1) {
direction = zigZagSegment(clonedPath, segment, amplitude, frequency, pointType, -direction);
if (i === count - 1 && !path.c) {
segment = null;
} else {
segment = PolynomialBezier.shapeSegment(path, (i + 1) % count);
}
zigZagCorner(clonedPath, path, i + 1, amplitude, frequency, pointType, direction);
}
return clonedPath;
};
ZigZagModifier.prototype.processShapes = function(_isFirstFrame) {
var shapePaths;
var i;
var len = this.shapes.length;
var j;
var jLen;
var amplitude = this.amplitude.v;
var frequency = Math.max(0, Math.round(this.frequency.v));
var pointType = this.pointsType.v;
if (amplitude !== 0) {
var shapeData;
var localShapeCollection;
for (i = 0; i < len; i += 1) {
shapeData = this.shapes[i];
localShapeCollection = shapeData.localShapeCollection;
if (!(!shapeData.shape._mdf && !this._mdf && !_isFirstFrame)) {
localShapeCollection.releaseShapes();
shapeData.shape._mdf = true;
shapePaths = shapeData.shape.paths.shapes;
jLen = shapeData.shape.paths._length;
for (j = 0; j < jLen; j += 1) {
localShapeCollection.addShape(this.processPath(shapePaths[j], amplitude, frequency, pointType));
}
}
shapeData.shape.paths = shapeData.localShapeCollection;
}
}
if (!this.dynamicProperties.length) {
this._mdf = false;
}
};
function linearOffset(p1, p2, amount) {
var angle = Math.atan2(p2[0] - p1[0], p2[1] - p1[1]);
return [polarOffset(p1, angle, amount), polarOffset(p2, angle, amount)];
}
function offsetSegment(segment, amount) {
var p0;
var p1a;
var p1b;
var p2b;
var p2a;
var p3;
var e;
e = linearOffset(segment.points[0], segment.points[1], amount);
p0 = e[0];
p1a = e[1];
e = linearOffset(segment.points[1], segment.points[2], amount);
p1b = e[0];
p2b = e[1];
e = linearOffset(segment.points[2], segment.points[3], amount);
p2a = e[0];
p3 = e[1];
var p1 = lineIntersection(p0, p1a, p1b, p2b);
if (p1 === null)
p1 = p1a;
var p2 = lineIntersection(p2a, p3, p1b, p2b);
if (p2 === null)
p2 = p2a;
return new PolynomialBezier(p0, p1, p2, p3);
}
function joinLines(outputBezier, seg1, seg2, lineJoin, miterLimit) {
var p0 = seg1.points[3];
var p1 = seg2.points[0];
if (lineJoin === 3)
return p0;
if (pointEqual(p0, p1))
return p0;
if (lineJoin === 2) {
var angleOut = -seg1.tangentAngle(1);
var angleIn = -seg2.tangentAngle(0) + Math.PI;
var center = lineIntersection(p0, polarOffset(p0, angleOut + Math.PI / 2, 100), p1, polarOffset(p1, angleOut + Math.PI / 2, 100));
var radius = center ? pointDistance(center, p0) : pointDistance(p0, p1) / 2;
var tan = polarOffset(p0, angleOut, 2 * radius * roundCorner);
outputBezier.setXYAt(tan[0], tan[1], "o", outputBezier.length() - 1);
tan = polarOffset(p1, angleIn, 2 * radius * roundCorner);
outputBezier.setTripleAt(p1[0], p1[1], p1[0], p1[1], tan[0], tan[1], outputBezier.length());
return p1;
}
var t0 = pointEqual(p0, seg1.points[2]) ? seg1.points[0] : seg1.points[2];
var t1 = pointEqual(p1, seg2.points[1]) ? seg2.points[3] : seg2.points[1];
var intersection = lineIntersection(t0, p0, p1, t1);
if (intersection && pointDistance(intersection, p0) < miterLimit) {
outputBezier.setTripleAt(intersection[0], intersection[1], intersection[0], intersection[1], intersection[0], intersection[1], outputBezier.length());
return intersection;
}
return p0;
}
function getIntersection(a, b) {
var intersect = a.intersections(b);
if (intersect.length && floatEqual(intersect[0][0], 1))
intersect.shift();
if (intersect.length)
return intersect[0];
return null;
}
function pruneSegmentIntersection(a, b) {
var outa = a.slice();
var outb = b.slice();
var intersect = getIntersection(a[a.length - 1], b[0]);
if (intersect) {
outa[a.length - 1] = a[a.length - 1].split(intersect[0])[0];
outb[0] = b[0].split(intersect[1])[1];
}
if (a.length > 1 && b.length > 1) {
intersect = getIntersection(a[0], b[b.length - 1]);
if (intersect) {
return [[a[0].split(intersect[0])[0]], [b[b.length - 1].split(intersect[1])[1]]];
}
}
return [outa, outb];
}
function pruneIntersections(segments) {
var e;
for (var i = 1; i < segments.length; i += 1) {
e = pruneSegmentIntersection(segments[i - 1], segments[i]);
segments[i - 1] = e[0];
segments[i] = e[1];
}
if (segments.length > 1) {
e = pruneSegmentIntersection(segments[segments.length - 1], segments[0]);
segments[segments.length - 1] = e[0];
segments[0] = e[1];
}
return segments;
}
function offsetSegmentSplit(segment, amount) {
var flex = segment.inflectionPoints();
var left;
var right;
var split2;
var mid;
if (flex.length === 0) {
return [offsetSegment(segment, amount)];
}
if (flex.length === 1 || floatEqual(flex[1], 1)) {
split2 = segment.split(flex[0]);
left = split2[0];
right = split2[1];
return [offsetSegment(left, amount), offsetSegment(right, amount)];
}
split2 = segment.split(flex[0]);
left = split2[0];
var t = (flex[1] - flex[0]) / (1 - flex[0]);
split2 = split2[1].split(t);
mid = split2[0];
right = split2[1];
return [offsetSegment(left, amount), offsetSegment(mid, amount), offsetSegment(right, amount)];
}
function OffsetPathModifier() {
}
extendPrototype([ShapeModifier], OffsetPathModifier);
OffsetPathModifier.prototype.initModifierProperties = function(elem2, data2) {
this.getValue = this.processKeys;
this.amount = PropertyFactory.getProp(elem2, data2.a, 0, null, this);
this.miterLimit = PropertyFactory.getProp(elem2, data2.ml, 0, null, this);
this.lineJoin = data2.lj;
this._isAnimated = this.amount.effectsSequence.length !== 0;
};
OffsetPathModifier.prototype.processPath = function(inputBezier, amount, lineJoin, miterLimit) {
var outputBezier = shapePool.newElement();
outputBezier.c = inputBezier.c;
var count = inputBezier.length();
if (!inputBezier.c) {
count -= 1;
}
var i;
var j;
var segment;
var multiSegments = [];
for (i = 0; i < count; i += 1) {
segment = PolynomialBezier.shapeSegment(inputBezier, i);
multiSegments.push(offsetSegmentSplit(segment, amount));
}
if (!inputBezier.c) {
for (i = count - 1; i >= 0; i -= 1) {
segment = PolynomialBezier.shapeSegmentInverted(inputBezier, i);
multiSegments.push(offsetSegmentSplit(segment, amount));
}
}
multiSegments = pruneIntersections(multiSegments);
var lastPoint = null;
var lastSeg = null;
for (i = 0; i < multiSegments.length; i += 1) {
var multiSegment = multiSegments[i];
if (lastSeg)
lastPoint = joinLines(outputBezier, lastSeg, multiSegment[0], lineJoin, miterLimit);
lastSeg = multiSegment[multiSegment.length - 1];
for (j = 0; j < multiSegment.length; j += 1) {
segment = multiSegment[j];
if (lastPoint && pointEqual(segment.points[0], lastPoint)) {
outputBezier.setXYAt(segment.points[1][0], segment.points[1][1], "o", outputBezier.length() - 1);
} else {
outputBezier.setTripleAt(segment.points[0][0], segment.points[0][1], segment.points[1][0], segment.points[1][1], segment.points[0][0], segment.points[0][1], outputBezier.length());
}
outputBezier.setTripleAt(segment.points[3][0], segment.points[3][1], segment.points[3][0], segment.points[3][1], segment.points[2][0], segment.points[2][1], outputBezier.length());
lastPoint = segment.points[3];
}
}
if (multiSegments.length)
joinLines(outputBezier, lastSeg, multiSegments[0][0], lineJoin, miterLimit);
return outputBezier;
};
OffsetPathModifier.prototype.processShapes = function(_isFirstFrame) {
var shapePaths;
var i;
var len = this.shapes.length;
var j;
var jLen;
var amount = this.amount.v;
var miterLimit = this.miterLimit.v;
var lineJoin = this.lineJoin;
if (amount !== 0) {
var shapeData;
var localShapeCollection;
for (i = 0; i < len; i += 1) {
shapeData = this.shapes[i];
localShapeCollection = shapeData.localShapeCollection;
if (!(!shapeData.shape._mdf && !this._mdf && !_isFirstFrame)) {
localShapeCollection.releaseShapes();
shapeData.shape._mdf = true;
shapePaths = shapeData.shape.paths.shapes;
jLen = shapeData.shape.paths._length;
for (j = 0; j < jLen; j += 1) {
localShapeCollection.addShape(this.processPath(shapePaths[j], amount, lineJoin, miterLimit));
}
}
shapeData.shape.paths = shapeData.localShapeCollection;
}
}
if (!this.dynamicProperties.length) {
this._mdf = false;
}
};
function getFontProperties(fontData) {
var styles = fontData.fStyle ? fontData.fStyle.split(" ") : [];
var fWeight = "normal";
var fStyle = "normal";
var len = styles.length;
var styleName;
for (var i = 0; i < len; i += 1) {
styleName = styles[i].toLowerCase();
switch (styleName) {
case "italic":
fStyle = "italic";
break;
case "bold":
fWeight = "700";
break;
case "black":
fWeight = "900";
break;
case "medium":
fWeight = "500";
break;
case "regular":
case "normal":
fWeight = "400";
break;
case "light":
case "thin":
fWeight = "200";
break;
default:
break;
}
}
return {
style: fStyle,
weight: fontData.fWeight || fWeight
};
}
var FontManager = function() {
var maxWaitingTime = 5e3;
var emptyChar = {
w: 0,
size: 0,
shapes: [],
data: {
shapes: []
}
};
var combinedCharacters = [];
combinedCharacters = combinedCharacters.concat([2304, 2305, 2306, 2307, 2362, 2363, 2364, 2364, 2366, 2367, 2368, 2369, 2370, 2371, 2372, 2373, 2374, 2375, 2376, 2377, 2378, 2379, 2380, 2381, 2382, 2383, 2387, 2388, 2389, 2390, 2391, 2402, 2403]);
var BLACK_FLAG_CODE_POINT = 127988;
var CANCEL_TAG_CODE_POINT = 917631;
var A_TAG_CODE_POINT = 917601;
var Z_TAG_CODE_POINT = 917626;
var VARIATION_SELECTOR_16_CODE_POINT = 65039;
var ZERO_WIDTH_JOINER_CODE_POINT = 8205;
var REGIONAL_CHARACTER_A_CODE_POINT = 127462;
var REGIONAL_CHARACTER_Z_CODE_POINT = 127487;
var surrogateModifiers = ["d83cdffb", "d83cdffc", "d83cdffd", "d83cdffe", "d83cdfff"];
function trimFontOptions(font) {
var familyArray = font.split(",");
var i;
var len = familyArray.length;
var enabledFamilies = [];
for (i = 0; i < len; i += 1) {
if (familyArray[i] !== "sans-serif" && familyArray[i] !== "monospace") {
enabledFamilies.push(familyArray[i]);
}
}
return enabledFamilies.join(",");
}
function setUpNode(font, family) {
var parentNode = createTag("span");
parentNode.setAttribute("aria-hidden", true);
parentNode.style.fontFamily = family;
var node = createTag("span");
node.innerText = "giItT1WQy@!-/#";
parentNode.style.position = "absolute";
parentNode.style.left = "-10000px";
parentNode.style.top = "-10000px";
parentNode.style.fontSize = "300px";
parentNode.style.fontVariant = "normal";
parentNode.style.fontStyle = "normal";
parentNode.style.fontWeight = "normal";
parentNode.style.letterSpacing = "0";
parentNode.appendChild(node);
document.body.appendChild(parentNode);
var width2 = node.offsetWidth;
node.style.fontFamily = trimFontOptions(font) + ", " + family;
return {
node,
w: width2,
parent: parentNode
};
}
function checkLoadedFonts() {
var i;
var len = this.fonts.length;
var node;
var w;
var loadedCount = len;
for (i = 0; i < len; i += 1) {
if (this.fonts[i].loaded) {
loadedCount -= 1;
} else if (this.fonts[i].fOrigin === "n" || this.fonts[i].origin === 0) {
this.fonts[i].loaded = true;
} else {
node = this.fonts[i].monoCase.node;
w = this.fonts[i].monoCase.w;
if (node.offsetWidth !== w) {
loadedCount -= 1;
this.fonts[i].loaded = true;
} else {
node = this.fonts[i].sansCase.node;
w = this.fonts[i].sansCase.w;
if (node.offsetWidth !== w) {
loadedCount -= 1;
this.fonts[i].loaded = true;
}
}
if (this.fonts[i].loaded) {
this.fonts[i].sansCase.parent.parentNode.removeChild(this.fonts[i].sansCase.parent);
this.fonts[i].monoCase.parent.parentNode.removeChild(this.fonts[i].monoCase.parent);
}
}
}
if (loadedCount !== 0 && Date.now() - this.initTime < maxWaitingTime) {
setTimeout(this.checkLoadedFontsBinded, 20);
} else {
setTimeout(this.setIsLoadedBinded, 10);
}
}
function createHelper(fontData, def) {
var engine = document.body && def ? "svg" : "canvas";
var helper;
var fontProps = getFontProperties(fontData);
if (engine === "svg") {
var tHelper = createNS("text");
tHelper.style.fontSize = "100px";
tHelper.setAttribute("font-family", fontData.fFamily);
tHelper.setAttribute("font-style", fontProps.style);
tHelper.setAttribute("font-weight", fontProps.weight);
tHelper.textContent = "1";
if (fontData.fClass) {
tHelper.style.fontFamily = "inherit";
tHelper.setAttribute("class", fontData.fClass);
} else {
tHelper.style.fontFamily = fontData.fFamily;
}
def.appendChild(tHelper);
helper = tHelper;
} else {
var tCanvasHelper = new OffscreenCanvas(500, 500).getContext("2d");
tCanvasHelper.font = fontProps.style + " " + fontProps.weight + " 100px " + fontData.fFamily;
helper = tCanvasHelper;
}
function measure(text2) {
if (engine === "svg") {
helper.textContent = text2;
return helper.getComputedTextLength();
}
return helper.measureText(text2).width;
}
return {
measureText: measure
};
}
function addFonts(fontData, defs) {
if (!fontData) {
this.isLoaded = true;
return;
}
if (this.chars) {
this.isLoaded = true;
this.fonts = fontData.list;
return;
}
if (!document.body) {
this.isLoaded = true;
fontData.list.forEach(function(data2) {
data2.helper = createHelper(data2);
data2.cache = {};
});
this.fonts = fontData.list;
return;
}
var fontArr = fontData.list;
var i;
var len = fontArr.length;
var _pendingFonts = len;
for (i = 0; i < len; i += 1) {
var shouldLoadFont = true;
var loadedSelector;
var j;
fontArr[i].loaded = false;
fontArr[i].monoCase = setUpNode(fontArr[i].fFamily, "monospace");
fontArr[i].sansCase = setUpNode(fontArr[i].fFamily, "sans-serif");
if (!fontArr[i].fPath) {
fontArr[i].loaded = true;
_pendingFonts -= 1;
} else if (fontArr[i].fOrigin === "p" || fontArr[i].origin === 3) {
loadedSelector = document.querySelectorAll('style[f-forigin="p"][f-family="' + fontArr[i].fFamily + '"], style[f-origin="3"][f-family="' + fontArr[i].fFamily + '"]');
if (loadedSelector.length > 0) {
shouldLoadFont = false;
}
if (shouldLoadFont) {
var s = createTag("style");
s.setAttribute("f-forigin", fontArr[i].fOrigin);
s.setAttribute("f-origin", fontArr[i].origin);
s.setAttribute("f-family", fontArr[i].fFamily);
s.type = "text/css";
s.innerText = "@font-face {font-family: " + fontArr[i].fFamily + "; font-style: normal; src: url('" + fontArr[i].fPath + "');}";
defs.appendChild(s);
}
} else if (fontArr[i].fOrigin === "g" || fontArr[i].origin === 1) {
loadedSelector = document.querySelectorAll('link[f-forigin="g"], link[f-origin="1"]');
for (j = 0; j < loadedSelector.length; j += 1) {
if (loadedSelector[j].href.indexOf(fontArr[i].fPath) !== -1) {
shouldLoadFont = false;
}
}
if (shouldLoadFont) {
var l = createTag("link");
l.setAttribute("f-forigin", fontArr[i].fOrigin);
l.setAttribute("f-origin", fontArr[i].origin);
l.type = "text/css";
l.rel = "stylesheet";
l.href = fontArr[i].fPath;
document.body.appendChild(l);
}
} else if (fontArr[i].fOrigin === "t" || fontArr[i].origin === 2) {
loadedSelector = document.querySelectorAll('script[f-forigin="t"], script[f-origin="2"]');
for (j = 0; j < loadedSelector.length; j += 1) {
if (fontArr[i].fPath === loadedSelector[j].src) {
shouldLoadFont = false;
}
}
if (shouldLoadFont) {
var sc = createTag("link");
sc.setAttribute("f-forigin", fontArr[i].fOrigin);
sc.setAttribute("f-origin", fontArr[i].origin);
sc.setAttribute("rel", "stylesheet");
sc.setAttribute("href", fontArr[i].fPath);
defs.appendChild(sc);
}
}
fontArr[i].helper = createHelper(fontArr[i], defs);
fontArr[i].cache = {};
this.fonts.push(fontArr[i]);
}
if (_pendingFonts === 0) {
this.isLoaded = true;
} else {
setTimeout(this.checkLoadedFonts.bind(this), 100);
}
}
function addChars(chars) {
if (!chars) {
return;
}
if (!this.chars) {
this.chars = [];
}
var i;
var len = chars.length;
var j;
var jLen = this.chars.length;
var found;
for (i = 0; i < len; i += 1) {
j = 0;
found = false;
while (j < jLen) {
if (this.chars[j].style === chars[i].style && this.chars[j].fFamily === chars[i].fFamily && this.chars[j].ch === chars[i].ch) {
found = true;
}
j += 1;
}
if (!found) {
this.chars.push(chars[i]);
jLen += 1;
}
}
}
function getCharData(_char, style, font) {
var i = 0;
var len = this.chars.length;
while (i < len) {
if (this.chars[i].ch === _char && this.chars[i].style === style && this.chars[i].fFamily === font) {
return this.chars[i];
}
i += 1;
}
if ((typeof _char === "string" && _char.charCodeAt(0) !== 13 || !_char) && console && console.warn && !this._warned) {
this._warned = true;
console.warn("Missing character from exported characters list: ", _char, style, font);
}
return emptyChar;
}
function measureText(_char2, fontName, size) {
var fontData = this.getFontByName(fontName);
var index2 = _char2;
if (!fontData.cache[index2]) {
var tHelper = fontData.helper;
if (_char2 === " ") {
var doubleSize = tHelper.measureText("|" + _char2 + "|");
var singleSize = tHelper.measureText("||");
fontData.cache[index2] = (doubleSize - singleSize) / 100;
} else {
fontData.cache[index2] = tHelper.measureText(_char2) / 100;
}
}
return fontData.cache[index2] * size;
}
function getFontByName(name2) {
var i = 0;
var len = this.fonts.length;
while (i < len) {
if (this.fonts[i].fName === name2) {
return this.fonts[i];
}
i += 1;
}
return this.fonts[0];
}
function getCodePoint(string) {
var codePoint = 0;
var first2 = string.charCodeAt(0);
if (first2 >= 55296 && first2 <= 56319) {
var second = string.charCodeAt(1);
if (second >= 56320 && second <= 57343) {
codePoint = (first2 - 55296) * 1024 + second - 56320 + 65536;
}
}
return codePoint;
}
function isModifier(firstCharCode, secondCharCode) {
var sum2 = firstCharCode.toString(16) + secondCharCode.toString(16);
return surrogateModifiers.indexOf(sum2) !== -1;
}
function isZeroWidthJoiner(charCode) {
return charCode === ZERO_WIDTH_JOINER_CODE_POINT;
}
function isVariationSelector(charCode) {
return charCode === VARIATION_SELECTOR_16_CODE_POINT;
}
function isRegionalCode(string) {
var codePoint = getCodePoint(string);
if (codePoint >= REGIONAL_CHARACTER_A_CODE_POINT && codePoint <= REGIONAL_CHARACTER_Z_CODE_POINT) {
return true;
}
return false;
}
function isFlagEmoji(string) {
return isRegionalCode(string.substr(0, 2)) && isRegionalCode(string.substr(2, 2));
}
function isCombinedCharacter(_char3) {
return combinedCharacters.indexOf(_char3) !== -1;
}
function isRegionalFlag(text2, index2) {
var codePoint = getCodePoint(text2.substr(index2, 2));
if (codePoint !== BLACK_FLAG_CODE_POINT) {
return false;
}
var count = 0;
index2 += 2;
while (count < 5) {
codePoint = getCodePoint(text2.substr(index2, 2));
if (codePoint < A_TAG_CODE_POINT || codePoint > Z_TAG_CODE_POINT) {
return false;
}
count += 1;
index2 += 2;
}
return getCodePoint(text2.substr(index2, 2)) === CANCEL_TAG_CODE_POINT;
}
function setIsLoaded() {
this.isLoaded = true;
}
var Font = function Font2() {
this.fonts = [];
this.chars = null;
this.typekitLoaded = 0;
this.isLoaded = false;
this._warned = false;
this.initTime = Date.now();
this.setIsLoadedBinded = this.setIsLoaded.bind(this);
this.checkLoadedFontsBinded = this.checkLoadedFonts.bind(this);
};
Font.isModifier = isModifier;
Font.isZeroWidthJoiner = isZeroWidthJoiner;
Font.isFlagEmoji = isFlagEmoji;
Font.isRegionalCode = isRegionalCode;
Font.isCombinedCharacter = isCombinedCharacter;
Font.isRegionalFlag = isRegionalFlag;
Font.isVariationSelector = isVariationSelector;
Font.BLACK_FLAG_CODE_POINT = BLACK_FLAG_CODE_POINT;
var fontPrototype = {
addChars,
addFonts,
getCharData,
getFontByName,
measureText,
checkLoadedFonts,
setIsLoaded
};
Font.prototype = fontPrototype;
return Font;
}();
function SlotManager(animationData2) {
this.animationData = animationData2;
}
SlotManager.prototype.getProp = function(data2) {
if (this.animationData.slots && this.animationData.slots[data2.sid]) {
return Object.assign(data2, this.animationData.slots[data2.sid].p);
}
return data2;
};
function slotFactory(animationData2) {
return new SlotManager(animationData2);
}
function RenderableElement() {
}
RenderableElement.prototype = {
initRenderable: function initRenderable() {
this.isInRange = false;
this.hidden = false;
this.isTransparent = false;
this.renderableComponents = [];
},
addRenderableComponent: function addRenderableComponent(component) {
if (this.renderableComponents.indexOf(component) === -1) {
this.renderableComponents.push(component);
}
},
removeRenderableComponent: function removeRenderableComponent(component) {
if (this.renderableComponents.indexOf(component) !== -1) {
this.renderableComponents.splice(this.renderableComponents.indexOf(component), 1);
}
},
prepareRenderableFrame: function prepareRenderableFrame(num) {
this.checkLayerLimits(num);
},
checkTransparency: function checkTransparency() {
if (this.finalTransform.mProp.o.v <= 0) {
if (!this.isTransparent && this.globalData.renderConfig.hideOnTransparent) {
this.isTransparent = true;
this.hide();
}
} else if (this.isTransparent) {
this.isTransparent = false;
this.show();
}
},
/**
* @function
* Initializes frame related properties.
*
* @param {number} num
* current frame number in Layer's time
*
*/
checkLayerLimits: function checkLayerLimits(num) {
if (this.data.ip - this.data.st <= num && this.data.op - this.data.st > num) {
if (this.isInRange !== true) {
this.globalData._mdf = true;
this._mdf = true;
this.isInRange = true;
this.show();
}
} else if (this.isInRange !== false) {
this.globalData._mdf = true;
this.isInRange = false;
this.hide();
}
},
renderRenderable: function renderRenderable() {
var i;
var len = this.renderableComponents.length;
for (i = 0; i < len; i += 1) {
this.renderableComponents[i].renderFrame(this._isFirstFrame);
}
},
sourceRectAtTime: function sourceRectAtTime2() {
return {
top: 0,
left: 0,
width: 100,
height: 100
};
},
getLayerSize: function getLayerSize() {
if (this.data.ty === 5) {
return {
w: this.data.textData.width,
h: this.data.textData.height
};
}
return {
w: this.data.width,
h: this.data.height
};
}
};
var getBlendMode = /* @__PURE__ */ function() {
var blendModeEnums = {
0: "source-over",
1: "multiply",
2: "screen",
3: "overlay",
4: "darken",
5: "lighten",
6: "color-dodge",
7: "color-burn",
8: "hard-light",
9: "soft-light",
10: "difference",
11: "exclusion",
12: "hue",
13: "saturation",
14: "color",
15: "luminosity"
};
return function(mode) {
return blendModeEnums[mode] || "";
};
}();
function SliderEffect(data2, elem2, container) {
this.p = PropertyFactory.getProp(elem2, data2.v, 0, 0, container);
}
function AngleEffect(data2, elem2, container) {
this.p = PropertyFactory.getProp(elem2, data2.v, 0, 0, container);
}
function ColorEffect(data2, elem2, container) {
this.p = PropertyFactory.getProp(elem2, data2.v, 1, 0, container);
}
function PointEffect(data2, elem2, container) {
this.p = PropertyFactory.getProp(elem2, data2.v, 1, 0, container);
}
function LayerIndexEffect(data2, elem2, container) {
this.p = PropertyFactory.getProp(elem2, data2.v, 0, 0, container);
}
function MaskIndexEffect(data2, elem2, container) {
this.p = PropertyFactory.getProp(elem2, data2.v, 0, 0, container);
}
function CheckboxEffect(data2, elem2, container) {
this.p = PropertyFactory.getProp(elem2, data2.v, 0, 0, container);
}
function NoValueEffect() {
this.p = {};
}
function EffectsManager(data2, element) {
var effects = data2.ef || [];
this.effectElements = [];
var i;
var len = effects.length;
var effectItem;
for (i = 0; i < len; i += 1) {
effectItem = new GroupEffect(effects[i], element);
this.effectElements.push(effectItem);
}
}
function GroupEffect(data2, element) {
this.init(data2, element);
}
extendPrototype([DynamicPropertyContainer], GroupEffect);
GroupEffect.prototype.getValue = GroupEffect.prototype.iterateDynamicProperties;
GroupEffect.prototype.init = function(data2, element) {
this.data = data2;
this.effectElements = [];
this.initDynamicPropertyContainer(element);
var i;
var len = this.data.ef.length;
var eff;
var effects = this.data.ef;
for (i = 0; i < len; i += 1) {
eff = null;
switch (effects[i].ty) {
case 0:
eff = new SliderEffect(effects[i], element, this);
break;
case 1:
eff = new AngleEffect(effects[i], element, this);
break;
case 2:
eff = new ColorEffect(effects[i], element, this);
break;
case 3:
eff = new PointEffect(effects[i], element, this);
break;
case 4:
case 7:
eff = new CheckboxEffect(effects[i], element, this);
break;
case 10:
eff = new LayerIndexEffect(effects[i], element, this);
break;
case 11:
eff = new MaskIndexEffect(effects[i], element, this);
break;
case 5:
eff = new EffectsManager(effects[i], element, this);
break;
default:
eff = new NoValueEffect(effects[i], element, this);
break;
}
if (eff) {
this.effectElements.push(eff);
}
}
};
function BaseElement() {
}
BaseElement.prototype = {
checkMasks: function checkMasks() {
if (!this.data.hasMask) {
return false;
}
var i = 0;
var len = this.data.masksProperties.length;
while (i < len) {
if (this.data.masksProperties[i].mode !== "n" && this.data.masksProperties[i].cl !== false) {
return true;
}
i += 1;
}
return false;
},
initExpressions: function initExpressions() {
var expressionsInterfaces2 = getExpressionInterfaces();
if (!expressionsInterfaces2) {
return;
}
var LayerExpressionInterface2 = expressionsInterfaces2("layer");
var EffectsExpressionInterface2 = expressionsInterfaces2("effects");
var ShapeExpressionInterface2 = expressionsInterfaces2("shape");
var TextExpressionInterface2 = expressionsInterfaces2("text");
var CompExpressionInterface2 = expressionsInterfaces2("comp");
this.layerInterface = LayerExpressionInterface2(this);
if (this.data.hasMask && this.maskManager) {
this.layerInterface.registerMaskInterface(this.maskManager);
}
var effectsInterface = EffectsExpressionInterface2.createEffectsInterface(this, this.layerInterface);
this.layerInterface.registerEffectsInterface(effectsInterface);
if (this.data.ty === 0 || this.data.xt) {
this.compInterface = CompExpressionInterface2(this);
} else if (this.data.ty === 4) {
this.layerInterface.shapeInterface = ShapeExpressionInterface2(this.shapesData, this.itemsData, this.layerInterface);
this.layerInterface.content = this.layerInterface.shapeInterface;
} else if (this.data.ty === 5) {
this.layerInterface.textInterface = TextExpressionInterface2(this);
this.layerInterface.text = this.layerInterface.textInterface;
}
},
setBlendMode: function setBlendMode() {
var blendModeValue = getBlendMode(this.data.bm);
var elem2 = this.baseElement || this.layerElement;
elem2.style["mix-blend-mode"] = blendModeValue;
},
initBaseData: function initBaseData(data2, globalData2, comp2) {
this.globalData = globalData2;
this.comp = comp2;
this.data = data2;
this.layerId = createElementID();
if (!this.data.sr) {
this.data.sr = 1;
}
this.effectsManager = new EffectsManager(this.data, this, this.dynamicProperties);
},
getType: function getType() {
return this.type;
},
sourceRectAtTime: function sourceRectAtTime2() {
}
};
function FrameElement() {
}
FrameElement.prototype = {
/**
* @function
* Initializes frame related properties.
*
*/
initFrame: function initFrame2() {
this._isFirstFrame = false;
this.dynamicProperties = [];
this._mdf = false;
},
/**
* @function
* Calculates all dynamic values
*
* @param {number} num
* current frame number in Layer's time
* @param {boolean} isVisible
* if layers is currently in range
*
*/
prepareProperties: function prepareProperties(num, isVisible) {
var i;
var len = this.dynamicProperties.length;
for (i = 0; i < len; i += 1) {
if (isVisible || this._isParent && this.dynamicProperties[i].propType === "transform") {
this.dynamicProperties[i].getValue();
if (this.dynamicProperties[i]._mdf) {
this.globalData._mdf = true;
this._mdf = true;
}
}
}
},
addDynamicProperty: function addDynamicProperty(prop) {
if (this.dynamicProperties.indexOf(prop) === -1) {
this.dynamicProperties.push(prop);
}
}
};
function FootageElement(data2, globalData2, comp2) {
this.initFrame();
this.initRenderable();
this.assetData = globalData2.getAssetData(data2.refId);
this.footageData = globalData2.imageLoader.getAsset(this.assetData);
this.initBaseData(data2, globalData2, comp2);
}
FootageElement.prototype.prepareFrame = function() {
};
extendPrototype([RenderableElement, BaseElement, FrameElement], FootageElement);
FootageElement.prototype.getBaseElement = function() {
return null;
};
FootageElement.prototype.renderFrame = function() {
};
FootageElement.prototype.destroy = function() {
};
FootageElement.prototype.initExpressions = function() {
var expressionsInterfaces2 = getExpressionInterfaces();
if (!expressionsInterfaces2) {
return;
}
var FootageInterface2 = expressionsInterfaces2("footage");
this.layerInterface = FootageInterface2(this);
};
FootageElement.prototype.getFootageData = function() {
return this.footageData;
};
function AudioElement(data2, globalData2, comp2) {
this.initFrame();
this.initRenderable();
this.assetData = globalData2.getAssetData(data2.refId);
this.initBaseData(data2, globalData2, comp2);
this._isPlaying = false;
this._canPlay = false;
var assetPath = this.globalData.getAssetsPath(this.assetData);
this.audio = this.globalData.audioController.createAudio(assetPath);
this._currentTime = 0;
this.globalData.audioController.addAudio(this);
this._volumeMultiplier = 1;
this._volume = 1;
this._previousVolume = null;
this.tm = data2.tm ? PropertyFactory.getProp(this, data2.tm, 0, globalData2.frameRate, this) : {
_placeholder: true
};
this.lv = PropertyFactory.getProp(this, data2.au && data2.au.lv ? data2.au.lv : {
k: [100]
}, 1, 0.01, this);
}
AudioElement.prototype.prepareFrame = function(num) {
this.prepareRenderableFrame(num, true);
this.prepareProperties(num, true);
if (!this.tm._placeholder) {
var timeRemapped = this.tm.v;
this._currentTime = timeRemapped;
} else {
this._currentTime = num / this.data.sr;
}
this._volume = this.lv.v[0];
var totalVolume = this._volume * this._volumeMultiplier;
if (this._previousVolume !== totalVolume) {
this._previousVolume = totalVolume;
this.audio.volume(totalVolume);
}
};
extendPrototype([RenderableElement, BaseElement, FrameElement], AudioElement);
AudioElement.prototype.renderFrame = function() {
if (this.isInRange && this._canPlay) {
if (!this._isPlaying) {
this.audio.play();
this.audio.seek(this._currentTime / this.globalData.frameRate);
this._isPlaying = true;
} else if (!this.audio.playing() || Math.abs(this._currentTime / this.globalData.frameRate - this.audio.seek()) > 0.1) {
this.audio.seek(this._currentTime / this.globalData.frameRate);
}
}
};
AudioElement.prototype.show = function() {
};
AudioElement.prototype.hide = function() {
this.audio.pause();
this._isPlaying = false;
};
AudioElement.prototype.pause = function() {
this.audio.pause();
this._isPlaying = false;
this._canPlay = false;
};
AudioElement.prototype.resume = function() {
this._canPlay = true;
};
AudioElement.prototype.setRate = function(rateValue) {
this.audio.rate(rateValue);
};
AudioElement.prototype.volume = function(volumeValue) {
this._volumeMultiplier = volumeValue;
this._previousVolume = volumeValue * this._volume;
this.audio.volume(this._previousVolume);
};
AudioElement.prototype.getBaseElement = function() {
return null;
};
AudioElement.prototype.destroy = function() {
};
AudioElement.prototype.sourceRectAtTime = function() {
};
AudioElement.prototype.initExpressions = function() {
};
function BaseRenderer() {
}
BaseRenderer.prototype.checkLayers = function(num) {
var i;
var len = this.layers.length;
var data2;
this.completeLayers = true;
for (i = len - 1; i >= 0; i -= 1) {
if (!this.elements[i]) {
data2 = this.layers[i];
if (data2.ip - data2.st <= num - this.layers[i].st && data2.op - data2.st > num - this.layers[i].st) {
this.buildItem(i);
}
}
this.completeLayers = this.elements[i] ? this.completeLayers : false;
}
this.checkPendingElements();
};
BaseRenderer.prototype.createItem = function(layer) {
switch (layer.ty) {
case 2:
return this.createImage(layer);
case 0:
return this.createComp(layer);
case 1:
return this.createSolid(layer);
case 3:
return this.createNull(layer);
case 4:
return this.createShape(layer);
case 5:
return this.createText(layer);
case 6:
return this.createAudio(layer);
case 13:
return this.createCamera(layer);
case 15:
return this.createFootage(layer);
default:
return this.createNull(layer);
}
};
BaseRenderer.prototype.createCamera = function() {
throw new Error("You're using a 3d camera. Try the html renderer.");
};
BaseRenderer.prototype.createAudio = function(data2) {
return new AudioElement(data2, this.globalData, this);
};
BaseRenderer.prototype.createFootage = function(data2) {
return new FootageElement(data2, this.globalData, this);
};
BaseRenderer.prototype.buildAllItems = function() {
var i;
var len = this.layers.length;
for (i = 0; i < len; i += 1) {
this.buildItem(i);
}
this.checkPendingElements();
};
BaseRenderer.prototype.includeLayers = function(newLayers) {
this.completeLayers = false;
var i;
var len = newLayers.length;
var j;
var jLen = this.layers.length;
for (i = 0; i < len; i += 1) {
j = 0;
while (j < jLen) {
if (this.layers[j].id === newLayers[i].id) {
this.layers[j] = newLayers[i];
break;
}
j += 1;
}
}
};
BaseRenderer.prototype.setProjectInterface = function(pInterface) {
this.globalData.projectInterface = pInterface;
};
BaseRenderer.prototype.initItems = function() {
if (!this.globalData.progressiveLoad) {
this.buildAllItems();
}
};
BaseRenderer.prototype.buildElementParenting = function(element, parentName, hierarchy) {
var elements = this.elements;
var layers = this.layers;
var i = 0;
var len = layers.length;
while (i < len) {
if (layers[i].ind == parentName) {
if (!elements[i] || elements[i] === true) {
this.buildItem(i);
this.addPendingElement(element);
} else {
hierarchy.push(elements[i]);
elements[i].setAsParent();
if (layers[i].parent !== void 0) {
this.buildElementParenting(element, layers[i].parent, hierarchy);
} else {
element.setHierarchy(hierarchy);
}
}
}
i += 1;
}
};
BaseRenderer.prototype.addPendingElement = function(element) {
this.pendingElements.push(element);
};
BaseRenderer.prototype.searchExtraCompositions = function(assets) {
var i;
var len = assets.length;
for (i = 0; i < len; i += 1) {
if (assets[i].xt) {
var comp2 = this.createComp(assets[i]);
comp2.initExpressions();
this.globalData.projectInterface.registerComposition(comp2);
}
}
};
BaseRenderer.prototype.getElementById = function(ind) {
var i;
var len = this.elements.length;
for (i = 0; i < len; i += 1) {
if (this.elements[i].data.ind === ind) {
return this.elements[i];
}
}
return null;
};
BaseRenderer.prototype.getElementByPath = function(path) {
var pathValue = path.shift();
var element;
if (typeof pathValue === "number") {
element = this.elements[pathValue];
} else {
var i;
var len = this.elements.length;
for (i = 0; i < len; i += 1) {
if (this.elements[i].data.nm === pathValue) {
element = this.elements[i];
break;
}
}
}
if (path.length === 0) {
return element;
}
return element.getElementByPath(path);
};
BaseRenderer.prototype.setupGlobalData = function(animData, fontsContainer) {
this.globalData.fontManager = new FontManager();
this.globalData.slotManager = slotFactory(animData);
this.globalData.fontManager.addChars(animData.chars);
this.globalData.fontManager.addFonts(animData.fonts, fontsContainer);
this.globalData.getAssetData = this.animationItem.getAssetData.bind(this.animationItem);
this.globalData.getAssetsPath = this.animationItem.getAssetsPath.bind(this.animationItem);
this.globalData.imageLoader = this.animationItem.imagePreloader;
this.globalData.audioController = this.animationItem.audioController;
this.globalData.frameId = 0;
this.globalData.frameRate = animData.fr;
this.globalData.nm = animData.nm;
this.globalData.compSize = {
w: animData.w,
h: animData.h
};
};
var effectTypes = {
TRANSFORM_EFFECT: "transformEFfect"
};
function TransformElement() {
}
TransformElement.prototype = {
initTransform: function initTransform() {
var mat = new Matrix();
this.finalTransform = {
mProp: this.data.ks ? TransformPropertyFactory.getTransformProperty(this, this.data.ks, this) : {
o: 0
},
_matMdf: false,
_localMatMdf: false,
_opMdf: false,
mat,
localMat: mat,
localOpacity: 1
};
if (this.data.ao) {
this.finalTransform.mProp.autoOriented = true;
}
if (this.data.ty !== 11) {
}
},
renderTransform: function renderTransform() {
this.finalTransform._opMdf = this.finalTransform.mProp.o._mdf || this._isFirstFrame;
this.finalTransform._matMdf = this.finalTransform.mProp._mdf || this._isFirstFrame;
if (this.hierarchy) {
var mat;
var finalMat = this.finalTransform.mat;
var i = 0;
var len = this.hierarchy.length;
if (!this.finalTransform._matMdf) {
while (i < len) {
if (this.hierarchy[i].finalTransform.mProp._mdf) {
this.finalTransform._matMdf = true;
break;
}
i += 1;
}
}
if (this.finalTransform._matMdf) {
mat = this.finalTransform.mProp.v.props;
finalMat.cloneFromProps(mat);
for (i = 0; i < len; i += 1) {
finalMat.multiply(this.hierarchy[i].finalTransform.mProp.v);
}
}
}
if (this.finalTransform._matMdf) {
this.finalTransform._localMatMdf = this.finalTransform._matMdf;
}
if (this.finalTransform._opMdf) {
this.finalTransform.localOpacity = this.finalTransform.mProp.o.v;
}
},
renderLocalTransform: function renderLocalTransform() {
if (this.localTransforms) {
var i = 0;
var len = this.localTransforms.length;
this.finalTransform._localMatMdf = this.finalTransform._matMdf;
if (!this.finalTransform._localMatMdf || !this.finalTransform._opMdf) {
while (i < len) {
if (this.localTransforms[i]._mdf) {
this.finalTransform._localMatMdf = true;
}
if (this.localTransforms[i]._opMdf && !this.finalTransform._opMdf) {
this.finalTransform.localOpacity = this.finalTransform.mProp.o.v;
this.finalTransform._opMdf = true;
}
i += 1;
}
}
if (this.finalTransform._localMatMdf) {
var localMat = this.finalTransform.localMat;
this.localTransforms[0].matrix.clone(localMat);
for (i = 1; i < len; i += 1) {
var lmat = this.localTransforms[i].matrix;
localMat.multiply(lmat);
}
localMat.multiply(this.finalTransform.mat);
}
if (this.finalTransform._opMdf) {
var localOp = this.finalTransform.localOpacity;
for (i = 0; i < len; i += 1) {
localOp *= this.localTransforms[i].opacity * 0.01;
}
this.finalTransform.localOpacity = localOp;
}
}
},
searchEffectTransforms: function searchEffectTransforms() {
if (this.renderableEffectsManager) {
var transformEffects = this.renderableEffectsManager.getEffects(effectTypes.TRANSFORM_EFFECT);
if (transformEffects.length) {
this.localTransforms = [];
this.finalTransform.localMat = new Matrix();
var i = 0;
var len = transformEffects.length;
for (i = 0; i < len; i += 1) {
this.localTransforms.push(transformEffects[i]);
}
}
}
},
globalToLocal: function globalToLocal(pt) {
var transforms = [];
transforms.push(this.finalTransform);
var flag = true;
var comp2 = this.comp;
while (flag) {
if (comp2.finalTransform) {
if (comp2.data.hasMask) {
transforms.splice(0, 0, comp2.finalTransform);
}
comp2 = comp2.comp;
} else {
flag = false;
}
}
var i;
var len = transforms.length;
var ptNew;
for (i = 0; i < len; i += 1) {
ptNew = transforms[i].mat.applyToPointArray(0, 0, 0);
pt = [pt[0] - ptNew[0], pt[1] - ptNew[1], 0];
}
return pt;
},
mHelper: new Matrix()
};
function MaskElement(data2, element, globalData2) {
this.data = data2;
this.element = element;
this.globalData = globalData2;
this.storedData = [];
this.masksProperties = this.data.masksProperties || [];
this.maskElement = null;
var defs = this.globalData.defs;
var i;
var len = this.masksProperties ? this.masksProperties.length : 0;
this.viewData = createSizedArray(len);
this.solidPath = "";
var path;
var properties = this.masksProperties;
var count = 0;
var currentMasks = [];
var j;
var jLen;
var layerId = createElementID();
var rect;
var expansor;
var feMorph;
var x;
var maskType = "clipPath";
var maskRef = "clip-path";
for (i = 0; i < len; i += 1) {
if (properties[i].mode !== "a" && properties[i].mode !== "n" || properties[i].inv || properties[i].o.k !== 100 || properties[i].o.x) {
maskType = "mask";
maskRef = "mask";
}
if ((properties[i].mode === "s" || properties[i].mode === "i") && count === 0) {
rect = createNS("rect");
rect.setAttribute("fill", "#ffffff");
rect.setAttribute("width", this.element.comp.data.w || 0);
rect.setAttribute("height", this.element.comp.data.h || 0);
currentMasks.push(rect);
} else {
rect = null;
}
path = createNS("path");
if (properties[i].mode === "n") {
this.viewData[i] = {
op: PropertyFactory.getProp(this.element, properties[i].o, 0, 0.01, this.element),
prop: ShapePropertyFactory.getShapeProp(this.element, properties[i], 3),
elem: path,
lastPath: ""
};
defs.appendChild(path);
} else {
count += 1;
path.setAttribute("fill", properties[i].mode === "s" ? "#000000" : "#ffffff");
path.setAttribute("clip-rule", "nonzero");
var filterID;
if (properties[i].x.k !== 0) {
maskType = "mask";
maskRef = "mask";
x = PropertyFactory.getProp(this.element, properties[i].x, 0, null, this.element);
filterID = createElementID();
expansor = createNS("filter");
expansor.setAttribute("id", filterID);
feMorph = createNS("feMorphology");
feMorph.setAttribute("operator", "erode");
feMorph.setAttribute("in", "SourceGraphic");
feMorph.setAttribute("radius", "0");
expansor.appendChild(feMorph);
defs.appendChild(expansor);
path.setAttribute("stroke", properties[i].mode === "s" ? "#000000" : "#ffffff");
} else {
feMorph = null;
x = null;
}
this.storedData[i] = {
elem: path,
x,
expan: feMorph,
lastPath: "",
lastOperator: "",
filterId: filterID,
lastRadius: 0
};
if (properties[i].mode === "i") {
jLen = currentMasks.length;
var g = createNS("g");
for (j = 0; j < jLen; j += 1) {
g.appendChild(currentMasks[j]);
}
var mask2 = createNS("mask");
mask2.setAttribute("mask-type", "alpha");
mask2.setAttribute("id", layerId + "_" + count);
mask2.appendChild(path);
defs.appendChild(mask2);
g.setAttribute("mask", "url(" + getLocationHref() + "#" + layerId + "_" + count + ")");
currentMasks.length = 0;
currentMasks.push(g);
} else {
currentMasks.push(path);
}
if (properties[i].inv && !this.solidPath) {
this.solidPath = this.createLayerSolidPath();
}
this.viewData[i] = {
elem: path,
lastPath: "",
op: PropertyFactory.getProp(this.element, properties[i].o, 0, 0.01, this.element),
prop: ShapePropertyFactory.getShapeProp(this.element, properties[i], 3),
invRect: rect
};
if (!this.viewData[i].prop.k) {
this.drawPath(properties[i], this.viewData[i].prop.v, this.viewData[i]);
}
}
}
this.maskElement = createNS(maskType);
len = currentMasks.length;
for (i = 0; i < len; i += 1) {
this.maskElement.appendChild(currentMasks[i]);
}
if (count > 0) {
this.maskElement.setAttribute("id", layerId);
this.element.maskedElement.setAttribute(maskRef, "url(" + getLocationHref() + "#" + layerId + ")");
defs.appendChild(this.maskElement);
}
if (this.viewData.length) {
this.element.addRenderableComponent(this);
}
}
MaskElement.prototype.getMaskProperty = function(pos) {
return this.viewData[pos].prop;
};
MaskElement.prototype.renderFrame = function(isFirstFrame) {
var finalMat = this.element.finalTransform.mat;
var i;
var len = this.masksProperties.length;
for (i = 0; i < len; i += 1) {
if (this.viewData[i].prop._mdf || isFirstFrame) {
this.drawPath(this.masksProperties[i], this.viewData[i].prop.v, this.viewData[i]);
}
if (this.viewData[i].op._mdf || isFirstFrame) {
this.viewData[i].elem.setAttribute("fill-opacity", this.viewData[i].op.v);
}
if (this.masksProperties[i].mode !== "n") {
if (this.viewData[i].invRect && (this.element.finalTransform.mProp._mdf || isFirstFrame)) {
this.viewData[i].invRect.setAttribute("transform", finalMat.getInverseMatrix().to2dCSS());
}
if (this.storedData[i].x && (this.storedData[i].x._mdf || isFirstFrame)) {
var feMorph = this.storedData[i].expan;
if (this.storedData[i].x.v < 0) {
if (this.storedData[i].lastOperator !== "erode") {
this.storedData[i].lastOperator = "erode";
this.storedData[i].elem.setAttribute("filter", "url(" + getLocationHref() + "#" + this.storedData[i].filterId + ")");
}
feMorph.setAttribute("radius", -this.storedData[i].x.v);
} else {
if (this.storedData[i].lastOperator !== "dilate") {
this.storedData[i].lastOperator = "dilate";
this.storedData[i].elem.setAttribute("filter", null);
}
this.storedData[i].elem.setAttribute("stroke-width", this.storedData[i].x.v * 2);
}
}
}
}
};
MaskElement.prototype.getMaskelement = function() {
return this.maskElement;
};
MaskElement.prototype.createLayerSolidPath = function() {
var path = "M0,0 ";
path += " h" + this.globalData.compSize.w;
path += " v" + this.globalData.compSize.h;
path += " h-" + this.globalData.compSize.w;
path += " v-" + this.globalData.compSize.h + " ";
return path;
};
MaskElement.prototype.drawPath = function(pathData, pathNodes, viewData) {
var pathString = " M" + pathNodes.v[0][0] + "," + pathNodes.v[0][1];
var i;
var len;
len = pathNodes._length;
for (i = 1; i < len; i += 1) {
pathString += " C" + pathNodes.o[i - 1][0] + "," + pathNodes.o[i - 1][1] + " " + pathNodes.i[i][0] + "," + pathNodes.i[i][1] + " " + pathNodes.v[i][0] + "," + pathNodes.v[i][1];
}
if (pathNodes.c && len > 1) {
pathString += " C" + pathNodes.o[i - 1][0] + "," + pathNodes.o[i - 1][1] + " " + pathNodes.i[0][0] + "," + pathNodes.i[0][1] + " " + pathNodes.v[0][0] + "," + pathNodes.v[0][1];
}
if (viewData.lastPath !== pathString) {
var pathShapeValue = "";
if (viewData.elem) {
if (pathNodes.c) {
pathShapeValue = pathData.inv ? this.solidPath + pathString : pathString;
}
viewData.elem.setAttribute("d", pathShapeValue);
}
viewData.lastPath = pathString;
}
};
MaskElement.prototype.destroy = function() {
this.element = null;
this.globalData = null;
this.maskElement = null;
this.data = null;
this.masksProperties = null;
};
var filtersFactory = function() {
var ob2 = {};
ob2.createFilter = createFilter;
ob2.createAlphaToLuminanceFilter = createAlphaToLuminanceFilter;
function createFilter(filId, skipCoordinates) {
var fil = createNS("filter");
fil.setAttribute("id", filId);
if (skipCoordinates !== true) {
fil.setAttribute("filterUnits", "objectBoundingBox");
fil.setAttribute("x", "0%");
fil.setAttribute("y", "0%");
fil.setAttribute("width", "100%");
fil.setAttribute("height", "100%");
}
return fil;
}
function createAlphaToLuminanceFilter() {
var feColorMatrix = createNS("feColorMatrix");
feColorMatrix.setAttribute("type", "matrix");
feColorMatrix.setAttribute("color-interpolation-filters", "sRGB");
feColorMatrix.setAttribute("values", "0 0 0 1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1 1");
return feColorMatrix;
}
return ob2;
}();
var featureSupport = function() {
var ob2 = {
maskType: true,
svgLumaHidden: true,
offscreenCanvas: typeof OffscreenCanvas !== "undefined"
};
if (/MSIE 10/i.test(navigator.userAgent) || /MSIE 9/i.test(navigator.userAgent) || /rv:11.0/i.test(navigator.userAgent) || /Edge\/\d./i.test(navigator.userAgent)) {
ob2.maskType = false;
}
if (/firefox/i.test(navigator.userAgent)) {
ob2.svgLumaHidden = false;
}
return ob2;
}();
var registeredEffects$1 = {};
var idPrefix = "filter_result_";
function SVGEffects(elem2) {
var i;
var source = "SourceGraphic";
var len = elem2.data.ef ? elem2.data.ef.length : 0;
var filId = createElementID();
var fil = filtersFactory.createFilter(filId, true);
var count = 0;
this.filters = [];
var filterManager;
for (i = 0; i < len; i += 1) {
filterManager = null;
var type = elem2.data.ef[i].ty;
if (registeredEffects$1[type]) {
var Effect = registeredEffects$1[type].effect;
filterManager = new Effect(fil, elem2.effectsManager.effectElements[i], elem2, idPrefix + count, source);
source = idPrefix + count;
if (registeredEffects$1[type].countsAsEffect) {
count += 1;
}
}
if (filterManager) {
this.filters.push(filterManager);
}
}
if (count) {
elem2.globalData.defs.appendChild(fil);
elem2.layerElement.setAttribute("filter", "url(" + getLocationHref() + "#" + filId + ")");
}
if (this.filters.length) {
elem2.addRenderableComponent(this);
}
}
SVGEffects.prototype.renderFrame = function(_isFirstFrame) {
var i;
var len = this.filters.length;
for (i = 0; i < len; i += 1) {
this.filters[i].renderFrame(_isFirstFrame);
}
};
SVGEffects.prototype.getEffects = function(type) {
var i;
var len = this.filters.length;
var effects = [];
for (i = 0; i < len; i += 1) {
if (this.filters[i].type === type) {
effects.push(this.filters[i]);
}
}
return effects;
};
function registerEffect$1(id, effect3, countsAsEffect) {
registeredEffects$1[id] = {
effect: effect3,
countsAsEffect
};
}
function SVGBaseElement() {
}
SVGBaseElement.prototype = {
initRendererElement: function initRendererElement() {
this.layerElement = createNS("g");
},
createContainerElements: function createContainerElements() {
this.matteElement = createNS("g");
this.transformedElement = this.layerElement;
this.maskedElement = this.layerElement;
this._sizeChanged = false;
var layerElementParent = null;
if (this.data.td) {
this.matteMasks = {};
var gg = createNS("g");
gg.setAttribute("id", this.layerId);
gg.appendChild(this.layerElement);
layerElementParent = gg;
this.globalData.defs.appendChild(gg);
} else if (this.data.tt) {
this.matteElement.appendChild(this.layerElement);
layerElementParent = this.matteElement;
this.baseElement = this.matteElement;
} else {
this.baseElement = this.layerElement;
}
if (this.data.ln) {
this.layerElement.setAttribute("id", this.data.ln);
}
if (this.data.cl) {
this.layerElement.setAttribute("class", this.data.cl);
}
if (this.data.ty === 0 && !this.data.hd) {
var cp = createNS("clipPath");
var pt = createNS("path");
pt.setAttribute("d", "M0,0 L" + this.data.w + ",0 L" + this.data.w + "," + this.data.h + " L0," + this.data.h + "z");
var clipId = createElementID();
cp.setAttribute("id", clipId);
cp.appendChild(pt);
this.globalData.defs.appendChild(cp);
if (this.checkMasks()) {
var cpGroup = createNS("g");
cpGroup.setAttribute("clip-path", "url(" + getLocationHref() + "#" + clipId + ")");
cpGroup.appendChild(this.layerElement);
this.transformedElement = cpGroup;
if (layerElementParent) {
layerElementParent.appendChild(this.transformedElement);
} else {
this.baseElement = this.transformedElement;
}
} else {
this.layerElement.setAttribute("clip-path", "url(" + getLocationHref() + "#" + clipId + ")");
}
}
if (this.data.bm !== 0) {
this.setBlendMode();
}
},
renderElement: function renderElement() {
if (this.finalTransform._localMatMdf) {
this.transformedElement.setAttribute("transform", this.finalTransform.localMat.to2dCSS());
}
if (this.finalTransform._opMdf) {
this.transformedElement.setAttribute("opacity", this.finalTransform.localOpacity);
}
},
destroyBaseElement: function destroyBaseElement() {
this.layerElement = null;
this.matteElement = null;
this.maskManager.destroy();
},
getBaseElement: function getBaseElement() {
if (this.data.hd) {
return null;
}
return this.baseElement;
},
createRenderableComponents: function createRenderableComponents() {
this.maskManager = new MaskElement(this.data, this, this.globalData);
this.renderableEffectsManager = new SVGEffects(this);
this.searchEffectTransforms();
},
getMatte: function getMatte(matteType) {
if (!this.matteMasks) {
this.matteMasks = {};
}
if (!this.matteMasks[matteType]) {
var id = this.layerId + "_" + matteType;
var filId;
var fil;
var useElement;
var gg;
if (matteType === 1 || matteType === 3) {
var masker = createNS("mask");
masker.setAttribute("id", id);
masker.setAttribute("mask-type", matteType === 3 ? "luminance" : "alpha");
useElement = createNS("use");
useElement.setAttributeNS("http://www.w3.org/1999/xlink", "href", "#" + this.layerId);
masker.appendChild(useElement);
this.globalData.defs.appendChild(masker);
if (!featureSupport.maskType && matteType === 1) {
masker.setAttribute("mask-type", "luminance");
filId = createElementID();
fil = filtersFactory.createFilter(filId);
this.globalData.defs.appendChild(fil);
fil.appendChild(filtersFactory.createAlphaToLuminanceFilter());
gg = createNS("g");
gg.appendChild(useElement);
masker.appendChild(gg);
gg.setAttribute("filter", "url(" + getLocationHref() + "#" + filId + ")");
}
} else if (matteType === 2) {
var maskGroup = createNS("mask");
maskGroup.setAttribute("id", id);
maskGroup.setAttribute("mask-type", "alpha");
var maskGrouper = createNS("g");
maskGroup.appendChild(maskGrouper);
filId = createElementID();
fil = filtersFactory.createFilter(filId);
var feCTr = createNS("feComponentTransfer");
feCTr.setAttribute("in", "SourceGraphic");
fil.appendChild(feCTr);
var feFunc = createNS("feFuncA");
feFunc.setAttribute("type", "table");
feFunc.setAttribute("tableValues", "1.0 0.0");
feCTr.appendChild(feFunc);
this.globalData.defs.appendChild(fil);
var alphaRect = createNS("rect");
alphaRect.setAttribute("width", this.comp.data.w);
alphaRect.setAttribute("height", this.comp.data.h);
alphaRect.setAttribute("x", "0");
alphaRect.setAttribute("y", "0");
alphaRect.setAttribute("fill", "#ffffff");
alphaRect.setAttribute("opacity", "0");
maskGrouper.setAttribute("filter", "url(" + getLocationHref() + "#" + filId + ")");
maskGrouper.appendChild(alphaRect);
useElement = createNS("use");
useElement.setAttributeNS("http://www.w3.org/1999/xlink", "href", "#" + this.layerId);
maskGrouper.appendChild(useElement);
if (!featureSupport.maskType) {
maskGroup.setAttribute("mask-type", "luminance");
fil.appendChild(filtersFactory.createAlphaToLuminanceFilter());
gg = createNS("g");
maskGrouper.appendChild(alphaRect);
gg.appendChild(this.layerElement);
maskGrouper.appendChild(gg);
}
this.globalData.defs.appendChild(maskGroup);
}
this.matteMasks[matteType] = id;
}
return this.matteMasks[matteType];
},
setMatte: function setMatte(id) {
if (!this.matteElement) {
return;
}
this.matteElement.setAttribute("mask", "url(" + getLocationHref() + "#" + id + ")");
}
};
function HierarchyElement() {
}
HierarchyElement.prototype = {
/**
* @function
* Initializes hierarchy properties
*
*/
initHierarchy: function initHierarchy() {
this.hierarchy = [];
this._isParent = false;
this.checkParenting();
},
/**
* @function
* Sets layer's hierarchy.
* @param {array} hierarch
* layer's parent list
*
*/
setHierarchy: function setHierarchy(hierarchy) {
this.hierarchy = hierarchy;
},
/**
* @function
* Sets layer as parent.
*
*/
setAsParent: function setAsParent() {
this._isParent = true;
},
/**
* @function
* Searches layer's parenting chain
*
*/
checkParenting: function checkParenting() {
if (this.data.parent !== void 0) {
this.comp.buildElementParenting(this, this.data.parent, []);
}
}
};
function RenderableDOMElement() {
}
(function() {
var _prototype = {
initElement: function initElement(data2, globalData2, comp2) {
this.initFrame();
this.initBaseData(data2, globalData2, comp2);
this.initTransform(data2, globalData2, comp2);
this.initHierarchy();
this.initRenderable();
this.initRendererElement();
this.createContainerElements();
this.createRenderableComponents();
this.createContent();
this.hide();
},
hide: function hide() {
if (!this.hidden && (!this.isInRange || this.isTransparent)) {
var elem2 = this.baseElement || this.layerElement;
elem2.style.display = "none";
this.hidden = true;
}
},
show: function show() {
if (this.isInRange && !this.isTransparent) {
if (!this.data.hd) {
var elem2 = this.baseElement || this.layerElement;
elem2.style.display = "block";
}
this.hidden = false;
this._isFirstFrame = true;
}
},
renderFrame: function renderFrame() {
if (this.data.hd || this.hidden) {
return;
}
this.renderTransform();
this.renderRenderable();
this.renderLocalTransform();
this.renderElement();
this.renderInnerContent();
if (this._isFirstFrame) {
this._isFirstFrame = false;
}
},
renderInnerContent: function renderInnerContent() {
},
prepareFrame: function prepareFrame(num) {
this._mdf = false;
this.prepareRenderableFrame(num);
this.prepareProperties(num, this.isInRange);
this.checkTransparency();
},
destroy: function destroy() {
this.innerElem = null;
this.destroyBaseElement();
}
};
extendPrototype([RenderableElement, createProxyFunction(_prototype)], RenderableDOMElement);
})();
function IImageElement(data2, globalData2, comp2) {
this.assetData = globalData2.getAssetData(data2.refId);
if (this.assetData && this.assetData.sid) {
this.assetData = globalData2.slotManager.getProp(this.assetData);
}
this.initElement(data2, globalData2, comp2);
this.sourceRect = {
top: 0,
left: 0,
width: this.assetData.w,
height: this.assetData.h
};
}
extendPrototype([BaseElement, TransformElement, SVGBaseElement, HierarchyElement, FrameElement, RenderableDOMElement], IImageElement);
IImageElement.prototype.createContent = function() {
var assetPath = this.globalData.getAssetsPath(this.assetData);
this.innerElem = createNS("image");
this.innerElem.setAttribute("width", this.assetData.w + "px");
this.innerElem.setAttribute("height", this.assetData.h + "px");
this.innerElem.setAttribute("preserveAspectRatio", this.assetData.pr || this.globalData.renderConfig.imagePreserveAspectRatio);
this.innerElem.setAttributeNS("http://www.w3.org/1999/xlink", "href", assetPath);
this.layerElement.appendChild(this.innerElem);
};
IImageElement.prototype.sourceRectAtTime = function() {
return this.sourceRect;
};
function ProcessedElement(element, position2) {
this.elem = element;
this.pos = position2;
}
function IShapeElement() {
}
IShapeElement.prototype = {
addShapeToModifiers: function addShapeToModifiers(data2) {
var i;
var len = this.shapeModifiers.length;
for (i = 0; i < len; i += 1) {
this.shapeModifiers[i].addShape(data2);
}
},
isShapeInAnimatedModifiers: function isShapeInAnimatedModifiers(data2) {
var i = 0;
var len = this.shapeModifiers.length;
while (i < len) {
if (this.shapeModifiers[i].isAnimatedWithShape(data2)) {
return true;
}
}
return false;
},
renderModifiers: function renderModifiers() {
if (!this.shapeModifiers.length) {
return;
}
var i;
var len = this.shapes.length;
for (i = 0; i < len; i += 1) {
this.shapes[i].sh.reset();
}
len = this.shapeModifiers.length;
var shouldBreakProcess;
for (i = len - 1; i >= 0; i -= 1) {
shouldBreakProcess = this.shapeModifiers[i].processShapes(this._isFirstFrame);
if (shouldBreakProcess) {
break;
}
}
},
searchProcessedElement: function searchProcessedElement(elem2) {
var elements = this.processedElements;
var i = 0;
var len = elements.length;
while (i < len) {
if (elements[i].elem === elem2) {
return elements[i].pos;
}
i += 1;
}
return 0;
},
addProcessedElement: function addProcessedElement(elem2, pos) {
var elements = this.processedElements;
var i = elements.length;
while (i) {
i -= 1;
if (elements[i].elem === elem2) {
elements[i].pos = pos;
return;
}
}
elements.push(new ProcessedElement(elem2, pos));
},
prepareFrame: function prepareFrame(num) {
this.prepareRenderableFrame(num);
this.prepareProperties(num, this.isInRange);
}
};
var lineCapEnum = {
1: "butt",
2: "round",
3: "square"
};
var lineJoinEnum = {
1: "miter",
2: "round",
3: "bevel"
};
function SVGShapeData(transformers, level, shape) {
this.caches = [];
this.styles = [];
this.transformers = transformers;
this.lStr = "";
this.sh = shape;
this.lvl = level;
this._isAnimated = !!shape.k;
var i = 0;
var len = transformers.length;
while (i < len) {
if (transformers[i].mProps.dynamicProperties.length) {
this._isAnimated = true;
break;
}
i += 1;
}
}
SVGShapeData.prototype.setAsAnimated = function() {
this._isAnimated = true;
};
function SVGStyleData(data2, level) {
this.data = data2;
this.type = data2.ty;
this.d = "";
this.lvl = level;
this._mdf = false;
this.closed = data2.hd === true;
this.pElem = createNS("path");
this.msElem = null;
}
SVGStyleData.prototype.reset = function() {
this.d = "";
this._mdf = false;
};
function DashProperty(elem2, data2, renderer2, container) {
this.elem = elem2;
this.frameId = -1;
this.dataProps = createSizedArray(data2.length);
this.renderer = renderer2;
this.k = false;
this.dashStr = "";
this.dashArray = createTypedArray("float32", data2.length ? data2.length - 1 : 0);
this.dashoffset = createTypedArray("float32", 1);
this.initDynamicPropertyContainer(container);
var i;
var len = data2.length || 0;
var prop;
for (i = 0; i < len; i += 1) {
prop = PropertyFactory.getProp(elem2, data2[i].v, 0, 0, this);
this.k = prop.k || this.k;
this.dataProps[i] = {
n: data2[i].n,
p: prop
};
}
if (!this.k) {
this.getValue(true);
}
this._isAnimated = this.k;
}
DashProperty.prototype.getValue = function(forceRender) {
if (this.elem.globalData.frameId === this.frameId && !forceRender) {
return;
}
this.frameId = this.elem.globalData.frameId;
this.iterateDynamicProperties();
this._mdf = this._mdf || forceRender;
if (this._mdf) {
var i = 0;
var len = this.dataProps.length;
if (this.renderer === "svg") {
this.dashStr = "";
}
for (i = 0; i < len; i += 1) {
if (this.dataProps[i].n !== "o") {
if (this.renderer === "svg") {
this.dashStr += " " + this.dataProps[i].p.v;
} else {
this.dashArray[i] = this.dataProps[i].p.v;
}
} else {
this.dashoffset[0] = this.dataProps[i].p.v;
}
}
}
};
extendPrototype([DynamicPropertyContainer], DashProperty);
function SVGStrokeStyleData(elem2, data2, styleOb) {
this.initDynamicPropertyContainer(elem2);
this.getValue = this.iterateDynamicProperties;
this.o = PropertyFactory.getProp(elem2, data2.o, 0, 0.01, this);
this.w = PropertyFactory.getProp(elem2, data2.w, 0, null, this);
this.d = new DashProperty(elem2, data2.d || {}, "svg", this);
this.c = PropertyFactory.getProp(elem2, data2.c, 1, 255, this);
this.style = styleOb;
this._isAnimated = !!this._isAnimated;
}
extendPrototype([DynamicPropertyContainer], SVGStrokeStyleData);
function SVGFillStyleData(elem2, data2, styleOb) {
this.initDynamicPropertyContainer(elem2);
this.getValue = this.iterateDynamicProperties;
this.o = PropertyFactory.getProp(elem2, data2.o, 0, 0.01, this);
this.c = PropertyFactory.getProp(elem2, data2.c, 1, 255, this);
this.style = styleOb;
}
extendPrototype([DynamicPropertyContainer], SVGFillStyleData);
function SVGNoStyleData(elem2, data2, styleOb) {
this.initDynamicPropertyContainer(elem2);
this.getValue = this.iterateDynamicProperties;
this.style = styleOb;
}
extendPrototype([DynamicPropertyContainer], SVGNoStyleData);
function GradientProperty(elem2, data2, container) {
this.data = data2;
this.c = createTypedArray("uint8c", data2.p * 4);
var cLength = data2.k.k[0].s ? data2.k.k[0].s.length - data2.p * 4 : data2.k.k.length - data2.p * 4;
this.o = createTypedArray("float32", cLength);
this._cmdf = false;
this._omdf = false;
this._collapsable = this.checkCollapsable();
this._hasOpacity = cLength;
this.initDynamicPropertyContainer(container);
this.prop = PropertyFactory.getProp(elem2, data2.k, 1, null, this);
this.k = this.prop.k;
this.getValue(true);
}
GradientProperty.prototype.comparePoints = function(values, points) {
var i = 0;
var len = this.o.length / 2;
var diff;
while (i < len) {
diff = Math.abs(values[i * 4] - values[points * 4 + i * 2]);
if (diff > 0.01) {
return false;
}
i += 1;
}
return true;
};
GradientProperty.prototype.checkCollapsable = function() {
if (this.o.length / 2 !== this.c.length / 4) {
return false;
}
if (this.data.k.k[0].s) {
var i = 0;
var len = this.data.k.k.length;
while (i < len) {
if (!this.comparePoints(this.data.k.k[i].s, this.data.p)) {
return false;
}
i += 1;
}
} else if (!this.comparePoints(this.data.k.k, this.data.p)) {
return false;
}
return true;
};
GradientProperty.prototype.getValue = function(forceRender) {
this.prop.getValue();
this._mdf = false;
this._cmdf = false;
this._omdf = false;
if (this.prop._mdf || forceRender) {
var i;
var len = this.data.p * 4;
var mult;
var val2;
for (i = 0; i < len; i += 1) {
mult = i % 4 === 0 ? 100 : 255;
val2 = Math.round(this.prop.v[i] * mult);
if (this.c[i] !== val2) {
this.c[i] = val2;
this._cmdf = !forceRender;
}
}
if (this.o.length) {
len = this.prop.v.length;
for (i = this.data.p * 4; i < len; i += 1) {
mult = i % 2 === 0 ? 100 : 1;
val2 = i % 2 === 0 ? Math.round(this.prop.v[i] * 100) : this.prop.v[i];
if (this.o[i - this.data.p * 4] !== val2) {
this.o[i - this.data.p * 4] = val2;
this._omdf = !forceRender;
}
}
}
this._mdf = !forceRender;
}
};
extendPrototype([DynamicPropertyContainer], GradientProperty);
function SVGGradientFillStyleData(elem2, data2, styleOb) {
this.initDynamicPropertyContainer(elem2);
this.getValue = this.iterateDynamicProperties;
this.initGradientData(elem2, data2, styleOb);
}
SVGGradientFillStyleData.prototype.initGradientData = function(elem2, data2, styleOb) {
this.o = PropertyFactory.getProp(elem2, data2.o, 0, 0.01, this);
this.s = PropertyFactory.getProp(elem2, data2.s, 1, null, this);
this.e = PropertyFactory.getProp(elem2, data2.e, 1, null, this);
this.h = PropertyFactory.getProp(elem2, data2.h || {
k: 0
}, 0, 0.01, this);
this.a = PropertyFactory.getProp(elem2, data2.a || {
k: 0
}, 0, degToRads, this);
this.g = new GradientProperty(elem2, data2.g, this);
this.style = styleOb;
this.stops = [];
this.setGradientData(styleOb.pElem, data2);
this.setGradientOpacity(data2, styleOb);
this._isAnimated = !!this._isAnimated;
};
SVGGradientFillStyleData.prototype.setGradientData = function(pathElement, data2) {
var gradientId = createElementID();
var gfill = createNS(data2.t === 1 ? "linearGradient" : "radialGradient");
gfill.setAttribute("id", gradientId);
gfill.setAttribute("spreadMethod", "pad");
gfill.setAttribute("gradientUnits", "userSpaceOnUse");
var stops = [];
var stop;
var j;
var jLen;
jLen = data2.g.p * 4;
for (j = 0; j < jLen; j += 4) {
stop = createNS("stop");
gfill.appendChild(stop);
stops.push(stop);
}
pathElement.setAttribute(data2.ty === "gf" ? "fill" : "stroke", "url(" + getLocationHref() + "#" + gradientId + ")");
this.gf = gfill;
this.cst = stops;
};
SVGGradientFillStyleData.prototype.setGradientOpacity = function(data2, styleOb) {
if (this.g._hasOpacity && !this.g._collapsable) {
var stop;
var j;
var jLen;
var mask2 = createNS("mask");
var maskElement = createNS("path");
mask2.appendChild(maskElement);
var opacityId = createElementID();
var maskId = createElementID();
mask2.setAttribute("id", maskId);
var opFill = createNS(data2.t === 1 ? "linearGradient" : "radialGradient");
opFill.setAttribute("id", opacityId);
opFill.setAttribute("spreadMethod", "pad");
opFill.setAttribute("gradientUnits", "userSpaceOnUse");
jLen = data2.g.k.k[0].s ? data2.g.k.k[0].s.length : data2.g.k.k.length;
var stops = this.stops;
for (j = data2.g.p * 4; j < jLen; j += 2) {
stop = createNS("stop");
stop.setAttribute("stop-color", "rgb(255,255,255)");
opFill.appendChild(stop);
stops.push(stop);
}
maskElement.setAttribute(data2.ty === "gf" ? "fill" : "stroke", "url(" + getLocationHref() + "#" + opacityId + ")");
if (data2.ty === "gs") {
maskElement.setAttribute("stroke-linecap", lineCapEnum[data2.lc || 2]);
maskElement.setAttribute("stroke-linejoin", lineJoinEnum[data2.lj || 2]);
if (data2.lj === 1) {
maskElement.setAttribute("stroke-miterlimit", data2.ml);
}
}
this.of = opFill;
this.ms = mask2;
this.ost = stops;
this.maskId = maskId;
styleOb.msElem = maskElement;
}
};
extendPrototype([DynamicPropertyContainer], SVGGradientFillStyleData);
function SVGGradientStrokeStyleData(elem2, data2, styleOb) {
this.initDynamicPropertyContainer(elem2);
this.getValue = this.iterateDynamicProperties;
this.w = PropertyFactory.getProp(elem2, data2.w, 0, null, this);
this.d = new DashProperty(elem2, data2.d || {}, "svg", this);
this.initGradientData(elem2, data2, styleOb);
this._isAnimated = !!this._isAnimated;
}
extendPrototype([SVGGradientFillStyleData, DynamicPropertyContainer], SVGGradientStrokeStyleData);
function ShapeGroupData() {
this.it = [];
this.prevViewData = [];
this.gr = createNS("g");
}
function SVGTransformData(mProps, op, container) {
this.transform = {
mProps,
op,
container
};
this.elements = [];
this._isAnimated = this.transform.mProps.dynamicProperties.length || this.transform.op.effectsSequence.length;
}
var buildShapeString = function buildShapeString2(pathNodes, length2, closed, mat) {
if (length2 === 0) {
return "";
}
var _o = pathNodes.o;
var _i = pathNodes.i;
var _v = pathNodes.v;
var i;
var shapeString = " M" + mat.applyToPointStringified(_v[0][0], _v[0][1]);
for (i = 1; i < length2; i += 1) {
shapeString += " C" + mat.applyToPointStringified(_o[i - 1][0], _o[i - 1][1]) + " " + mat.applyToPointStringified(_i[i][0], _i[i][1]) + " " + mat.applyToPointStringified(_v[i][0], _v[i][1]);
}
if (closed && length2) {
shapeString += " C" + mat.applyToPointStringified(_o[i - 1][0], _o[i - 1][1]) + " " + mat.applyToPointStringified(_i[0][0], _i[0][1]) + " " + mat.applyToPointStringified(_v[0][0], _v[0][1]);
shapeString += "z";
}
return shapeString;
};
var SVGElementsRenderer = function() {
var _identityMatrix = new Matrix();
var _matrixHelper = new Matrix();
var ob2 = {
createRenderFunction
};
function createRenderFunction(data2) {
switch (data2.ty) {
case "fl":
return renderFill;
case "gf":
return renderGradient;
case "gs":
return renderGradientStroke;
case "st":
return renderStroke;
case "sh":
case "el":
case "rc":
case "sr":
return renderPath;
case "tr":
return renderContentTransform;
case "no":
return renderNoop;
default:
return null;
}
}
function renderContentTransform(styleData, itemData, isFirstFrame) {
if (isFirstFrame || itemData.transform.op._mdf) {
itemData.transform.container.setAttribute("opacity", itemData.transform.op.v);
}
if (isFirstFrame || itemData.transform.mProps._mdf) {
itemData.transform.container.setAttribute("transform", itemData.transform.mProps.v.to2dCSS());
}
}
function renderNoop() {
}
function renderPath(styleData, itemData, isFirstFrame) {
var j;
var jLen;
var pathStringTransformed;
var redraw;
var pathNodes;
var l;
var lLen = itemData.styles.length;
var lvl = itemData.lvl;
var paths;
var mat;
var iterations;
var k;
for (l = 0; l < lLen; l += 1) {
redraw = itemData.sh._mdf || isFirstFrame;
if (itemData.styles[l].lvl < lvl) {
mat = _matrixHelper.reset();
iterations = lvl - itemData.styles[l].lvl;
k = itemData.transformers.length - 1;
while (!redraw && iterations > 0) {
redraw = itemData.transformers[k].mProps._mdf || redraw;
iterations -= 1;
k -= 1;
}
if (redraw) {
iterations = lvl - itemData.styles[l].lvl;
k = itemData.transformers.length - 1;
while (iterations > 0) {
mat.multiply(itemData.transformers[k].mProps.v);
iterations -= 1;
k -= 1;
}
}
} else {
mat = _identityMatrix;
}
paths = itemData.sh.paths;
jLen = paths._length;
if (redraw) {
pathStringTransformed = "";
for (j = 0; j < jLen; j += 1) {
pathNodes = paths.shapes[j];
if (pathNodes && pathNodes._length) {
pathStringTransformed += buildShapeString(pathNodes, pathNodes._length, pathNodes.c, mat);
}
}
itemData.caches[l] = pathStringTransformed;
} else {
pathStringTransformed = itemData.caches[l];
}
itemData.styles[l].d += styleData.hd === true ? "" : pathStringTransformed;
itemData.styles[l]._mdf = redraw || itemData.styles[l]._mdf;
}
}
function renderFill(styleData, itemData, isFirstFrame) {
var styleElem = itemData.style;
if (itemData.c._mdf || isFirstFrame) {
styleElem.pElem.setAttribute("fill", "rgb(" + bmFloor(itemData.c.v[0]) + "," + bmFloor(itemData.c.v[1]) + "," + bmFloor(itemData.c.v[2]) + ")");
}
if (itemData.o._mdf || isFirstFrame) {
styleElem.pElem.setAttribute("fill-opacity", itemData.o.v);
}
}
function renderGradientStroke(styleData, itemData, isFirstFrame) {
renderGradient(styleData, itemData, isFirstFrame);
renderStroke(styleData, itemData, isFirstFrame);
}
function renderGradient(styleData, itemData, isFirstFrame) {
var gfill = itemData.gf;
var hasOpacity = itemData.g._hasOpacity;
var pt1 = itemData.s.v;
var pt2 = itemData.e.v;
if (itemData.o._mdf || isFirstFrame) {
var attr = styleData.ty === "gf" ? "fill-opacity" : "stroke-opacity";
itemData.style.pElem.setAttribute(attr, itemData.o.v);
}
if (itemData.s._mdf || isFirstFrame) {
var attr1 = styleData.t === 1 ? "x1" : "cx";
var attr2 = attr1 === "x1" ? "y1" : "cy";
gfill.setAttribute(attr1, pt1[0]);
gfill.setAttribute(attr2, pt1[1]);
if (hasOpacity && !itemData.g._collapsable) {
itemData.of.setAttribute(attr1, pt1[0]);
itemData.of.setAttribute(attr2, pt1[1]);
}
}
var stops;
var i;
var len;
var stop;
if (itemData.g._cmdf || isFirstFrame) {
stops = itemData.cst;
var cValues = itemData.g.c;
len = stops.length;
for (i = 0; i < len; i += 1) {
stop = stops[i];
stop.setAttribute("offset", cValues[i * 4] + "%");
stop.setAttribute("stop-color", "rgb(" + cValues[i * 4 + 1] + "," + cValues[i * 4 + 2] + "," + cValues[i * 4 + 3] + ")");
}
}
if (hasOpacity && (itemData.g._omdf || isFirstFrame)) {
var oValues = itemData.g.o;
if (itemData.g._collapsable) {
stops = itemData.cst;
} else {
stops = itemData.ost;
}
len = stops.length;
for (i = 0; i < len; i += 1) {
stop = stops[i];
if (!itemData.g._collapsable) {
stop.setAttribute("offset", oValues[i * 2] + "%");
}
stop.setAttribute("stop-opacity", oValues[i * 2 + 1]);
}
}
if (styleData.t === 1) {
if (itemData.e._mdf || isFirstFrame) {
gfill.setAttribute("x2", pt2[0]);
gfill.setAttribute("y2", pt2[1]);
if (hasOpacity && !itemData.g._collapsable) {
itemData.of.setAttribute("x2", pt2[0]);
itemData.of.setAttribute("y2", pt2[1]);
}
}
} else {
var rad;
if (itemData.s._mdf || itemData.e._mdf || isFirstFrame) {
rad = Math.sqrt(Math.pow(pt1[0] - pt2[0], 2) + Math.pow(pt1[1] - pt2[1], 2));
gfill.setAttribute("r", rad);
if (hasOpacity && !itemData.g._collapsable) {
itemData.of.setAttribute("r", rad);
}
}
if (itemData.e._mdf || itemData.h._mdf || itemData.a._mdf || isFirstFrame) {
if (!rad) {
rad = Math.sqrt(Math.pow(pt1[0] - pt2[0], 2) + Math.pow(pt1[1] - pt2[1], 2));
}
var ang = Math.atan2(pt2[1] - pt1[1], pt2[0] - pt1[0]);
var percent = itemData.h.v;
if (percent >= 1) {
percent = 0.99;
} else if (percent <= -1) {
percent = -0.99;
}
var dist = rad * percent;
var x = Math.cos(ang + itemData.a.v) * dist + pt1[0];
var y = Math.sin(ang + itemData.a.v) * dist + pt1[1];
gfill.setAttribute("fx", x);
gfill.setAttribute("fy", y);
if (hasOpacity && !itemData.g._collapsable) {
itemData.of.setAttribute("fx", x);
itemData.of.setAttribute("fy", y);
}
}
}
}
function renderStroke(styleData, itemData, isFirstFrame) {
var styleElem = itemData.style;
var d = itemData.d;
if (d && (d._mdf || isFirstFrame) && d.dashStr) {
styleElem.pElem.setAttribute("stroke-dasharray", d.dashStr);
styleElem.pElem.setAttribute("stroke-dashoffset", d.dashoffset[0]);
}
if (itemData.c && (itemData.c._mdf || isFirstFrame)) {
styleElem.pElem.setAttribute("stroke", "rgb(" + bmFloor(itemData.c.v[0]) + "," + bmFloor(itemData.c.v[1]) + "," + bmFloor(itemData.c.v[2]) + ")");
}
if (itemData.o._mdf || isFirstFrame) {
styleElem.pElem.setAttribute("stroke-opacity", itemData.o.v);
}
if (itemData.w._mdf || isFirstFrame) {
styleElem.pElem.setAttribute("stroke-width", itemData.w.v);
if (styleElem.msElem) {
styleElem.msElem.setAttribute("stroke-width", itemData.w.v);
}
}
}
return ob2;
}();
function SVGShapeElement(data2, globalData2, comp2) {
this.shapes = [];
this.shapesData = data2.shapes;
this.stylesList = [];
this.shapeModifiers = [];
this.itemsData = [];
this.processedElements = [];
this.animatedContents = [];
this.initElement(data2, globalData2, comp2);
this.prevViewData = [];
}
extendPrototype([BaseElement, TransformElement, SVGBaseElement, IShapeElement, HierarchyElement, FrameElement, RenderableDOMElement], SVGShapeElement);
SVGShapeElement.prototype.initSecondaryElement = function() {
};
SVGShapeElement.prototype.identityMatrix = new Matrix();
SVGShapeElement.prototype.buildExpressionInterface = function() {
};
SVGShapeElement.prototype.createContent = function() {
this.searchShapes(this.shapesData, this.itemsData, this.prevViewData, this.layerElement, 0, [], true);
this.filterUniqueShapes();
};
SVGShapeElement.prototype.filterUniqueShapes = function() {
var i;
var len = this.shapes.length;
var shape;
var j;
var jLen = this.stylesList.length;
var style;
var tempShapes = [];
var areAnimated = false;
for (j = 0; j < jLen; j += 1) {
style = this.stylesList[j];
areAnimated = false;
tempShapes.length = 0;
for (i = 0; i < len; i += 1) {
shape = this.shapes[i];
if (shape.styles.indexOf(style) !== -1) {
tempShapes.push(shape);
areAnimated = shape._isAnimated || areAnimated;
}
}
if (tempShapes.length > 1 && areAnimated) {
this.setShapesAsAnimated(tempShapes);
}
}
};
SVGShapeElement.prototype.setShapesAsAnimated = function(shapes) {
var i;
var len = shapes.length;
for (i = 0; i < len; i += 1) {
shapes[i].setAsAnimated();
}
};
SVGShapeElement.prototype.createStyleElement = function(data2, level) {
var elementData;
var styleOb = new SVGStyleData(data2, level);
var pathElement = styleOb.pElem;
if (data2.ty === "st") {
elementData = new SVGStrokeStyleData(this, data2, styleOb);
} else if (data2.ty === "fl") {
elementData = new SVGFillStyleData(this, data2, styleOb);
} else if (data2.ty === "gf" || data2.ty === "gs") {
var GradientConstructor = data2.ty === "gf" ? SVGGradientFillStyleData : SVGGradientStrokeStyleData;
elementData = new GradientConstructor(this, data2, styleOb);
this.globalData.defs.appendChild(elementData.gf);
if (elementData.maskId) {
this.globalData.defs.appendChild(elementData.ms);
this.globalData.defs.appendChild(elementData.of);
pathElement.setAttribute("mask", "url(" + getLocationHref() + "#" + elementData.maskId + ")");
}
} else if (data2.ty === "no") {
elementData = new SVGNoStyleData(this, data2, styleOb);
}
if (data2.ty === "st" || data2.ty === "gs") {
pathElement.setAttribute("stroke-linecap", lineCapEnum[data2.lc || 2]);
pathElement.setAttribute("stroke-linejoin", lineJoinEnum[data2.lj || 2]);
pathElement.setAttribute("fill-opacity", "0");
if (data2.lj === 1) {
pathElement.setAttribute("stroke-miterlimit", data2.ml);
}
}
if (data2.r === 2) {
pathElement.setAttribute("fill-rule", "evenodd");
}
if (data2.ln) {
pathElement.setAttribute("id", data2.ln);
}
if (data2.cl) {
pathElement.setAttribute("class", data2.cl);
}
if (data2.bm) {
pathElement.style["mix-blend-mode"] = getBlendMode(data2.bm);
}
this.stylesList.push(styleOb);
this.addToAnimatedContents(data2, elementData);
return elementData;
};
SVGShapeElement.prototype.createGroupElement = function(data2) {
var elementData = new ShapeGroupData();
if (data2.ln) {
elementData.gr.setAttribute("id", data2.ln);
}
if (data2.cl) {
elementData.gr.setAttribute("class", data2.cl);
}
if (data2.bm) {
elementData.gr.style["mix-blend-mode"] = getBlendMode(data2.bm);
}
return elementData;
};
SVGShapeElement.prototype.createTransformElement = function(data2, container) {
var transformProperty = TransformPropertyFactory.getTransformProperty(this, data2, this);
var elementData = new SVGTransformData(transformProperty, transformProperty.o, container);
this.addToAnimatedContents(data2, elementData);
return elementData;
};
SVGShapeElement.prototype.createShapeElement = function(data2, ownTransformers, level) {
var ty = 4;
if (data2.ty === "rc") {
ty = 5;
} else if (data2.ty === "el") {
ty = 6;
} else if (data2.ty === "sr") {
ty = 7;
}
var shapeProperty = ShapePropertyFactory.getShapeProp(this, data2, ty, this);
var elementData = new SVGShapeData(ownTransformers, level, shapeProperty);
this.shapes.push(elementData);
this.addShapeToModifiers(elementData);
this.addToAnimatedContents(data2, elementData);
return elementData;
};
SVGShapeElement.prototype.addToAnimatedContents = function(data2, element) {
var i = 0;
var len = this.animatedContents.length;
while (i < len) {
if (this.animatedContents[i].element === element) {
return;
}
i += 1;
}
this.animatedContents.push({
fn: SVGElementsRenderer.createRenderFunction(data2),
element,
data: data2
});
};
SVGShapeElement.prototype.setElementStyles = function(elementData) {
var arr = elementData.styles;
var j;
var jLen = this.stylesList.length;
for (j = 0; j < jLen; j += 1) {
if (!this.stylesList[j].closed) {
arr.push(this.stylesList[j]);
}
}
};
SVGShapeElement.prototype.reloadShapes = function() {
this._isFirstFrame = true;
var i;
var len = this.itemsData.length;
for (i = 0; i < len; i += 1) {
this.prevViewData[i] = this.itemsData[i];
}
this.searchShapes(this.shapesData, this.itemsData, this.prevViewData, this.layerElement, 0, [], true);
this.filterUniqueShapes();
len = this.dynamicProperties.length;
for (i = 0; i < len; i += 1) {
this.dynamicProperties[i].getValue();
}
this.renderModifiers();
};
SVGShapeElement.prototype.searchShapes = function(arr, itemsData, prevViewData, container, level, transformers, render) {
var ownTransformers = [].concat(transformers);
var i;
var len = arr.length - 1;
var j;
var jLen;
var ownStyles = [];
var ownModifiers = [];
var currentTransform;
var modifier;
var processedPos;
for (i = len; i >= 0; i -= 1) {
processedPos = this.searchProcessedElement(arr[i]);
if (!processedPos) {
arr[i]._render = render;
} else {
itemsData[i] = prevViewData[processedPos - 1];
}
if (arr[i].ty === "fl" || arr[i].ty === "st" || arr[i].ty === "gf" || arr[i].ty === "gs" || arr[i].ty === "no") {
if (!processedPos) {
itemsData[i] = this.createStyleElement(arr[i], level);
} else {
itemsData[i].style.closed = false;
}
if (arr[i]._render) {
if (itemsData[i].style.pElem.parentNode !== container) {
container.appendChild(itemsData[i].style.pElem);
}
}
ownStyles.push(itemsData[i].style);
} else if (arr[i].ty === "gr") {
if (!processedPos) {
itemsData[i] = this.createGroupElement(arr[i]);
} else {
jLen = itemsData[i].it.length;
for (j = 0; j < jLen; j += 1) {
itemsData[i].prevViewData[j] = itemsData[i].it[j];
}
}
this.searchShapes(arr[i].it, itemsData[i].it, itemsData[i].prevViewData, itemsData[i].gr, level + 1, ownTransformers, render);
if (arr[i]._render) {
if (itemsData[i].gr.parentNode !== container) {
container.appendChild(itemsData[i].gr);
}
}
} else if (arr[i].ty === "tr") {
if (!processedPos) {
itemsData[i] = this.createTransformElement(arr[i], container);
}
currentTransform = itemsData[i].transform;
ownTransformers.push(currentTransform);
} else if (arr[i].ty === "sh" || arr[i].ty === "rc" || arr[i].ty === "el" || arr[i].ty === "sr") {
if (!processedPos) {
itemsData[i] = this.createShapeElement(arr[i], ownTransformers, level);
}
this.setElementStyles(itemsData[i]);
} else if (arr[i].ty === "tm" || arr[i].ty === "rd" || arr[i].ty === "ms" || arr[i].ty === "pb" || arr[i].ty === "zz" || arr[i].ty === "op") {
if (!processedPos) {
modifier = ShapeModifiers.getModifier(arr[i].ty);
modifier.init(this, arr[i]);
itemsData[i] = modifier;
this.shapeModifiers.push(modifier);
} else {
modifier = itemsData[i];
modifier.closed = false;
}
ownModifiers.push(modifier);
} else if (arr[i].ty === "rp") {
if (!processedPos) {
modifier = ShapeModifiers.getModifier(arr[i].ty);
itemsData[i] = modifier;
modifier.init(this, arr, i, itemsData);
this.shapeModifiers.push(modifier);
render = false;
} else {
modifier = itemsData[i];
modifier.closed = true;
}
ownModifiers.push(modifier);
}
this.addProcessedElement(arr[i], i + 1);
}
len = ownStyles.length;
for (i = 0; i < len; i += 1) {
ownStyles[i].closed = true;
}
len = ownModifiers.length;
for (i = 0; i < len; i += 1) {
ownModifiers[i].closed = true;
}
};
SVGShapeElement.prototype.renderInnerContent = function() {
this.renderModifiers();
var i;
var len = this.stylesList.length;
for (i = 0; i < len; i += 1) {
this.stylesList[i].reset();
}
this.renderShape();
for (i = 0; i < len; i += 1) {
if (this.stylesList[i]._mdf || this._isFirstFrame) {
if (this.stylesList[i].msElem) {
this.stylesList[i].msElem.setAttribute("d", this.stylesList[i].d);
this.stylesList[i].d = "M0 0" + this.stylesList[i].d;
}
this.stylesList[i].pElem.setAttribute("d", this.stylesList[i].d || "M0 0");
}
}
};
SVGShapeElement.prototype.renderShape = function() {
var i;
var len = this.animatedContents.length;
var animatedContent;
for (i = 0; i < len; i += 1) {
animatedContent = this.animatedContents[i];
if ((this._isFirstFrame || animatedContent.element._isAnimated) && animatedContent.data !== true) {
animatedContent.fn(animatedContent.data, animatedContent.element, this._isFirstFrame);
}
}
};
SVGShapeElement.prototype.destroy = function() {
this.destroyBaseElement();
this.shapesData = null;
this.itemsData = null;
};
function LetterProps(o, sw, sc, fc, m, p) {
this.o = o;
this.sw = sw;
this.sc = sc;
this.fc = fc;
this.m = m;
this.p = p;
this._mdf = {
o: true,
sw: !!sw,
sc: !!sc,
fc: !!fc,
m: true,
p: true
};
}
LetterProps.prototype.update = function(o, sw, sc, fc, m, p) {
this._mdf.o = false;
this._mdf.sw = false;
this._mdf.sc = false;
this._mdf.fc = false;
this._mdf.m = false;
this._mdf.p = false;
var updated = false;
if (this.o !== o) {
this.o = o;
this._mdf.o = true;
updated = true;
}
if (this.sw !== sw) {
this.sw = sw;
this._mdf.sw = true;
updated = true;
}
if (this.sc !== sc) {
this.sc = sc;
this._mdf.sc = true;
updated = true;
}
if (this.fc !== fc) {
this.fc = fc;
this._mdf.fc = true;
updated = true;
}
if (this.m !== m) {
this.m = m;
this._mdf.m = true;
updated = true;
}
if (p.length && (this.p[0] !== p[0] || this.p[1] !== p[1] || this.p[4] !== p[4] || this.p[5] !== p[5] || this.p[12] !== p[12] || this.p[13] !== p[13])) {
this.p = p;
this._mdf.p = true;
updated = true;
}
return updated;
};
function TextProperty(elem2, data2) {
this._frameId = initialDefaultFrame;
this.pv = "";
this.v = "";
this.kf = false;
this._isFirstFrame = true;
this._mdf = false;
if (data2.d && data2.d.sid) {
data2.d = elem2.globalData.slotManager.getProp(data2.d);
}
this.data = data2;
this.elem = elem2;
this.comp = this.elem.comp;
this.keysIndex = 0;
this.canResize = false;
this.minimumFontSize = 1;
this.effectsSequence = [];
this.currentData = {
ascent: 0,
boxWidth: this.defaultBoxWidth,
f: "",
fStyle: "",
fWeight: "",
fc: "",
j: "",
justifyOffset: "",
l: [],
lh: 0,
lineWidths: [],
ls: "",
of: "",
s: "",
sc: "",
sw: 0,
t: 0,
tr: 0,
sz: 0,
ps: null,
fillColorAnim: false,
strokeColorAnim: false,
strokeWidthAnim: false,
yOffset: 0,
finalSize: 0,
finalText: [],
finalLineHeight: 0,
__complete: false
};
this.copyData(this.currentData, this.data.d.k[0].s);
if (!this.searchProperty()) {
this.completeTextData(this.currentData);
}
}
TextProperty.prototype.defaultBoxWidth = [0, 0];
TextProperty.prototype.copyData = function(obj, data2) {
for (var s in data2) {
if (Object.prototype.hasOwnProperty.call(data2, s)) {
obj[s] = data2[s];
}
}
return obj;
};
TextProperty.prototype.setCurrentData = function(data2) {
if (!data2.__complete) {
this.completeTextData(data2);
}
this.currentData = data2;
this.currentData.boxWidth = this.currentData.boxWidth || this.defaultBoxWidth;
this._mdf = true;
};
TextProperty.prototype.searchProperty = function() {
return this.searchKeyframes();
};
TextProperty.prototype.searchKeyframes = function() {
this.kf = this.data.d.k.length > 1;
if (this.kf) {
this.addEffect(this.getKeyframeValue.bind(this));
}
return this.kf;
};
TextProperty.prototype.addEffect = function(effectFunction) {
this.effectsSequence.push(effectFunction);
this.elem.addDynamicProperty(this);
};
TextProperty.prototype.getValue = function(_finalValue) {
if ((this.elem.globalData.frameId === this.frameId || !this.effectsSequence.length) && !_finalValue) {
return;
}
this.currentData.t = this.data.d.k[this.keysIndex].s.t;
var currentValue = this.currentData;
var currentIndex = this.keysIndex;
if (this.lock) {
this.setCurrentData(this.currentData);
return;
}
this.lock = true;
this._mdf = false;
var i;
var len = this.effectsSequence.length;
var finalValue = _finalValue || this.data.d.k[this.keysIndex].s;
for (i = 0; i < len; i += 1) {
if (currentIndex !== this.keysIndex) {
finalValue = this.effectsSequence[i](finalValue, finalValue.t);
} else {
finalValue = this.effectsSequence[i](this.currentData, finalValue.t);
}
}
if (currentValue !== finalValue) {
this.setCurrentData(finalValue);
}
this.v = this.currentData;
this.pv = this.v;
this.lock = false;
this.frameId = this.elem.globalData.frameId;
};
TextProperty.prototype.getKeyframeValue = function() {
var textKeys = this.data.d.k;
var frameNum = this.elem.comp.renderedFrame;
var i = 0;
var len = textKeys.length;
while (i <= len - 1) {
if (i === len - 1 || textKeys[i + 1].t > frameNum) {
break;
}
i += 1;
}
if (this.keysIndex !== i) {
this.keysIndex = i;
}
return this.data.d.k[this.keysIndex].s;
};
TextProperty.prototype.buildFinalText = function(text2) {
var charactersArray = [];
var i = 0;
var len = text2.length;
var charCode;
var secondCharCode;
var shouldCombine = false;
var shouldCombineNext = false;
var currentChars = "";
while (i < len) {
shouldCombine = shouldCombineNext;
shouldCombineNext = false;
charCode = text2.charCodeAt(i);
currentChars = text2.charAt(i);
if (FontManager.isCombinedCharacter(charCode)) {
shouldCombine = true;
} else if (charCode >= 55296 && charCode <= 56319) {
if (FontManager.isRegionalFlag(text2, i)) {
currentChars = text2.substr(i, 14);
} else {
secondCharCode = text2.charCodeAt(i + 1);
if (secondCharCode >= 56320 && secondCharCode <= 57343) {
if (FontManager.isModifier(charCode, secondCharCode)) {
currentChars = text2.substr(i, 2);
shouldCombine = true;
} else if (FontManager.isFlagEmoji(text2.substr(i, 4))) {
currentChars = text2.substr(i, 4);
} else {
currentChars = text2.substr(i, 2);
}
}
}
} else if (charCode > 56319) {
secondCharCode = text2.charCodeAt(i + 1);
if (FontManager.isVariationSelector(charCode)) {
shouldCombine = true;
}
} else if (FontManager.isZeroWidthJoiner(charCode)) {
shouldCombine = true;
shouldCombineNext = true;
}
if (shouldCombine) {
charactersArray[charactersArray.length - 1] += currentChars;
shouldCombine = false;
} else {
charactersArray.push(currentChars);
}
i += currentChars.length;
}
return charactersArray;
};
TextProperty.prototype.completeTextData = function(documentData) {
documentData.__complete = true;
var fontManager = this.elem.globalData.fontManager;
var data2 = this.data;
var letters = [];
var i;
var len;
var newLineFlag;
var index2 = 0;
var val2;
var anchorGrouping = data2.m.g;
var currentSize = 0;
var currentPos = 0;
var currentLine = 0;
var lineWidths = [];
var lineWidth = 0;
var maxLineWidth = 0;
var j;
var jLen;
var fontData = fontManager.getFontByName(documentData.f);
var charData;
var cLength = 0;
var fontProps = getFontProperties(fontData);
documentData.fWeight = fontProps.weight;
documentData.fStyle = fontProps.style;
documentData.finalSize = documentData.s;
documentData.finalText = this.buildFinalText(documentData.t);
len = documentData.finalText.length;
documentData.finalLineHeight = documentData.lh;
var trackingOffset = documentData.tr / 1e3 * documentData.finalSize;
var charCode;
if (documentData.sz) {
var flag = true;
var boxWidth = documentData.sz[0];
var boxHeight = documentData.sz[1];
var currentHeight;
var finalText;
while (flag) {
finalText = this.buildFinalText(documentData.t);
currentHeight = 0;
lineWidth = 0;
len = finalText.length;
trackingOffset = documentData.tr / 1e3 * documentData.finalSize;
var lastSpaceIndex = -1;
for (i = 0; i < len; i += 1) {
charCode = finalText[i].charCodeAt(0);
newLineFlag = false;
if (finalText[i] === " ") {
lastSpaceIndex = i;
} else if (charCode === 13 || charCode === 3) {
lineWidth = 0;
newLineFlag = true;
currentHeight += documentData.finalLineHeight || documentData.finalSize * 1.2;
}
if (fontManager.chars) {
charData = fontManager.getCharData(finalText[i], fontData.fStyle, fontData.fFamily);
cLength = newLineFlag ? 0 : charData.w * documentData.finalSize / 100;
} else {
cLength = fontManager.measureText(finalText[i], documentData.f, documentData.finalSize);
}
if (lineWidth + cLength > boxWidth && finalText[i] !== " ") {
if (lastSpaceIndex === -1) {
len += 1;
} else {
i = lastSpaceIndex;
}
currentHeight += documentData.finalLineHeight || documentData.finalSize * 1.2;
finalText.splice(i, lastSpaceIndex === i ? 1 : 0, "\r");
lastSpaceIndex = -1;
lineWidth = 0;
} else {
lineWidth += cLength;
lineWidth += trackingOffset;
}
}
currentHeight += fontData.ascent * documentData.finalSize / 100;
if (this.canResize && documentData.finalSize > this.minimumFontSize && boxHeight < currentHeight) {
documentData.finalSize -= 1;
documentData.finalLineHeight = documentData.finalSize * documentData.lh / documentData.s;
} else {
documentData.finalText = finalText;
len = documentData.finalText.length;
flag = false;
}
}
}
lineWidth = -trackingOffset;
cLength = 0;
var uncollapsedSpaces = 0;
var currentChar;
for (i = 0; i < len; i += 1) {
newLineFlag = false;
currentChar = documentData.finalText[i];
charCode = currentChar.charCodeAt(0);
if (charCode === 13 || charCode === 3) {
uncollapsedSpaces = 0;
lineWidths.push(lineWidth);
maxLineWidth = lineWidth > maxLineWidth ? lineWidth : maxLineWidth;
lineWidth = -2 * trackingOffset;
val2 = "";
newLineFlag = true;
currentLine += 1;
} else {
val2 = currentChar;
}
if (fontManager.chars) {
charData = fontManager.getCharData(currentChar, fontData.fStyle, fontManager.getFontByName(documentData.f).fFamily);
cLength = newLineFlag ? 0 : charData.w * documentData.finalSize / 100;
} else {
cLength = fontManager.measureText(val2, documentData.f, documentData.finalSize);
}
if (currentChar === " ") {
uncollapsedSpaces += cLength + trackingOffset;
} else {
lineWidth += cLength + trackingOffset + uncollapsedSpaces;
uncollapsedSpaces = 0;
}
letters.push({
l: cLength,
an: cLength,
add: currentSize,
n: newLineFlag,
anIndexes: [],
val: val2,
line: currentLine,
animatorJustifyOffset: 0
});
if (anchorGrouping == 2) {
currentSize += cLength;
if (val2 === "" || val2 === " " || i === len - 1) {
if (val2 === "" || val2 === " ") {
currentSize -= cLength;
}
while (currentPos <= i) {
letters[currentPos].an = currentSize;
letters[currentPos].ind = index2;
letters[currentPos].extra = cLength;
currentPos += 1;
}
index2 += 1;
currentSize = 0;
}
} else if (anchorGrouping == 3) {
currentSize += cLength;
if (val2 === "" || i === len - 1) {
if (val2 === "") {
currentSize -= cLength;
}
while (currentPos <= i) {
letters[currentPos].an = currentSize;
letters[currentPos].ind = index2;
letters[currentPos].extra = cLength;
currentPos += 1;
}
currentSize = 0;
index2 += 1;
}
} else {
letters[index2].ind = index2;
letters[index2].extra = 0;
index2 += 1;
}
}
documentData.l = letters;
maxLineWidth = lineWidth > maxLineWidth ? lineWidth : maxLineWidth;
lineWidths.push(lineWidth);
if (documentData.sz) {
documentData.boxWidth = documentData.sz[0];
documentData.justifyOffset = 0;
} else {
documentData.boxWidth = maxLineWidth;
switch (documentData.j) {
case 1:
documentData.justifyOffset = -documentData.boxWidth;
break;
case 2:
documentData.justifyOffset = -documentData.boxWidth / 2;
break;
default:
documentData.justifyOffset = 0;
}
}
documentData.lineWidths = lineWidths;
var animators = data2.a;
var animatorData;
var letterData;
jLen = animators.length;
var based;
var ind;
var indexes = [];
for (j = 0; j < jLen; j += 1) {
animatorData = animators[j];
if (animatorData.a.sc) {
documentData.strokeColorAnim = true;
}
if (animatorData.a.sw) {
documentData.strokeWidthAnim = true;
}
if (animatorData.a.fc || animatorData.a.fh || animatorData.a.fs || animatorData.a.fb) {
documentData.fillColorAnim = true;
}
ind = 0;
based = animatorData.s.b;
for (i = 0; i < len; i += 1) {
letterData = letters[i];
letterData.anIndexes[j] = ind;
if (based == 1 && letterData.val !== "" || based == 2 && letterData.val !== "" && letterData.val !== " " || based == 3 && (letterData.n || letterData.val == " " || i == len - 1) || based == 4 && (letterData.n || i == len - 1)) {
if (animatorData.s.rn === 1) {
indexes.push(ind);
}
ind += 1;
}
}
data2.a[j].s.totalChars = ind;
var currentInd = -1;
var newInd;
if (animatorData.s.rn === 1) {
for (i = 0; i < len; i += 1) {
letterData = letters[i];
if (currentInd != letterData.anIndexes[j]) {
currentInd = letterData.anIndexes[j];
newInd = indexes.splice(Math.floor(Math.random() * indexes.length), 1)[0];
}
letterData.anIndexes[j] = newInd;
}
}
}
documentData.yOffset = documentData.finalLineHeight || documentData.finalSize * 1.2;
documentData.ls = documentData.ls || 0;
documentData.ascent = fontData.ascent * documentData.finalSize / 100;
};
TextProperty.prototype.updateDocumentData = function(newData, index2) {
index2 = index2 === void 0 ? this.keysIndex : index2;
var dData = this.copyData({}, this.data.d.k[index2].s);
dData = this.copyData(dData, newData);
this.data.d.k[index2].s = dData;
this.recalculate(index2);
this.setCurrentData(dData);
this.elem.addDynamicProperty(this);
};
TextProperty.prototype.recalculate = function(index2) {
var dData = this.data.d.k[index2].s;
dData.__complete = false;
this.keysIndex = 0;
this._isFirstFrame = true;
this.getValue(dData);
};
TextProperty.prototype.canResizeFont = function(_canResize) {
this.canResize = _canResize;
this.recalculate(this.keysIndex);
this.elem.addDynamicProperty(this);
};
TextProperty.prototype.setMinimumFontSize = function(_fontValue) {
this.minimumFontSize = Math.floor(_fontValue) || 1;
this.recalculate(this.keysIndex);
this.elem.addDynamicProperty(this);
};
var TextSelectorProp = function() {
var max = Math.max;
var min = Math.min;
var floor = Math.floor;
function TextSelectorPropFactory(elem2, data2) {
this._currentTextLength = -1;
this.k = false;
this.data = data2;
this.elem = elem2;
this.comp = elem2.comp;
this.finalS = 0;
this.finalE = 0;
this.initDynamicPropertyContainer(elem2);
this.s = PropertyFactory.getProp(elem2, data2.s || {
k: 0
}, 0, 0, this);
if ("e" in data2) {
this.e = PropertyFactory.getProp(elem2, data2.e, 0, 0, this);
} else {
this.e = {
v: 100
};
}
this.o = PropertyFactory.getProp(elem2, data2.o || {
k: 0
}, 0, 0, this);
this.xe = PropertyFactory.getProp(elem2, data2.xe || {
k: 0
}, 0, 0, this);
this.ne = PropertyFactory.getProp(elem2, data2.ne || {
k: 0
}, 0, 0, this);
this.sm = PropertyFactory.getProp(elem2, data2.sm || {
k: 100
}, 0, 0, this);
this.a = PropertyFactory.getProp(elem2, data2.a, 0, 0.01, this);
if (!this.dynamicProperties.length) {
this.getValue();
}
}
TextSelectorPropFactory.prototype = {
getMult: function getMult(ind) {
if (this._currentTextLength !== this.elem.textProperty.currentData.l.length) {
this.getValue();
}
var x1 = 0;
var y1 = 0;
var x2 = 1;
var y2 = 1;
if (this.ne.v > 0) {
x1 = this.ne.v / 100;
} else {
y1 = -this.ne.v / 100;
}
if (this.xe.v > 0) {
x2 = 1 - this.xe.v / 100;
} else {
y2 = 1 + this.xe.v / 100;
}
var easer = BezierFactory.getBezierEasing(x1, y1, x2, y2).get;
var mult = 0;
var s = this.finalS;
var e = this.finalE;
var type = this.data.sh;
if (type === 2) {
if (e === s) {
mult = ind >= e ? 1 : 0;
} else {
mult = max(0, min(0.5 / (e - s) + (ind - s) / (e - s), 1));
}
mult = easer(mult);
} else if (type === 3) {
if (e === s) {
mult = ind >= e ? 0 : 1;
} else {
mult = 1 - max(0, min(0.5 / (e - s) + (ind - s) / (e - s), 1));
}
mult = easer(mult);
} else if (type === 4) {
if (e === s) {
mult = 0;
} else {
mult = max(0, min(0.5 / (e - s) + (ind - s) / (e - s), 1));
if (mult < 0.5) {
mult *= 2;
} else {
mult = 1 - 2 * (mult - 0.5);
}
}
mult = easer(mult);
} else if (type === 5) {
if (e === s) {
mult = 0;
} else {
var tot = e - s;
ind = min(max(0, ind + 0.5 - s), e - s);
var x = -tot / 2 + ind;
var a = tot / 2;
mult = Math.sqrt(1 - x * x / (a * a));
}
mult = easer(mult);
} else if (type === 6) {
if (e === s) {
mult = 0;
} else {
ind = min(max(0, ind + 0.5 - s), e - s);
mult = (1 + Math.cos(Math.PI + Math.PI * 2 * ind / (e - s))) / 2;
}
mult = easer(mult);
} else {
if (ind >= floor(s)) {
if (ind - s < 0) {
mult = max(0, min(min(e, 1) - (s - ind), 1));
} else {
mult = max(0, min(e - ind, 1));
}
}
mult = easer(mult);
}
if (this.sm.v !== 100) {
var smoothness = this.sm.v * 0.01;
if (smoothness === 0) {
smoothness = 1e-8;
}
var threshold = 0.5 - smoothness * 0.5;
if (mult < threshold) {
mult = 0;
} else {
mult = (mult - threshold) / smoothness;
if (mult > 1) {
mult = 1;
}
}
}
return mult * this.a.v;
},
getValue: function getValue(newCharsFlag) {
this.iterateDynamicProperties();
this._mdf = newCharsFlag || this._mdf;
this._currentTextLength = this.elem.textProperty.currentData.l.length || 0;
if (newCharsFlag && this.data.r === 2) {
this.e.v = this._currentTextLength;
}
var divisor = this.data.r === 2 ? 1 : 100 / this.data.totalChars;
var o = this.o.v / divisor;
var s = this.s.v / divisor + o;
var e = this.e.v / divisor + o;
if (s > e) {
var _s = s;
s = e;
e = _s;
}
this.finalS = s;
this.finalE = e;
}
};
extendPrototype([DynamicPropertyContainer], TextSelectorPropFactory);
function getTextSelectorProp(elem2, data2, arr) {
return new TextSelectorPropFactory(elem2, data2, arr);
}
return {
getTextSelectorProp
};
}();
function TextAnimatorDataProperty(elem2, animatorProps, container) {
var defaultData = {
propType: false
};
var getProp = PropertyFactory.getProp;
var textAnimatorAnimatables = animatorProps.a;
this.a = {
r: textAnimatorAnimatables.r ? getProp(elem2, textAnimatorAnimatables.r, 0, degToRads, container) : defaultData,
rx: textAnimatorAnimatables.rx ? getProp(elem2, textAnimatorAnimatables.rx, 0, degToRads, container) : defaultData,
ry: textAnimatorAnimatables.ry ? getProp(elem2, textAnimatorAnimatables.ry, 0, degToRads, container) : defaultData,
sk: textAnimatorAnimatables.sk ? getProp(elem2, textAnimatorAnimatables.sk, 0, degToRads, container) : defaultData,
sa: textAnimatorAnimatables.sa ? getProp(elem2, textAnimatorAnimatables.sa, 0, degToRads, container) : defaultData,
s: textAnimatorAnimatables.s ? getProp(elem2, textAnimatorAnimatables.s, 1, 0.01, container) : defaultData,
a: textAnimatorAnimatables.a ? getProp(elem2, textAnimatorAnimatables.a, 1, 0, container) : defaultData,
o: textAnimatorAnimatables.o ? getProp(elem2, textAnimatorAnimatables.o, 0, 0.01, container) : defaultData,
p: textAnimatorAnimatables.p ? getProp(elem2, textAnimatorAnimatables.p, 1, 0, container) : defaultData,
sw: textAnimatorAnimatables.sw ? getProp(elem2, textAnimatorAnimatables.sw, 0, 0, container) : defaultData,
sc: textAnimatorAnimatables.sc ? getProp(elem2, textAnimatorAnimatables.sc, 1, 0, container) : defaultData,
fc: textAnimatorAnimatables.fc ? getProp(elem2, textAnimatorAnimatables.fc, 1, 0, container) : defaultData,
fh: textAnimatorAnimatables.fh ? getProp(elem2, textAnimatorAnimatables.fh, 0, 0, container) : defaultData,
fs: textAnimatorAnimatables.fs ? getProp(elem2, textAnimatorAnimatables.fs, 0, 0.01, container) : defaultData,
fb: textAnimatorAnimatables.fb ? getProp(elem2, textAnimatorAnimatables.fb, 0, 0.01, container) : defaultData,
t: textAnimatorAnimatables.t ? getProp(elem2, textAnimatorAnimatables.t, 0, 0, container) : defaultData
};
this.s = TextSelectorProp.getTextSelectorProp(elem2, animatorProps.s, container);
this.s.t = animatorProps.s.t;
}
function TextAnimatorProperty(textData, renderType, elem2) {
this._isFirstFrame = true;
this._hasMaskedPath = false;
this._frameId = -1;
this._textData = textData;
this._renderType = renderType;
this._elem = elem2;
this._animatorsData = createSizedArray(this._textData.a.length);
this._pathData = {};
this._moreOptions = {
alignment: {}
};
this.renderedLetters = [];
this.lettersChangedFlag = false;
this.initDynamicPropertyContainer(elem2);
}
TextAnimatorProperty.prototype.searchProperties = function() {
var i;
var len = this._textData.a.length;
var animatorProps;
var getProp = PropertyFactory.getProp;
for (i = 0; i < len; i += 1) {
animatorProps = this._textData.a[i];
this._animatorsData[i] = new TextAnimatorDataProperty(this._elem, animatorProps, this);
}
if (this._textData.p && "m" in this._textData.p) {
this._pathData = {
a: getProp(this._elem, this._textData.p.a, 0, 0, this),
f: getProp(this._elem, this._textData.p.f, 0, 0, this),
l: getProp(this._elem, this._textData.p.l, 0, 0, this),
r: getProp(this._elem, this._textData.p.r, 0, 0, this),
p: getProp(this._elem, this._textData.p.p, 0, 0, this),
m: this._elem.maskManager.getMaskProperty(this._textData.p.m)
};
this._hasMaskedPath = true;
} else {
this._hasMaskedPath = false;
}
this._moreOptions.alignment = getProp(this._elem, this._textData.m.a, 1, 0, this);
};
TextAnimatorProperty.prototype.getMeasures = function(documentData, lettersChangedFlag) {
this.lettersChangedFlag = lettersChangedFlag;
if (!this._mdf && !this._isFirstFrame && !lettersChangedFlag && (!this._hasMaskedPath || !this._pathData.m._mdf)) {
return;
}
this._isFirstFrame = false;
var alignment = this._moreOptions.alignment.v;
var animators = this._animatorsData;
var textData = this._textData;
var matrixHelper = this.mHelper;
var renderType = this._renderType;
var renderedLettersCount = this.renderedLetters.length;
var xPos;
var yPos;
var i;
var len;
var letters = documentData.l;
var pathInfo;
var currentLength;
var currentPoint;
var segmentLength;
var flag;
var pointInd;
var segmentInd;
var prevPoint;
var points;
var segments;
var partialLength;
var totalLength;
var perc;
var tanAngle;
var mask2;
if (this._hasMaskedPath) {
mask2 = this._pathData.m;
if (!this._pathData.n || this._pathData._mdf) {
var paths = mask2.v;
if (this._pathData.r.v) {
paths = paths.reverse();
}
pathInfo = {
tLength: 0,
segments: []
};
len = paths._length - 1;
var bezierData;
totalLength = 0;
for (i = 0; i < len; i += 1) {
bezierData = bez.buildBezierData(paths.v[i], paths.v[i + 1], [paths.o[i][0] - paths.v[i][0], paths.o[i][1] - paths.v[i][1]], [paths.i[i + 1][0] - paths.v[i + 1][0], paths.i[i + 1][1] - paths.v[i + 1][1]]);
pathInfo.tLength += bezierData.segmentLength;
pathInfo.segments.push(bezierData);
totalLength += bezierData.segmentLength;
}
i = len;
if (mask2.v.c) {
bezierData = bez.buildBezierData(paths.v[i], paths.v[0], [paths.o[i][0] - paths.v[i][0], paths.o[i][1] - paths.v[i][1]], [paths.i[0][0] - paths.v[0][0], paths.i[0][1] - paths.v[0][1]]);
pathInfo.tLength += bezierData.segmentLength;
pathInfo.segments.push(bezierData);
totalLength += bezierData.segmentLength;
}
this._pathData.pi = pathInfo;
}
pathInfo = this._pathData.pi;
currentLength = this._pathData.f.v;
segmentInd = 0;
pointInd = 1;
segmentLength = 0;
flag = true;
segments = pathInfo.segments;
if (currentLength < 0 && mask2.v.c) {
if (pathInfo.tLength < Math.abs(currentLength)) {
currentLength = -Math.abs(currentLength) % pathInfo.tLength;
}
segmentInd = segments.length - 1;
points = segments[segmentInd].points;
pointInd = points.length - 1;
while (currentLength < 0) {
currentLength += points[pointInd].partialLength;
pointInd -= 1;
if (pointInd < 0) {
segmentInd -= 1;
points = segments[segmentInd].points;
pointInd = points.length - 1;
}
}
}
points = segments[segmentInd].points;
prevPoint = points[pointInd - 1];
currentPoint = points[pointInd];
partialLength = currentPoint.partialLength;
}
len = letters.length;
xPos = 0;
yPos = 0;
var yOff = documentData.finalSize * 1.2 * 0.714;
var firstLine = true;
var animatorProps;
var animatorSelector;
var j;
var jLen;
var letterValue;
jLen = animators.length;
var mult;
var ind = -1;
var offf;
var xPathPos;
var yPathPos;
var initPathPos = currentLength;
var initSegmentInd = segmentInd;
var initPointInd = pointInd;
var currentLine = -1;
var elemOpacity;
var sc;
var sw;
var fc;
var k;
var letterSw;
var letterSc;
var letterFc;
var letterM = "";
var letterP = this.defaultPropsArray;
var letterO;
if (documentData.j === 2 || documentData.j === 1) {
var animatorJustifyOffset = 0;
var animatorFirstCharOffset = 0;
var justifyOffsetMult = documentData.j === 2 ? -0.5 : -1;
var lastIndex = 0;
var isNewLine = true;
for (i = 0; i < len; i += 1) {
if (letters[i].n) {
if (animatorJustifyOffset) {
animatorJustifyOffset += animatorFirstCharOffset;
}
while (lastIndex < i) {
letters[lastIndex].animatorJustifyOffset = animatorJustifyOffset;
lastIndex += 1;
}
animatorJustifyOffset = 0;
isNewLine = true;
} else {
for (j = 0; j < jLen; j += 1) {
animatorProps = animators[j].a;
if (animatorProps.t.propType) {
if (isNewLine && documentData.j === 2) {
animatorFirstCharOffset += animatorProps.t.v * justifyOffsetMult;
}
animatorSelector = animators[j].s;
mult = animatorSelector.getMult(letters[i].anIndexes[j], textData.a[j].s.totalChars);
if (mult.length) {
animatorJustifyOffset += animatorProps.t.v * mult[0] * justifyOffsetMult;
} else {
animatorJustifyOffset += animatorProps.t.v * mult * justifyOffsetMult;
}
}
}
isNewLine = false;
}
}
if (animatorJustifyOffset) {
animatorJustifyOffset += animatorFirstCharOffset;
}
while (lastIndex < i) {
letters[lastIndex].animatorJustifyOffset = animatorJustifyOffset;
lastIndex += 1;
}
}
for (i = 0; i < len; i += 1) {
matrixHelper.reset();
elemOpacity = 1;
if (letters[i].n) {
xPos = 0;
yPos += documentData.yOffset;
yPos += firstLine ? 1 : 0;
currentLength = initPathPos;
firstLine = false;
if (this._hasMaskedPath) {
segmentInd = initSegmentInd;
pointInd = initPointInd;
points = segments[segmentInd].points;
prevPoint = points[pointInd - 1];
currentPoint = points[pointInd];
partialLength = currentPoint.partialLength;
segmentLength = 0;
}
letterM = "";
letterFc = "";
letterSw = "";
letterO = "";
letterP = this.defaultPropsArray;
} else {
if (this._hasMaskedPath) {
if (currentLine !== letters[i].line) {
switch (documentData.j) {
case 1:
currentLength += totalLength - documentData.lineWidths[letters[i].line];
break;
case 2:
currentLength += (totalLength - documentData.lineWidths[letters[i].line]) / 2;
break;
default:
break;
}
currentLine = letters[i].line;
}
if (ind !== letters[i].ind) {
if (letters[ind]) {
currentLength += letters[ind].extra;
}
currentLength += letters[i].an / 2;
ind = letters[i].ind;
}
currentLength += alignment[0] * letters[i].an * 5e-3;
var animatorOffset = 0;
for (j = 0; j < jLen; j += 1) {
animatorProps = animators[j].a;
if (animatorProps.p.propType) {
animatorSelector = animators[j].s;
mult = animatorSelector.getMult(letters[i].anIndexes[j], textData.a[j].s.totalChars);
if (mult.length) {
animatorOffset += animatorProps.p.v[0] * mult[0];
} else {
animatorOffset += animatorProps.p.v[0] * mult;
}
}
if (animatorProps.a.propType) {
animatorSelector = animators[j].s;
mult = animatorSelector.getMult(letters[i].anIndexes[j], textData.a[j].s.totalChars);
if (mult.length) {
animatorOffset += animatorProps.a.v[0] * mult[0];
} else {
animatorOffset += animatorProps.a.v[0] * mult;
}
}
}
flag = true;
if (this._pathData.a.v) {
currentLength = letters[0].an * 0.5 + (totalLength - this._pathData.f.v - letters[0].an * 0.5 - letters[letters.length - 1].an * 0.5) * ind / (len - 1);
currentLength += this._pathData.f.v;
}
while (flag) {
if (segmentLength + partialLength >= currentLength + animatorOffset || !points) {
perc = (currentLength + animatorOffset - segmentLength) / currentPoint.partialLength;
xPathPos = prevPoint.point[0] + (currentPoint.point[0] - prevPoint.point[0]) * perc;
yPathPos = prevPoint.point[1] + (currentPoint.point[1] - prevPoint.point[1]) * perc;
matrixHelper.translate(-alignment[0] * letters[i].an * 5e-3, -(alignment[1] * yOff) * 0.01);
flag = false;
} else if (points) {
segmentLength += currentPoint.partialLength;
pointInd += 1;
if (pointInd >= points.length) {
pointInd = 0;
segmentInd += 1;
if (!segments[segmentInd]) {
if (mask2.v.c) {
pointInd = 0;
segmentInd = 0;
points = segments[segmentInd].points;
} else {
segmentLength -= currentPoint.partialLength;
points = null;
}
} else {
points = segments[segmentInd].points;
}
}
if (points) {
prevPoint = currentPoint;
currentPoint = points[pointInd];
partialLength = currentPoint.partialLength;
}
}
}
offf = letters[i].an / 2 - letters[i].add;
matrixHelper.translate(-offf, 0, 0);
} else {
offf = letters[i].an / 2 - letters[i].add;
matrixHelper.translate(-offf, 0, 0);
matrixHelper.translate(-alignment[0] * letters[i].an * 5e-3, -alignment[1] * yOff * 0.01, 0);
}
for (j = 0; j < jLen; j += 1) {
animatorProps = animators[j].a;
if (animatorProps.t.propType) {
animatorSelector = animators[j].s;
mult = animatorSelector.getMult(letters[i].anIndexes[j], textData.a[j].s.totalChars);
if (xPos !== 0 || documentData.j !== 0) {
if (this._hasMaskedPath) {
if (mult.length) {
currentLength += animatorProps.t.v * mult[0];
} else {
currentLength += animatorProps.t.v * mult;
}
} else if (mult.length) {
xPos += animatorProps.t.v * mult[0];
} else {
xPos += animatorProps.t.v * mult;
}
}
}
}
if (documentData.strokeWidthAnim) {
sw = documentData.sw || 0;
}
if (documentData.strokeColorAnim) {
if (documentData.sc) {
sc = [documentData.sc[0], documentData.sc[1], documentData.sc[2]];
} else {
sc = [0, 0, 0];
}
}
if (documentData.fillColorAnim && documentData.fc) {
fc = [documentData.fc[0], documentData.fc[1], documentData.fc[2]];
}
for (j = 0; j < jLen; j += 1) {
animatorProps = animators[j].a;
if (animatorProps.a.propType) {
animatorSelector = animators[j].s;
mult = animatorSelector.getMult(letters[i].anIndexes[j], textData.a[j].s.totalChars);
if (mult.length) {
matrixHelper.translate(-animatorProps.a.v[0] * mult[0], -animatorProps.a.v[1] * mult[1], animatorProps.a.v[2] * mult[2]);
} else {
matrixHelper.translate(-animatorProps.a.v[0] * mult, -animatorProps.a.v[1] * mult, animatorProps.a.v[2] * mult);
}
}
}
for (j = 0; j < jLen; j += 1) {
animatorProps = animators[j].a;
if (animatorProps.s.propType) {
animatorSelector = animators[j].s;
mult = animatorSelector.getMult(letters[i].anIndexes[j], textData.a[j].s.totalChars);
if (mult.length) {
matrixHelper.scale(1 + (animatorProps.s.v[0] - 1) * mult[0], 1 + (animatorProps.s.v[1] - 1) * mult[1], 1);
} else {
matrixHelper.scale(1 + (animatorProps.s.v[0] - 1) * mult, 1 + (animatorProps.s.v[1] - 1) * mult, 1);
}
}
}
for (j = 0; j < jLen; j += 1) {
animatorProps = animators[j].a;
animatorSelector = animators[j].s;
mult = animatorSelector.getMult(letters[i].anIndexes[j], textData.a[j].s.totalChars);
if (animatorProps.sk.propType) {
if (mult.length) {
matrixHelper.skewFromAxis(-animatorProps.sk.v * mult[0], animatorProps.sa.v * mult[1]);
} else {
matrixHelper.skewFromAxis(-animatorProps.sk.v * mult, animatorProps.sa.v * mult);
}
}
if (animatorProps.r.propType) {
if (mult.length) {
matrixHelper.rotateZ(-animatorProps.r.v * mult[2]);
} else {
matrixHelper.rotateZ(-animatorProps.r.v * mult);
}
}
if (animatorProps.ry.propType) {
if (mult.length) {
matrixHelper.rotateY(animatorProps.ry.v * mult[1]);
} else {
matrixHelper.rotateY(animatorProps.ry.v * mult);
}
}
if (animatorProps.rx.propType) {
if (mult.length) {
matrixHelper.rotateX(animatorProps.rx.v * mult[0]);
} else {
matrixHelper.rotateX(animatorProps.rx.v * mult);
}
}
if (animatorProps.o.propType) {
if (mult.length) {
elemOpacity += (animatorProps.o.v * mult[0] - elemOpacity) * mult[0];
} else {
elemOpacity += (animatorProps.o.v * mult - elemOpacity) * mult;
}
}
if (documentData.strokeWidthAnim && animatorProps.sw.propType) {
if (mult.length) {
sw += animatorProps.sw.v * mult[0];
} else {
sw += animatorProps.sw.v * mult;
}
}
if (documentData.strokeColorAnim && animatorProps.sc.propType) {
for (k = 0; k < 3; k += 1) {
if (mult.length) {
sc[k] += (animatorProps.sc.v[k] - sc[k]) * mult[0];
} else {
sc[k] += (animatorProps.sc.v[k] - sc[k]) * mult;
}
}
}
if (documentData.fillColorAnim && documentData.fc) {
if (animatorProps.fc.propType) {
for (k = 0; k < 3; k += 1) {
if (mult.length) {
fc[k] += (animatorProps.fc.v[k] - fc[k]) * mult[0];
} else {
fc[k] += (animatorProps.fc.v[k] - fc[k]) * mult;
}
}
}
if (animatorProps.fh.propType) {
if (mult.length) {
fc = addHueToRGB(fc, animatorProps.fh.v * mult[0]);
} else {
fc = addHueToRGB(fc, animatorProps.fh.v * mult);
}
}
if (animatorProps.fs.propType) {
if (mult.length) {
fc = addSaturationToRGB(fc, animatorProps.fs.v * mult[0]);
} else {
fc = addSaturationToRGB(fc, animatorProps.fs.v * mult);
}
}
if (animatorProps.fb.propType) {
if (mult.length) {
fc = addBrightnessToRGB(fc, animatorProps.fb.v * mult[0]);
} else {
fc = addBrightnessToRGB(fc, animatorProps.fb.v * mult);
}
}
}
}
for (j = 0; j < jLen; j += 1) {
animatorProps = animators[j].a;
if (animatorProps.p.propType) {
animatorSelector = animators[j].s;
mult = animatorSelector.getMult(letters[i].anIndexes[j], textData.a[j].s.totalChars);
if (this._hasMaskedPath) {
if (mult.length) {
matrixHelper.translate(0, animatorProps.p.v[1] * mult[0], -animatorProps.p.v[2] * mult[1]);
} else {
matrixHelper.translate(0, animatorProps.p.v[1] * mult, -animatorProps.p.v[2] * mult);
}
} else if (mult.length) {
matrixHelper.translate(animatorProps.p.v[0] * mult[0], animatorProps.p.v[1] * mult[1], -animatorProps.p.v[2] * mult[2]);
} else {
matrixHelper.translate(animatorProps.p.v[0] * mult, animatorProps.p.v[1] * mult, -animatorProps.p.v[2] * mult);
}
}
}
if (documentData.strokeWidthAnim) {
letterSw = sw < 0 ? 0 : sw;
}
if (documentData.strokeColorAnim) {
letterSc = "rgb(" + Math.round(sc[0] * 255) + "," + Math.round(sc[1] * 255) + "," + Math.round(sc[2] * 255) + ")";
}
if (documentData.fillColorAnim && documentData.fc) {
letterFc = "rgb(" + Math.round(fc[0] * 255) + "," + Math.round(fc[1] * 255) + "," + Math.round(fc[2] * 255) + ")";
}
if (this._hasMaskedPath) {
matrixHelper.translate(0, -documentData.ls);
matrixHelper.translate(0, alignment[1] * yOff * 0.01 + yPos, 0);
if (this._pathData.p.v) {
tanAngle = (currentPoint.point[1] - prevPoint.point[1]) / (currentPoint.point[0] - prevPoint.point[0]);
var rot = Math.atan(tanAngle) * 180 / Math.PI;
if (currentPoint.point[0] < prevPoint.point[0]) {
rot += 180;
}
matrixHelper.rotate(-rot * Math.PI / 180);
}
matrixHelper.translate(xPathPos, yPathPos, 0);
currentLength -= alignment[0] * letters[i].an * 5e-3;
if (letters[i + 1] && ind !== letters[i + 1].ind) {
currentLength += letters[i].an / 2;
currentLength += documentData.tr * 1e-3 * documentData.finalSize;
}
} else {
matrixHelper.translate(xPos, yPos, 0);
if (documentData.ps) {
matrixHelper.translate(documentData.ps[0], documentData.ps[1] + documentData.ascent, 0);
}
switch (documentData.j) {
case 1:
matrixHelper.translate(letters[i].animatorJustifyOffset + documentData.justifyOffset + (documentData.boxWidth - documentData.lineWidths[letters[i].line]), 0, 0);
break;
case 2:
matrixHelper.translate(letters[i].animatorJustifyOffset + documentData.justifyOffset + (documentData.boxWidth - documentData.lineWidths[letters[i].line]) / 2, 0, 0);
break;
default:
break;
}
matrixHelper.translate(0, -documentData.ls);
matrixHelper.translate(offf, 0, 0);
matrixHelper.translate(alignment[0] * letters[i].an * 5e-3, alignment[1] * yOff * 0.01, 0);
xPos += letters[i].l + documentData.tr * 1e-3 * documentData.finalSize;
}
if (renderType === "html") {
letterM = matrixHelper.toCSS();
} else if (renderType === "svg") {
letterM = matrixHelper.to2dCSS();
} else {
letterP = [matrixHelper.props[0], matrixHelper.props[1], matrixHelper.props[2], matrixHelper.props[3], matrixHelper.props[4], matrixHelper.props[5], matrixHelper.props[6], matrixHelper.props[7], matrixHelper.props[8], matrixHelper.props[9], matrixHelper.props[10], matrixHelper.props[11], matrixHelper.props[12], matrixHelper.props[13], matrixHelper.props[14], matrixHelper.props[15]];
}
letterO = elemOpacity;
}
if (renderedLettersCount <= i) {
letterValue = new LetterProps(letterO, letterSw, letterSc, letterFc, letterM, letterP);
this.renderedLetters.push(letterValue);
renderedLettersCount += 1;
this.lettersChangedFlag = true;
} else {
letterValue = this.renderedLetters[i];
this.lettersChangedFlag = letterValue.update(letterO, letterSw, letterSc, letterFc, letterM, letterP) || this.lettersChangedFlag;
}
}
};
TextAnimatorProperty.prototype.getValue = function() {
if (this._elem.globalData.frameId === this._frameId) {
return;
}
this._frameId = this._elem.globalData.frameId;
this.iterateDynamicProperties();
};
TextAnimatorProperty.prototype.mHelper = new Matrix();
TextAnimatorProperty.prototype.defaultPropsArray = [];
extendPrototype([DynamicPropertyContainer], TextAnimatorProperty);
function ITextElement() {
}
ITextElement.prototype.initElement = function(data2, globalData2, comp2) {
this.lettersChangedFlag = true;
this.initFrame();
this.initBaseData(data2, globalData2, comp2);
this.textProperty = new TextProperty(this, data2.t, this.dynamicProperties);
this.textAnimator = new TextAnimatorProperty(data2.t, this.renderType, this);
this.initTransform(data2, globalData2, comp2);
this.initHierarchy();
this.initRenderable();
this.initRendererElement();
this.createContainerElements();
this.createRenderableComponents();
this.createContent();
this.hide();
this.textAnimator.searchProperties(this.dynamicProperties);
};
ITextElement.prototype.prepareFrame = function(num) {
this._mdf = false;
this.prepareRenderableFrame(num);
this.prepareProperties(num, this.isInRange);
};
ITextElement.prototype.createPathShape = function(matrixHelper, shapes) {
var j;
var jLen = shapes.length;
var pathNodes;
var shapeStr = "";
for (j = 0; j < jLen; j += 1) {
if (shapes[j].ty === "sh") {
pathNodes = shapes[j].ks.k;
shapeStr += buildShapeString(pathNodes, pathNodes.i.length, true, matrixHelper);
}
}
return shapeStr;
};
ITextElement.prototype.updateDocumentData = function(newData, index2) {
this.textProperty.updateDocumentData(newData, index2);
};
ITextElement.prototype.canResizeFont = function(_canResize) {
this.textProperty.canResizeFont(_canResize);
};
ITextElement.prototype.setMinimumFontSize = function(_fontSize) {
this.textProperty.setMinimumFontSize(_fontSize);
};
ITextElement.prototype.applyTextPropertiesToMatrix = function(documentData, matrixHelper, lineNumber, xPos, yPos) {
if (documentData.ps) {
matrixHelper.translate(documentData.ps[0], documentData.ps[1] + documentData.ascent, 0);
}
matrixHelper.translate(0, -documentData.ls, 0);
switch (documentData.j) {
case 1:
matrixHelper.translate(documentData.justifyOffset + (documentData.boxWidth - documentData.lineWidths[lineNumber]), 0, 0);
break;
case 2:
matrixHelper.translate(documentData.justifyOffset + (documentData.boxWidth - documentData.lineWidths[lineNumber]) / 2, 0, 0);
break;
default:
break;
}
matrixHelper.translate(xPos, yPos, 0);
};
ITextElement.prototype.buildColor = function(colorData) {
return "rgb(" + Math.round(colorData[0] * 255) + "," + Math.round(colorData[1] * 255) + "," + Math.round(colorData[2] * 255) + ")";
};
ITextElement.prototype.emptyProp = new LetterProps();
ITextElement.prototype.destroy = function() {
};
ITextElement.prototype.validateText = function() {
if (this.textProperty._mdf || this.textProperty._isFirstFrame) {
this.buildNewText();
this.textProperty._isFirstFrame = false;
this.textProperty._mdf = false;
}
};
var emptyShapeData = {
shapes: []
};
function SVGTextLottieElement(data2, globalData2, comp2) {
this.textSpans = [];
this.renderType = "svg";
this.initElement(data2, globalData2, comp2);
}
extendPrototype([BaseElement, TransformElement, SVGBaseElement, HierarchyElement, FrameElement, RenderableDOMElement, ITextElement], SVGTextLottieElement);
SVGTextLottieElement.prototype.createContent = function() {
if (this.data.singleShape && !this.globalData.fontManager.chars) {
this.textContainer = createNS("text");
}
};
SVGTextLottieElement.prototype.buildTextContents = function(textArray) {
var i = 0;
var len = textArray.length;
var textContents = [];
var currentTextContent = "";
while (i < len) {
if (textArray[i] === String.fromCharCode(13) || textArray[i] === String.fromCharCode(3)) {
textContents.push(currentTextContent);
currentTextContent = "";
} else {
currentTextContent += textArray[i];
}
i += 1;
}
textContents.push(currentTextContent);
return textContents;
};
SVGTextLottieElement.prototype.buildShapeData = function(data2, scale2) {
if (data2.shapes && data2.shapes.length) {
var shape = data2.shapes[0];
if (shape.it) {
var shapeItem = shape.it[shape.it.length - 1];
if (shapeItem.s) {
shapeItem.s.k[0] = scale2;
shapeItem.s.k[1] = scale2;
}
}
}
return data2;
};
SVGTextLottieElement.prototype.buildNewText = function() {
this.addDynamicProperty(this);
var i;
var len;
var documentData = this.textProperty.currentData;
this.renderedLetters = createSizedArray(documentData ? documentData.l.length : 0);
if (documentData.fc) {
this.layerElement.setAttribute("fill", this.buildColor(documentData.fc));
} else {
this.layerElement.setAttribute("fill", "rgba(0,0,0,0)");
}
if (documentData.sc) {
this.layerElement.setAttribute("stroke", this.buildColor(documentData.sc));
this.layerElement.setAttribute("stroke-width", documentData.sw);
}
this.layerElement.setAttribute("font-size", documentData.finalSize);
var fontData = this.globalData.fontManager.getFontByName(documentData.f);
if (fontData.fClass) {
this.layerElement.setAttribute("class", fontData.fClass);
} else {
this.layerElement.setAttribute("font-family", fontData.fFamily);
var fWeight = documentData.fWeight;
var fStyle = documentData.fStyle;
this.layerElement.setAttribute("font-style", fStyle);
this.layerElement.setAttribute("font-weight", fWeight);
}
this.layerElement.setAttribute("aria-label", documentData.t);
var letters = documentData.l || [];
var usesGlyphs = !!this.globalData.fontManager.chars;
len = letters.length;
var tSpan;
var matrixHelper = this.mHelper;
var shapeStr = "";
var singleShape = this.data.singleShape;
var xPos = 0;
var yPos = 0;
var firstLine = true;
var trackingOffset = documentData.tr * 1e-3 * documentData.finalSize;
if (singleShape && !usesGlyphs && !documentData.sz) {
var tElement = this.textContainer;
var justify = "start";
switch (documentData.j) {
case 1:
justify = "end";
break;
case 2:
justify = "middle";
break;
default:
justify = "start";
break;
}
tElement.setAttribute("text-anchor", justify);
tElement.setAttribute("letter-spacing", trackingOffset);
var textContent = this.buildTextContents(documentData.finalText);
len = textContent.length;
yPos = documentData.ps ? documentData.ps[1] + documentData.ascent : 0;
for (i = 0; i < len; i += 1) {
tSpan = this.textSpans[i].span || createNS("tspan");
tSpan.textContent = textContent[i];
tSpan.setAttribute("x", 0);
tSpan.setAttribute("y", yPos);
tSpan.style.display = "inherit";
tElement.appendChild(tSpan);
if (!this.textSpans[i]) {
this.textSpans[i] = {
span: null,
glyph: null
};
}
this.textSpans[i].span = tSpan;
yPos += documentData.finalLineHeight;
}
this.layerElement.appendChild(tElement);
} else {
var cachedSpansLength = this.textSpans.length;
var charData;
for (i = 0; i < len; i += 1) {
if (!this.textSpans[i]) {
this.textSpans[i] = {
span: null,
childSpan: null,
glyph: null
};
}
if (!usesGlyphs || !singleShape || i === 0) {
tSpan = cachedSpansLength > i ? this.textSpans[i].span : createNS(usesGlyphs ? "g" : "text");
if (cachedSpansLength <= i) {
tSpan.setAttribute("stroke-linecap", "butt");
tSpan.setAttribute("stroke-linejoin", "round");
tSpan.setAttribute("stroke-miterlimit", "4");
this.textSpans[i].span = tSpan;
if (usesGlyphs) {
var childSpan = createNS("g");
tSpan.appendChild(childSpan);
this.textSpans[i].childSpan = childSpan;
}
this.textSpans[i].span = tSpan;
this.layerElement.appendChild(tSpan);
}
tSpan.style.display = "inherit";
}
matrixHelper.reset();
if (singleShape) {
if (letters[i].n) {
xPos = -trackingOffset;
yPos += documentData.yOffset;
yPos += firstLine ? 1 : 0;
firstLine = false;
}
this.applyTextPropertiesToMatrix(documentData, matrixHelper, letters[i].line, xPos, yPos);
xPos += letters[i].l || 0;
xPos += trackingOffset;
}
if (usesGlyphs) {
charData = this.globalData.fontManager.getCharData(documentData.finalText[i], fontData.fStyle, this.globalData.fontManager.getFontByName(documentData.f).fFamily);
var glyphElement;
if (charData.t === 1) {
glyphElement = new SVGCompElement(charData.data, this.globalData, this);
} else {
var data2 = emptyShapeData;
if (charData.data && charData.data.shapes) {
data2 = this.buildShapeData(charData.data, documentData.finalSize);
}
glyphElement = new SVGShapeElement(data2, this.globalData, this);
}
if (this.textSpans[i].glyph) {
var glyph = this.textSpans[i].glyph;
this.textSpans[i].childSpan.removeChild(glyph.layerElement);
glyph.destroy();
}
this.textSpans[i].glyph = glyphElement;
glyphElement._debug = true;
glyphElement.prepareFrame(0);
glyphElement.renderFrame();
this.textSpans[i].childSpan.appendChild(glyphElement.layerElement);
if (charData.t === 1) {
this.textSpans[i].childSpan.setAttribute("transform", "scale(" + documentData.finalSize / 100 + "," + documentData.finalSize / 100 + ")");
}
} else {
if (singleShape) {
tSpan.setAttribute("transform", "translate(" + matrixHelper.props[12] + "," + matrixHelper.props[13] + ")");
}
tSpan.textContent = letters[i].val;
tSpan.setAttributeNS("http://www.w3.org/XML/1998/namespace", "xml:space", "preserve");
}
}
if (singleShape && tSpan) {
tSpan.setAttribute("d", shapeStr);
}
}
while (i < this.textSpans.length) {
this.textSpans[i].span.style.display = "none";
i += 1;
}
this._sizeChanged = true;
};
SVGTextLottieElement.prototype.sourceRectAtTime = function() {
this.prepareFrame(this.comp.renderedFrame - this.data.st);
this.renderInnerContent();
if (this._sizeChanged) {
this._sizeChanged = false;
var textBox = this.layerElement.getBBox();
this.bbox = {
top: textBox.y,
left: textBox.x,
width: textBox.width,
height: textBox.height
};
}
return this.bbox;
};
SVGTextLottieElement.prototype.getValue = function() {
var i;
var len = this.textSpans.length;
var glyphElement;
this.renderedFrame = this.comp.renderedFrame;
for (i = 0; i < len; i += 1) {
glyphElement = this.textSpans[i].glyph;
if (glyphElement) {
glyphElement.prepareFrame(this.comp.renderedFrame - this.data.st);
if (glyphElement._mdf) {
this._mdf = true;
}
}
}
};
SVGTextLottieElement.prototype.renderInnerContent = function() {
this.validateText();
if (!this.data.singleShape || this._mdf) {
this.textAnimator.getMeasures(this.textProperty.currentData, this.lettersChangedFlag);
if (this.lettersChangedFlag || this.textAnimator.lettersChangedFlag) {
this._sizeChanged = true;
var i;
var len;
var renderedLetters = this.textAnimator.renderedLetters;
var letters = this.textProperty.currentData.l;
len = letters.length;
var renderedLetter;
var textSpan;
var glyphElement;
for (i = 0; i < len; i += 1) {
if (!letters[i].n) {
renderedLetter = renderedLetters[i];
textSpan = this.textSpans[i].span;
glyphElement = this.textSpans[i].glyph;
if (glyphElement) {
glyphElement.renderFrame();
}
if (renderedLetter._mdf.m) {
textSpan.setAttribute("transform", renderedLetter.m);
}
if (renderedLetter._mdf.o) {
textSpan.setAttribute("opacity", renderedLetter.o);
}
if (renderedLetter._mdf.sw) {
textSpan.setAttribute("stroke-width", renderedLetter.sw);
}
if (renderedLetter._mdf.sc) {
textSpan.setAttribute("stroke", renderedLetter.sc);
}
if (renderedLetter._mdf.fc) {
textSpan.setAttribute("fill", renderedLetter.fc);
}
}
}
}
}
};
function ISolidElement(data2, globalData2, comp2) {
this.initElement(data2, globalData2, comp2);
}
extendPrototype([IImageElement], ISolidElement);
ISolidElement.prototype.createContent = function() {
var rect = createNS("rect");
rect.setAttribute("width", this.data.sw);
rect.setAttribute("height", this.data.sh);
rect.setAttribute("fill", this.data.sc);
this.layerElement.appendChild(rect);
};
function NullElement(data2, globalData2, comp2) {
this.initFrame();
this.initBaseData(data2, globalData2, comp2);
this.initFrame();
this.initTransform(data2, globalData2, comp2);
this.initHierarchy();
}
NullElement.prototype.prepareFrame = function(num) {
this.prepareProperties(num, true);
};
NullElement.prototype.renderFrame = function() {
};
NullElement.prototype.getBaseElement = function() {
return null;
};
NullElement.prototype.destroy = function() {
};
NullElement.prototype.sourceRectAtTime = function() {
};
NullElement.prototype.hide = function() {
};
extendPrototype([BaseElement, TransformElement, HierarchyElement, FrameElement], NullElement);
function SVGRendererBase() {
}
extendPrototype([BaseRenderer], SVGRendererBase);
SVGRendererBase.prototype.createNull = function(data2) {
return new NullElement(data2, this.globalData, this);
};
SVGRendererBase.prototype.createShape = function(data2) {
return new SVGShapeElement(data2, this.globalData, this);
};
SVGRendererBase.prototype.createText = function(data2) {
return new SVGTextLottieElement(data2, this.globalData, this);
};
SVGRendererBase.prototype.createImage = function(data2) {
return new IImageElement(data2, this.globalData, this);
};
SVGRendererBase.prototype.createSolid = function(data2) {
return new ISolidElement(data2, this.globalData, this);
};
SVGRendererBase.prototype.configAnimation = function(animData) {
this.svgElement.setAttribute("xmlns", "http://www.w3.org/2000/svg");
this.svgElement.setAttribute("xmlns:xlink", "http://www.w3.org/1999/xlink");
if (this.renderConfig.viewBoxSize) {
this.svgElement.setAttribute("viewBox", this.renderConfig.viewBoxSize);
} else {
this.svgElement.setAttribute("viewBox", "0 0 " + animData.w + " " + animData.h);
}
if (!this.renderConfig.viewBoxOnly) {
this.svgElement.setAttribute("width", animData.w);
this.svgElement.setAttribute("height", animData.h);
this.svgElement.style.width = "100%";
this.svgElement.style.height = "100%";
this.svgElement.style.transform = "translate3d(0,0,0)";
this.svgElement.style.contentVisibility = this.renderConfig.contentVisibility;
}
if (this.renderConfig.width) {
this.svgElement.setAttribute("width", this.renderConfig.width);
}
if (this.renderConfig.height) {
this.svgElement.setAttribute("height", this.renderConfig.height);
}
if (this.renderConfig.className) {
this.svgElement.setAttribute("class", this.renderConfig.className);
}
if (this.renderConfig.id) {
this.svgElement.setAttribute("id", this.renderConfig.id);
}
if (this.renderConfig.focusable !== void 0) {
this.svgElement.setAttribute("focusable", this.renderConfig.focusable);
}
this.svgElement.setAttribute("preserveAspectRatio", this.renderConfig.preserveAspectRatio);
this.animationItem.wrapper.appendChild(this.svgElement);
var defs = this.globalData.defs;
this.setupGlobalData(animData, defs);
this.globalData.progressiveLoad = this.renderConfig.progressiveLoad;
this.data = animData;
var maskElement = createNS("clipPath");
var rect = createNS("rect");
rect.setAttribute("width", animData.w);
rect.setAttribute("height", animData.h);
rect.setAttribute("x", 0);
rect.setAttribute("y", 0);
var maskId = createElementID();
maskElement.setAttribute("id", maskId);
maskElement.appendChild(rect);
this.layerElement.setAttribute("clip-path", "url(" + getLocationHref() + "#" + maskId + ")");
defs.appendChild(maskElement);
this.layers = animData.layers;
this.elements = createSizedArray(animData.layers.length);
};
SVGRendererBase.prototype.destroy = function() {
if (this.animationItem.wrapper) {
this.animationItem.wrapper.innerText = "";
}
this.layerElement = null;
this.globalData.defs = null;
var i;
var len = this.layers ? this.layers.length : 0;
for (i = 0; i < len; i += 1) {
if (this.elements[i] && this.elements[i].destroy) {
this.elements[i].destroy();
}
}
this.elements.length = 0;
this.destroyed = true;
this.animationItem = null;
};
SVGRendererBase.prototype.updateContainerSize = function() {
};
SVGRendererBase.prototype.findIndexByInd = function(ind) {
var i = 0;
var len = this.layers.length;
for (i = 0; i < len; i += 1) {
if (this.layers[i].ind === ind) {
return i;
}
}
return -1;
};
SVGRendererBase.prototype.buildItem = function(pos) {
var elements = this.elements;
if (elements[pos] || this.layers[pos].ty === 99) {
return;
}
elements[pos] = true;
var element = this.createItem(this.layers[pos]);
elements[pos] = element;
if (getExpressionsPlugin()) {
if (this.layers[pos].ty === 0) {
this.globalData.projectInterface.registerComposition(element);
}
element.initExpressions();
}
this.appendElementInPos(element, pos);
if (this.layers[pos].tt) {
var elementIndex = "tp" in this.layers[pos] ? this.findIndexByInd(this.layers[pos].tp) : pos - 1;
if (elementIndex === -1) {
return;
}
if (!this.elements[elementIndex] || this.elements[elementIndex] === true) {
this.buildItem(elementIndex);
this.addPendingElement(element);
} else {
var matteElement = elements[elementIndex];
var matteMask = matteElement.getMatte(this.layers[pos].tt);
element.setMatte(matteMask);
}
}
};
SVGRendererBase.prototype.checkPendingElements = function() {
while (this.pendingElements.length) {
var element = this.pendingElements.pop();
element.checkParenting();
if (element.data.tt) {
var i = 0;
var len = this.elements.length;
while (i < len) {
if (this.elements[i] === element) {
var elementIndex = "tp" in element.data ? this.findIndexByInd(element.data.tp) : i - 1;
var matteElement = this.elements[elementIndex];
var matteMask = matteElement.getMatte(this.layers[i].tt);
element.setMatte(matteMask);
break;
}
i += 1;
}
}
}
};
SVGRendererBase.prototype.renderFrame = function(num) {
if (this.renderedFrame === num || this.destroyed) {
return;
}
if (num === null) {
num = this.renderedFrame;
} else {
this.renderedFrame = num;
}
this.globalData.frameNum = num;
this.globalData.frameId += 1;
this.globalData.projectInterface.currentFrame = num;
this.globalData._mdf = false;
var i;
var len = this.layers.length;
if (!this.completeLayers) {
this.checkLayers(num);
}
for (i = len - 1; i >= 0; i -= 1) {
if (this.completeLayers || this.elements[i]) {
this.elements[i].prepareFrame(num - this.layers[i].st);
}
}
if (this.globalData._mdf) {
for (i = 0; i < len; i += 1) {
if (this.completeLayers || this.elements[i]) {
this.elements[i].renderFrame();
}
}
}
};
SVGRendererBase.prototype.appendElementInPos = function(element, pos) {
var newElement = element.getBaseElement();
if (!newElement) {
return;
}
var i = 0;
var nextElement;
while (i < pos) {
if (this.elements[i] && this.elements[i] !== true && this.elements[i].getBaseElement()) {
nextElement = this.elements[i].getBaseElement();
}
i += 1;
}
if (nextElement) {
this.layerElement.insertBefore(newElement, nextElement);
} else {
this.layerElement.appendChild(newElement);
}
};
SVGRendererBase.prototype.hide = function() {
this.layerElement.style.display = "none";
};
SVGRendererBase.prototype.show = function() {
this.layerElement.style.display = "block";
};
function ICompElement() {
}
extendPrototype([BaseElement, TransformElement, HierarchyElement, FrameElement, RenderableDOMElement], ICompElement);
ICompElement.prototype.initElement = function(data2, globalData2, comp2) {
this.initFrame();
this.initBaseData(data2, globalData2, comp2);
this.initTransform(data2, globalData2, comp2);
this.initRenderable();
this.initHierarchy();
this.initRendererElement();
this.createContainerElements();
this.createRenderableComponents();
if (this.data.xt || !globalData2.progressiveLoad) {
this.buildAllItems();
}
this.hide();
};
ICompElement.prototype.prepareFrame = function(num) {
this._mdf = false;
this.prepareRenderableFrame(num);
this.prepareProperties(num, this.isInRange);
if (!this.isInRange && !this.data.xt) {
return;
}
if (!this.tm._placeholder) {
var timeRemapped = this.tm.v;
if (timeRemapped === this.data.op) {
timeRemapped = this.data.op - 1;
}
this.renderedFrame = timeRemapped;
} else {
this.renderedFrame = num / this.data.sr;
}
var i;
var len = this.elements.length;
if (!this.completeLayers) {
this.checkLayers(this.renderedFrame);
}
for (i = len - 1; i >= 0; i -= 1) {
if (this.completeLayers || this.elements[i]) {
this.elements[i].prepareFrame(this.renderedFrame - this.layers[i].st);
if (this.elements[i]._mdf) {
this._mdf = true;
}
}
}
};
ICompElement.prototype.renderInnerContent = function() {
var i;
var len = this.layers.length;
for (i = 0; i < len; i += 1) {
if (this.completeLayers || this.elements[i]) {
this.elements[i].renderFrame();
}
}
};
ICompElement.prototype.setElements = function(elems) {
this.elements = elems;
};
ICompElement.prototype.getElements = function() {
return this.elements;
};
ICompElement.prototype.destroyElements = function() {
var i;
var len = this.layers.length;
for (i = 0; i < len; i += 1) {
if (this.elements[i]) {
this.elements[i].destroy();
}
}
};
ICompElement.prototype.destroy = function() {
this.destroyElements();
this.destroyBaseElement();
};
function SVGCompElement(data2, globalData2, comp2) {
this.layers = data2.layers;
this.supports3d = true;
this.completeLayers = false;
this.pendingElements = [];
this.elements = this.layers ? createSizedArray(this.layers.length) : [];
this.initElement(data2, globalData2, comp2);
this.tm = data2.tm ? PropertyFactory.getProp(this, data2.tm, 0, globalData2.frameRate, this) : {
_placeholder: true
};
}
extendPrototype([SVGRendererBase, ICompElement, SVGBaseElement], SVGCompElement);
SVGCompElement.prototype.createComp = function(data2) {
return new SVGCompElement(data2, this.globalData, this);
};
function SVGRenderer(animationItem, config2) {
this.animationItem = animationItem;
this.layers = null;
this.renderedFrame = -1;
this.svgElement = createNS("svg");
var ariaLabel = "";
if (config2 && config2.title) {
var titleElement = createNS("title");
var titleId = createElementID();
titleElement.setAttribute("id", titleId);
titleElement.textContent = config2.title;
this.svgElement.appendChild(titleElement);
ariaLabel += titleId;
}
if (config2 && config2.description) {
var descElement = createNS("desc");
var descId = createElementID();
descElement.setAttribute("id", descId);
descElement.textContent = config2.description;
this.svgElement.appendChild(descElement);
ariaLabel += " " + descId;
}
if (ariaLabel) {
this.svgElement.setAttribute("aria-labelledby", ariaLabel);
}
var defs = createNS("defs");
this.svgElement.appendChild(defs);
var maskElement = createNS("g");
this.svgElement.appendChild(maskElement);
this.layerElement = maskElement;
this.renderConfig = {
preserveAspectRatio: config2 && config2.preserveAspectRatio || "xMidYMid meet",
imagePreserveAspectRatio: config2 && config2.imagePreserveAspectRatio || "xMidYMid slice",
contentVisibility: config2 && config2.contentVisibility || "visible",
progressiveLoad: config2 && config2.progressiveLoad || false,
hideOnTransparent: !(config2 && config2.hideOnTransparent === false),
viewBoxOnly: config2 && config2.viewBoxOnly || false,
viewBoxSize: config2 && config2.viewBoxSize || false,
className: config2 && config2.className || "",
id: config2 && config2.id || "",
focusable: config2 && config2.focusable,
filterSize: {
width: config2 && config2.filterSize && config2.filterSize.width || "100%",
height: config2 && config2.filterSize && config2.filterSize.height || "100%",
x: config2 && config2.filterSize && config2.filterSize.x || "0%",
y: config2 && config2.filterSize && config2.filterSize.y || "0%"
},
width: config2 && config2.width,
height: config2 && config2.height,
runExpressions: !config2 || config2.runExpressions === void 0 || config2.runExpressions
};
this.globalData = {
_mdf: false,
frameNum: -1,
defs,
renderConfig: this.renderConfig
};
this.elements = [];
this.pendingElements = [];
this.destroyed = false;
this.rendererType = "svg";
}
extendPrototype([SVGRendererBase], SVGRenderer);
SVGRenderer.prototype.createComp = function(data2) {
return new SVGCompElement(data2, this.globalData, this);
};
function ShapeTransformManager() {
this.sequences = {};
this.sequenceList = [];
this.transform_key_count = 0;
}
ShapeTransformManager.prototype = {
addTransformSequence: function addTransformSequence(transforms) {
var i;
var len = transforms.length;
var key2 = "_";
for (i = 0; i < len; i += 1) {
key2 += transforms[i].transform.key + "_";
}
var sequence = this.sequences[key2];
if (!sequence) {
sequence = {
transforms: [].concat(transforms),
finalTransform: new Matrix(),
_mdf: false
};
this.sequences[key2] = sequence;
this.sequenceList.push(sequence);
}
return sequence;
},
processSequence: function processSequence(sequence, isFirstFrame) {
var i = 0;
var len = sequence.transforms.length;
var _mdf = isFirstFrame;
while (i < len && !isFirstFrame) {
if (sequence.transforms[i].transform.mProps._mdf) {
_mdf = true;
break;
}
i += 1;
}
if (_mdf) {
sequence.finalTransform.reset();
for (i = len - 1; i >= 0; i -= 1) {
sequence.finalTransform.multiply(sequence.transforms[i].transform.mProps.v);
}
}
sequence._mdf = _mdf;
},
processSequences: function processSequences(isFirstFrame) {
var i;
var len = this.sequenceList.length;
for (i = 0; i < len; i += 1) {
this.processSequence(this.sequenceList[i], isFirstFrame);
}
},
getNewKey: function getNewKey() {
this.transform_key_count += 1;
return "_" + this.transform_key_count;
}
};
var lumaLoader = function lumaLoader2() {
var id = "__lottie_element_luma_buffer";
var lumaBuffer = null;
var lumaBufferCtx = null;
var svg = null;
function createLumaSvgFilter() {
var _svg = createNS("svg");
var fil = createNS("filter");
var matrix = createNS("feColorMatrix");
fil.setAttribute("id", id);
matrix.setAttribute("type", "matrix");
matrix.setAttribute("color-interpolation-filters", "sRGB");
matrix.setAttribute("values", "0.3, 0.3, 0.3, 0, 0, 0.3, 0.3, 0.3, 0, 0, 0.3, 0.3, 0.3, 0, 0, 0.3, 0.3, 0.3, 0, 0");
fil.appendChild(matrix);
_svg.appendChild(fil);
_svg.setAttribute("id", id + "_svg");
if (featureSupport.svgLumaHidden) {
_svg.style.display = "none";
}
return _svg;
}
function loadLuma() {
if (!lumaBuffer) {
svg = createLumaSvgFilter();
document.body.appendChild(svg);
lumaBuffer = createTag("canvas");
lumaBufferCtx = lumaBuffer.getContext("2d");
lumaBufferCtx.filter = "url(#" + id + ")";
lumaBufferCtx.fillStyle = "rgba(0,0,0,0)";
lumaBufferCtx.fillRect(0, 0, 1, 1);
}
}
function getLuma(canvas) {
if (!lumaBuffer) {
loadLuma();
}
lumaBuffer.width = canvas.width;
lumaBuffer.height = canvas.height;
lumaBufferCtx.filter = "url(#" + id + ")";
return lumaBuffer;
}
return {
load: loadLuma,
get: getLuma
};
};
function createCanvas(width2, height2) {
if (featureSupport.offscreenCanvas) {
return new OffscreenCanvas(width2, height2);
}
var canvas = createTag("canvas");
canvas.width = width2;
canvas.height = height2;
return canvas;
}
var assetLoader = function() {
return {
loadLumaCanvas: lumaLoader.load,
getLumaCanvas: lumaLoader.get,
createCanvas
};
}();
var registeredEffects = {};
function CVEffects(elem2) {
var i;
var len = elem2.data.ef ? elem2.data.ef.length : 0;
this.filters = [];
var filterManager;
for (i = 0; i < len; i += 1) {
filterManager = null;
var type = elem2.data.ef[i].ty;
if (registeredEffects[type]) {
var Effect = registeredEffects[type].effect;
filterManager = new Effect(elem2.effectsManager.effectElements[i], elem2);
}
if (filterManager) {
this.filters.push(filterManager);
}
}
if (this.filters.length) {
elem2.addRenderableComponent(this);
}
}
CVEffects.prototype.renderFrame = function(_isFirstFrame) {
var i;
var len = this.filters.length;
for (i = 0; i < len; i += 1) {
this.filters[i].renderFrame(_isFirstFrame);
}
};
CVEffects.prototype.getEffects = function(type) {
var i;
var len = this.filters.length;
var effects = [];
for (i = 0; i < len; i += 1) {
if (this.filters[i].type === type) {
effects.push(this.filters[i]);
}
}
return effects;
};
function registerEffect(id, effect3) {
registeredEffects[id] = {
effect: effect3
};
}
function CVMaskElement(data2, element) {
this.data = data2;
this.element = element;
this.masksProperties = this.data.masksProperties || [];
this.viewData = createSizedArray(this.masksProperties.length);
var i;
var len = this.masksProperties.length;
var hasMasks = false;
for (i = 0; i < len; i += 1) {
if (this.masksProperties[i].mode !== "n") {
hasMasks = true;
}
this.viewData[i] = ShapePropertyFactory.getShapeProp(this.element, this.masksProperties[i], 3);
}
this.hasMasks = hasMasks;
if (hasMasks) {
this.element.addRenderableComponent(this);
}
}
CVMaskElement.prototype.renderFrame = function() {
if (!this.hasMasks) {
return;
}
var transform2 = this.element.finalTransform.mat;
var ctx = this.element.canvasContext;
var i;
var len = this.masksProperties.length;
var pt;
var pts;
var data2;
ctx.beginPath();
for (i = 0; i < len; i += 1) {
if (this.masksProperties[i].mode !== "n") {
if (this.masksProperties[i].inv) {
ctx.moveTo(0, 0);
ctx.lineTo(this.element.globalData.compSize.w, 0);
ctx.lineTo(this.element.globalData.compSize.w, this.element.globalData.compSize.h);
ctx.lineTo(0, this.element.globalData.compSize.h);
ctx.lineTo(0, 0);
}
data2 = this.viewData[i].v;
pt = transform2.applyToPointArray(data2.v[0][0], data2.v[0][1], 0);
ctx.moveTo(pt[0], pt[1]);
var j;
var jLen = data2._length;
for (j = 1; j < jLen; j += 1) {
pts = transform2.applyToTriplePoints(data2.o[j - 1], data2.i[j], data2.v[j]);
ctx.bezierCurveTo(pts[0], pts[1], pts[2], pts[3], pts[4], pts[5]);
}
pts = transform2.applyToTriplePoints(data2.o[j - 1], data2.i[0], data2.v[0]);
ctx.bezierCurveTo(pts[0], pts[1], pts[2], pts[3], pts[4], pts[5]);
}
}
this.element.globalData.renderer.save(true);
ctx.clip();
};
CVMaskElement.prototype.getMaskProperty = MaskElement.prototype.getMaskProperty;
CVMaskElement.prototype.destroy = function() {
this.element = null;
};
function CVBaseElement() {
}
var operationsMap = {
1: "source-in",
2: "source-out",
3: "source-in",
4: "source-out"
};
CVBaseElement.prototype = {
createElements: function createElements() {
},
initRendererElement: function initRendererElement() {
},
createContainerElements: function createContainerElements() {
if (this.data.tt >= 1) {
this.buffers = [];
var canvasContext = this.globalData.canvasContext;
var bufferCanvas = assetLoader.createCanvas(canvasContext.canvas.width, canvasContext.canvas.height);
this.buffers.push(bufferCanvas);
var bufferCanvas2 = assetLoader.createCanvas(canvasContext.canvas.width, canvasContext.canvas.height);
this.buffers.push(bufferCanvas2);
if (this.data.tt >= 3 && !document._isProxy) {
assetLoader.loadLumaCanvas();
}
}
this.canvasContext = this.globalData.canvasContext;
this.transformCanvas = this.globalData.transformCanvas;
this.renderableEffectsManager = new CVEffects(this);
this.searchEffectTransforms();
},
createContent: function createContent() {
},
setBlendMode: function setBlendMode() {
var globalData2 = this.globalData;
if (globalData2.blendMode !== this.data.bm) {
globalData2.blendMode = this.data.bm;
var blendModeValue = getBlendMode(this.data.bm);
globalData2.canvasContext.globalCompositeOperation = blendModeValue;
}
},
createRenderableComponents: function createRenderableComponents() {
this.maskManager = new CVMaskElement(this.data, this);
this.transformEffects = this.renderableEffectsManager.getEffects(effectTypes.TRANSFORM_EFFECT);
},
hideElement: function hideElement() {
if (!this.hidden && (!this.isInRange || this.isTransparent)) {
this.hidden = true;
}
},
showElement: function showElement() {
if (this.isInRange && !this.isTransparent) {
this.hidden = false;
this._isFirstFrame = true;
this.maskManager._isFirstFrame = true;
}
},
clearCanvas: function clearCanvas(canvasContext) {
canvasContext.clearRect(this.transformCanvas.tx, this.transformCanvas.ty, this.transformCanvas.w * this.transformCanvas.sx, this.transformCanvas.h * this.transformCanvas.sy);
},
prepareLayer: function prepareLayer() {
if (this.data.tt >= 1) {
var buffer = this.buffers[0];
var bufferCtx = buffer.getContext("2d");
this.clearCanvas(bufferCtx);
bufferCtx.drawImage(this.canvasContext.canvas, 0, 0);
this.currentTransform = this.canvasContext.getTransform();
this.canvasContext.setTransform(1, 0, 0, 1, 0, 0);
this.clearCanvas(this.canvasContext);
this.canvasContext.setTransform(this.currentTransform);
}
},
exitLayer: function exitLayer() {
if (this.data.tt >= 1) {
var buffer = this.buffers[1];
var bufferCtx = buffer.getContext("2d");
this.clearCanvas(bufferCtx);
bufferCtx.drawImage(this.canvasContext.canvas, 0, 0);
this.canvasContext.setTransform(1, 0, 0, 1, 0, 0);
this.clearCanvas(this.canvasContext);
this.canvasContext.setTransform(this.currentTransform);
var mask2 = this.comp.getElementById("tp" in this.data ? this.data.tp : this.data.ind - 1);
mask2.renderFrame(true);
this.canvasContext.setTransform(1, 0, 0, 1, 0, 0);
if (this.data.tt >= 3 && !document._isProxy) {
var lumaBuffer = assetLoader.getLumaCanvas(this.canvasContext.canvas);
var lumaBufferCtx = lumaBuffer.getContext("2d");
lumaBufferCtx.drawImage(this.canvasContext.canvas, 0, 0);
this.clearCanvas(this.canvasContext);
this.canvasContext.drawImage(lumaBuffer, 0, 0);
}
this.canvasContext.globalCompositeOperation = operationsMap[this.data.tt];
this.canvasContext.drawImage(buffer, 0, 0);
this.canvasContext.globalCompositeOperation = "destination-over";
this.canvasContext.drawImage(this.buffers[0], 0, 0);
this.canvasContext.setTransform(this.currentTransform);
this.canvasContext.globalCompositeOperation = "source-over";
}
},
renderFrame: function renderFrame(forceRender) {
if (this.hidden || this.data.hd) {
return;
}
if (this.data.td === 1 && !forceRender) {
return;
}
this.renderTransform();
this.renderRenderable();
this.renderLocalTransform();
this.setBlendMode();
var forceRealStack = this.data.ty === 0;
this.prepareLayer();
this.globalData.renderer.save(forceRealStack);
this.globalData.renderer.ctxTransform(this.finalTransform.localMat.props);
this.globalData.renderer.ctxOpacity(this.finalTransform.localOpacity);
this.renderInnerContent();
this.globalData.renderer.restore(forceRealStack);
this.exitLayer();
if (this.maskManager.hasMasks) {
this.globalData.renderer.restore(true);
}
if (this._isFirstFrame) {
this._isFirstFrame = false;
}
},
destroy: function destroy() {
this.canvasContext = null;
this.data = null;
this.globalData = null;
this.maskManager.destroy();
},
mHelper: new Matrix()
};
CVBaseElement.prototype.hide = CVBaseElement.prototype.hideElement;
CVBaseElement.prototype.show = CVBaseElement.prototype.showElement;
function CVShapeData(element, data2, styles, transformsManager) {
this.styledShapes = [];
this.tr = [0, 0, 0, 0, 0, 0];
var ty = 4;
if (data2.ty === "rc") {
ty = 5;
} else if (data2.ty === "el") {
ty = 6;
} else if (data2.ty === "sr") {
ty = 7;
}
this.sh = ShapePropertyFactory.getShapeProp(element, data2, ty, element);
var i;
var len = styles.length;
var styledShape;
for (i = 0; i < len; i += 1) {
if (!styles[i].closed) {
styledShape = {
transforms: transformsManager.addTransformSequence(styles[i].transforms),
trNodes: []
};
this.styledShapes.push(styledShape);
styles[i].elements.push(styledShape);
}
}
}
CVShapeData.prototype.setAsAnimated = SVGShapeData.prototype.setAsAnimated;
function CVShapeElement(data2, globalData2, comp2) {
this.shapes = [];
this.shapesData = data2.shapes;
this.stylesList = [];
this.itemsData = [];
this.prevViewData = [];
this.shapeModifiers = [];
this.processedElements = [];
this.transformsManager = new ShapeTransformManager();
this.initElement(data2, globalData2, comp2);
}
extendPrototype([BaseElement, TransformElement, CVBaseElement, IShapeElement, HierarchyElement, FrameElement, RenderableElement], CVShapeElement);
CVShapeElement.prototype.initElement = RenderableDOMElement.prototype.initElement;
CVShapeElement.prototype.transformHelper = {
opacity: 1,
_opMdf: false
};
CVShapeElement.prototype.dashResetter = [];
CVShapeElement.prototype.createContent = function() {
this.searchShapes(this.shapesData, this.itemsData, this.prevViewData, true, []);
};
CVShapeElement.prototype.createStyleElement = function(data2, transforms) {
var styleElem = {
data: data2,
type: data2.ty,
preTransforms: this.transformsManager.addTransformSequence(transforms),
transforms: [],
elements: [],
closed: data2.hd === true
};
var elementData = {};
if (data2.ty === "fl" || data2.ty === "st") {
elementData.c = PropertyFactory.getProp(this, data2.c, 1, 255, this);
if (!elementData.c.k) {
styleElem.co = "rgb(" + bmFloor(elementData.c.v[0]) + "," + bmFloor(elementData.c.v[1]) + "," + bmFloor(elementData.c.v[2]) + ")";
}
} else if (data2.ty === "gf" || data2.ty === "gs") {
elementData.s = PropertyFactory.getProp(this, data2.s, 1, null, this);
elementData.e = PropertyFactory.getProp(this, data2.e, 1, null, this);
elementData.h = PropertyFactory.getProp(this, data2.h || {
k: 0
}, 0, 0.01, this);
elementData.a = PropertyFactory.getProp(this, data2.a || {
k: 0
}, 0, degToRads, this);
elementData.g = new GradientProperty(this, data2.g, this);
}
elementData.o = PropertyFactory.getProp(this, data2.o, 0, 0.01, this);
if (data2.ty === "st" || data2.ty === "gs") {
styleElem.lc = lineCapEnum[data2.lc || 2];
styleElem.lj = lineJoinEnum[data2.lj || 2];
if (data2.lj == 1) {
styleElem.ml = data2.ml;
}
elementData.w = PropertyFactory.getProp(this, data2.w, 0, null, this);
if (!elementData.w.k) {
styleElem.wi = elementData.w.v;
}
if (data2.d) {
var d = new DashProperty(this, data2.d, "canvas", this);
elementData.d = d;
if (!elementData.d.k) {
styleElem.da = elementData.d.dashArray;
styleElem["do"] = elementData.d.dashoffset[0];
}
}
} else {
styleElem.r = data2.r === 2 ? "evenodd" : "nonzero";
}
this.stylesList.push(styleElem);
elementData.style = styleElem;
return elementData;
};
CVShapeElement.prototype.createGroupElement = function() {
var elementData = {
it: [],
prevViewData: []
};
return elementData;
};
CVShapeElement.prototype.createTransformElement = function(data2) {
var elementData = {
transform: {
opacity: 1,
_opMdf: false,
key: this.transformsManager.getNewKey(),
op: PropertyFactory.getProp(this, data2.o, 0, 0.01, this),
mProps: TransformPropertyFactory.getTransformProperty(this, data2, this)
}
};
return elementData;
};
CVShapeElement.prototype.createShapeElement = function(data2) {
var elementData = new CVShapeData(this, data2, this.stylesList, this.transformsManager);
this.shapes.push(elementData);
this.addShapeToModifiers(elementData);
return elementData;
};
CVShapeElement.prototype.reloadShapes = function() {
this._isFirstFrame = true;
var i;
var len = this.itemsData.length;
for (i = 0; i < len; i += 1) {
this.prevViewData[i] = this.itemsData[i];
}
this.searchShapes(this.shapesData, this.itemsData, this.prevViewData, true, []);
len = this.dynamicProperties.length;
for (i = 0; i < len; i += 1) {
this.dynamicProperties[i].getValue();
}
this.renderModifiers();
this.transformsManager.processSequences(this._isFirstFrame);
};
CVShapeElement.prototype.addTransformToStyleList = function(transform2) {
var i;
var len = this.stylesList.length;
for (i = 0; i < len; i += 1) {
if (!this.stylesList[i].closed) {
this.stylesList[i].transforms.push(transform2);
}
}
};
CVShapeElement.prototype.removeTransformFromStyleList = function() {
var i;
var len = this.stylesList.length;
for (i = 0; i < len; i += 1) {
if (!this.stylesList[i].closed) {
this.stylesList[i].transforms.pop();
}
}
};
CVShapeElement.prototype.closeStyles = function(styles) {
var i;
var len = styles.length;
for (i = 0; i < len; i += 1) {
styles[i].closed = true;
}
};
CVShapeElement.prototype.searchShapes = function(arr, itemsData, prevViewData, shouldRender, transforms) {
var i;
var len = arr.length - 1;
var j;
var jLen;
var ownStyles = [];
var ownModifiers = [];
var processedPos;
var modifier;
var currentTransform;
var ownTransforms = [].concat(transforms);
for (i = len; i >= 0; i -= 1) {
processedPos = this.searchProcessedElement(arr[i]);
if (!processedPos) {
arr[i]._shouldRender = shouldRender;
} else {
itemsData[i] = prevViewData[processedPos - 1];
}
if (arr[i].ty === "fl" || arr[i].ty === "st" || arr[i].ty === "gf" || arr[i].ty === "gs") {
if (!processedPos) {
itemsData[i] = this.createStyleElement(arr[i], ownTransforms);
} else {
itemsData[i].style.closed = false;
}
ownStyles.push(itemsData[i].style);
} else if (arr[i].ty === "gr") {
if (!processedPos) {
itemsData[i] = this.createGroupElement(arr[i]);
} else {
jLen = itemsData[i].it.length;
for (j = 0; j < jLen; j += 1) {
itemsData[i].prevViewData[j] = itemsData[i].it[j];
}
}
this.searchShapes(arr[i].it, itemsData[i].it, itemsData[i].prevViewData, shouldRender, ownTransforms);
} else if (arr[i].ty === "tr") {
if (!processedPos) {
currentTransform = this.createTransformElement(arr[i]);
itemsData[i] = currentTransform;
}
ownTransforms.push(itemsData[i]);
this.addTransformToStyleList(itemsData[i]);
} else if (arr[i].ty === "sh" || arr[i].ty === "rc" || arr[i].ty === "el" || arr[i].ty === "sr") {
if (!processedPos) {
itemsData[i] = this.createShapeElement(arr[i]);
}
} else if (arr[i].ty === "tm" || arr[i].ty === "rd" || arr[i].ty === "pb" || arr[i].ty === "zz" || arr[i].ty === "op") {
if (!processedPos) {
modifier = ShapeModifiers.getModifier(arr[i].ty);
modifier.init(this, arr[i]);
itemsData[i] = modifier;
this.shapeModifiers.push(modifier);
} else {
modifier = itemsData[i];
modifier.closed = false;
}
ownModifiers.push(modifier);
} else if (arr[i].ty === "rp") {
if (!processedPos) {
modifier = ShapeModifiers.getModifier(arr[i].ty);
itemsData[i] = modifier;
modifier.init(this, arr, i, itemsData);
this.shapeModifiers.push(modifier);
shouldRender = false;
} else {
modifier = itemsData[i];
modifier.closed = true;
}
ownModifiers.push(modifier);
}
this.addProcessedElement(arr[i], i + 1);
}
this.removeTransformFromStyleList();
this.closeStyles(ownStyles);
len = ownModifiers.length;
for (i = 0; i < len; i += 1) {
ownModifiers[i].closed = true;
}
};
CVShapeElement.prototype.renderInnerContent = function() {
this.transformHelper.opacity = 1;
this.transformHelper._opMdf = false;
this.renderModifiers();
this.transformsManager.processSequences(this._isFirstFrame);
this.renderShape(this.transformHelper, this.shapesData, this.itemsData, true);
};
CVShapeElement.prototype.renderShapeTransform = function(parentTransform, groupTransform) {
if (parentTransform._opMdf || groupTransform.op._mdf || this._isFirstFrame) {
groupTransform.opacity = parentTransform.opacity;
groupTransform.opacity *= groupTransform.op.v;
groupTransform._opMdf = true;
}
};
CVShapeElement.prototype.drawLayer = function() {
var i;
var len = this.stylesList.length;
var j;
var jLen;
var k;
var kLen;
var elems;
var nodes;
var renderer2 = this.globalData.renderer;
var ctx = this.globalData.canvasContext;
var type;
var currentStyle;
for (i = 0; i < len; i += 1) {
currentStyle = this.stylesList[i];
type = currentStyle.type;
if (!((type === "st" || type === "gs") && currentStyle.wi === 0 || !currentStyle.data._shouldRender || currentStyle.coOp === 0 || this.globalData.currentGlobalAlpha === 0)) {
renderer2.save();
elems = currentStyle.elements;
if (type === "st" || type === "gs") {
renderer2.ctxStrokeStyle(type === "st" ? currentStyle.co : currentStyle.grd);
renderer2.ctxLineWidth(currentStyle.wi);
renderer2.ctxLineCap(currentStyle.lc);
renderer2.ctxLineJoin(currentStyle.lj);
renderer2.ctxMiterLimit(currentStyle.ml || 0);
} else {
renderer2.ctxFillStyle(type === "fl" ? currentStyle.co : currentStyle.grd);
}
renderer2.ctxOpacity(currentStyle.coOp);
if (type !== "st" && type !== "gs") {
ctx.beginPath();
}
renderer2.ctxTransform(currentStyle.preTransforms.finalTransform.props);
jLen = elems.length;
for (j = 0; j < jLen; j += 1) {
if (type === "st" || type === "gs") {
ctx.beginPath();
if (currentStyle.da) {
ctx.setLineDash(currentStyle.da);
ctx.lineDashOffset = currentStyle["do"];
}
}
nodes = elems[j].trNodes;
kLen = nodes.length;
for (k = 0; k < kLen; k += 1) {
if (nodes[k].t === "m") {
ctx.moveTo(nodes[k].p[0], nodes[k].p[1]);
} else if (nodes[k].t === "c") {
ctx.bezierCurveTo(nodes[k].pts[0], nodes[k].pts[1], nodes[k].pts[2], nodes[k].pts[3], nodes[k].pts[4], nodes[k].pts[5]);
} else {
ctx.closePath();
}
}
if (type === "st" || type === "gs") {
renderer2.ctxStroke();
if (currentStyle.da) {
ctx.setLineDash(this.dashResetter);
}
}
}
if (type !== "st" && type !== "gs") {
this.globalData.renderer.ctxFill(currentStyle.r);
}
renderer2.restore();
}
}
};
CVShapeElement.prototype.renderShape = function(parentTransform, items, data2, isMain) {
var i;
var len = items.length - 1;
var groupTransform;
groupTransform = parentTransform;
for (i = len; i >= 0; i -= 1) {
if (items[i].ty === "tr") {
groupTransform = data2[i].transform;
this.renderShapeTransform(parentTransform, groupTransform);
} else if (items[i].ty === "sh" || items[i].ty === "el" || items[i].ty === "rc" || items[i].ty === "sr") {
this.renderPath(items[i], data2[i]);
} else if (items[i].ty === "fl") {
this.renderFill(items[i], data2[i], groupTransform);
} else if (items[i].ty === "st") {
this.renderStroke(items[i], data2[i], groupTransform);
} else if (items[i].ty === "gf" || items[i].ty === "gs") {
this.renderGradientFill(items[i], data2[i], groupTransform);
} else if (items[i].ty === "gr") {
this.renderShape(groupTransform, items[i].it, data2[i].it);
} else if (items[i].ty === "tm") {
}
}
if (isMain) {
this.drawLayer();
}
};
CVShapeElement.prototype.renderStyledShape = function(styledShape, shape) {
if (this._isFirstFrame || shape._mdf || styledShape.transforms._mdf) {
var shapeNodes = styledShape.trNodes;
var paths = shape.paths;
var i;
var len;
var j;
var jLen = paths._length;
shapeNodes.length = 0;
var groupTransformMat = styledShape.transforms.finalTransform;
for (j = 0; j < jLen; j += 1) {
var pathNodes = paths.shapes[j];
if (pathNodes && pathNodes.v) {
len = pathNodes._length;
for (i = 1; i < len; i += 1) {
if (i === 1) {
shapeNodes.push({
t: "m",
p: groupTransformMat.applyToPointArray(pathNodes.v[0][0], pathNodes.v[0][1], 0)
});
}
shapeNodes.push({
t: "c",
pts: groupTransformMat.applyToTriplePoints(pathNodes.o[i - 1], pathNodes.i[i], pathNodes.v[i])
});
}
if (len === 1) {
shapeNodes.push({
t: "m",
p: groupTransformMat.applyToPointArray(pathNodes.v[0][0], pathNodes.v[0][1], 0)
});
}
if (pathNodes.c && len) {
shapeNodes.push({
t: "c",
pts: groupTransformMat.applyToTriplePoints(pathNodes.o[i - 1], pathNodes.i[0], pathNodes.v[0])
});
shapeNodes.push({
t: "z"
});
}
}
}
styledShape.trNodes = shapeNodes;
}
};
CVShapeElement.prototype.renderPath = function(pathData, itemData) {
if (pathData.hd !== true && pathData._shouldRender) {
var i;
var len = itemData.styledShapes.length;
for (i = 0; i < len; i += 1) {
this.renderStyledShape(itemData.styledShapes[i], itemData.sh);
}
}
};
CVShapeElement.prototype.renderFill = function(styleData, itemData, groupTransform) {
var styleElem = itemData.style;
if (itemData.c._mdf || this._isFirstFrame) {
styleElem.co = "rgb(" + bmFloor(itemData.c.v[0]) + "," + bmFloor(itemData.c.v[1]) + "," + bmFloor(itemData.c.v[2]) + ")";
}
if (itemData.o._mdf || groupTransform._opMdf || this._isFirstFrame) {
styleElem.coOp = itemData.o.v * groupTransform.opacity;
}
};
CVShapeElement.prototype.renderGradientFill = function(styleData, itemData, groupTransform) {
var styleElem = itemData.style;
var grd;
if (!styleElem.grd || itemData.g._mdf || itemData.s._mdf || itemData.e._mdf || styleData.t !== 1 && (itemData.h._mdf || itemData.a._mdf)) {
var ctx = this.globalData.canvasContext;
var pt1 = itemData.s.v;
var pt2 = itemData.e.v;
if (styleData.t === 1) {
grd = ctx.createLinearGradient(pt1[0], pt1[1], pt2[0], pt2[1]);
} else {
var rad = Math.sqrt(Math.pow(pt1[0] - pt2[0], 2) + Math.pow(pt1[1] - pt2[1], 2));
var ang = Math.atan2(pt2[1] - pt1[1], pt2[0] - pt1[0]);
var percent = itemData.h.v;
if (percent >= 1) {
percent = 0.99;
} else if (percent <= -1) {
percent = -0.99;
}
var dist = rad * percent;
var x = Math.cos(ang + itemData.a.v) * dist + pt1[0];
var y = Math.sin(ang + itemData.a.v) * dist + pt1[1];
grd = ctx.createRadialGradient(x, y, 0, pt1[0], pt1[1], rad);
}
var i;
var len = styleData.g.p;
var cValues = itemData.g.c;
var opacity = 1;
for (i = 0; i < len; i += 1) {
if (itemData.g._hasOpacity && itemData.g._collapsable) {
opacity = itemData.g.o[i * 2 + 1];
}
grd.addColorStop(cValues[i * 4] / 100, "rgba(" + cValues[i * 4 + 1] + "," + cValues[i * 4 + 2] + "," + cValues[i * 4 + 3] + "," + opacity + ")");
}
styleElem.grd = grd;
}
styleElem.coOp = itemData.o.v * groupTransform.opacity;
};
CVShapeElement.prototype.renderStroke = function(styleData, itemData, groupTransform) {
var styleElem = itemData.style;
var d = itemData.d;
if (d && (d._mdf || this._isFirstFrame)) {
styleElem.da = d.dashArray;
styleElem["do"] = d.dashoffset[0];
}
if (itemData.c._mdf || this._isFirstFrame) {
styleElem.co = "rgb(" + bmFloor(itemData.c.v[0]) + "," + bmFloor(itemData.c.v[1]) + "," + bmFloor(itemData.c.v[2]) + ")";
}
if (itemData.o._mdf || groupTransform._opMdf || this._isFirstFrame) {
styleElem.coOp = itemData.o.v * groupTransform.opacity;
}
if (itemData.w._mdf || this._isFirstFrame) {
styleElem.wi = itemData.w.v;
}
};
CVShapeElement.prototype.destroy = function() {
this.shapesData = null;
this.globalData = null;
this.canvasContext = null;
this.stylesList.length = 0;
this.itemsData.length = 0;
};
function CVTextElement(data2, globalData2, comp2) {
this.textSpans = [];
this.yOffset = 0;
this.fillColorAnim = false;
this.strokeColorAnim = false;
this.strokeWidthAnim = false;
this.stroke = false;
this.fill = false;
this.justifyOffset = 0;
this.currentRender = null;
this.renderType = "canvas";
this.values = {
fill: "rgba(0,0,0,0)",
stroke: "rgba(0,0,0,0)",
sWidth: 0,
fValue: ""
};
this.initElement(data2, globalData2, comp2);
}
extendPrototype([BaseElement, TransformElement, CVBaseElement, HierarchyElement, FrameElement, RenderableElement, ITextElement], CVTextElement);
CVTextElement.prototype.tHelper = createTag("canvas").getContext("2d");
CVTextElement.prototype.buildNewText = function() {
var documentData = this.textProperty.currentData;
this.renderedLetters = createSizedArray(documentData.l ? documentData.l.length : 0);
var hasFill = false;
if (documentData.fc) {
hasFill = true;
this.values.fill = this.buildColor(documentData.fc);
} else {
this.values.fill = "rgba(0,0,0,0)";
}
this.fill = hasFill;
var hasStroke = false;
if (documentData.sc) {
hasStroke = true;
this.values.stroke = this.buildColor(documentData.sc);
this.values.sWidth = documentData.sw;
}
var fontData = this.globalData.fontManager.getFontByName(documentData.f);
var i;
var len;
var letters = documentData.l;
var matrixHelper = this.mHelper;
this.stroke = hasStroke;
this.values.fValue = documentData.finalSize + "px " + this.globalData.fontManager.getFontByName(documentData.f).fFamily;
len = documentData.finalText.length;
var charData;
var shapeData;
var k;
var kLen;
var shapes;
var j;
var jLen;
var pathNodes;
var commands;
var pathArr;
var singleShape = this.data.singleShape;
var trackingOffset = documentData.tr * 1e-3 * documentData.finalSize;
var xPos = 0;
var yPos = 0;
var firstLine = true;
var cnt = 0;
for (i = 0; i < len; i += 1) {
charData = this.globalData.fontManager.getCharData(documentData.finalText[i], fontData.fStyle, this.globalData.fontManager.getFontByName(documentData.f).fFamily);
shapeData = charData && charData.data || {};
matrixHelper.reset();
if (singleShape && letters[i].n) {
xPos = -trackingOffset;
yPos += documentData.yOffset;
yPos += firstLine ? 1 : 0;
firstLine = false;
}
shapes = shapeData.shapes ? shapeData.shapes[0].it : [];
jLen = shapes.length;
matrixHelper.scale(documentData.finalSize / 100, documentData.finalSize / 100);
if (singleShape) {
this.applyTextPropertiesToMatrix(documentData, matrixHelper, letters[i].line, xPos, yPos);
}
commands = createSizedArray(jLen - 1);
var commandsCounter = 0;
for (j = 0; j < jLen; j += 1) {
if (shapes[j].ty === "sh") {
kLen = shapes[j].ks.k.i.length;
pathNodes = shapes[j].ks.k;
pathArr = [];
for (k = 1; k < kLen; k += 1) {
if (k === 1) {
pathArr.push(matrixHelper.applyToX(pathNodes.v[0][0], pathNodes.v[0][1], 0), matrixHelper.applyToY(pathNodes.v[0][0], pathNodes.v[0][1], 0));
}
pathArr.push(matrixHelper.applyToX(pathNodes.o[k - 1][0], pathNodes.o[k - 1][1], 0), matrixHelper.applyToY(pathNodes.o[k - 1][0], pathNodes.o[k - 1][1], 0), matrixHelper.applyToX(pathNodes.i[k][0], pathNodes.i[k][1], 0), matrixHelper.applyToY(pathNodes.i[k][0], pathNodes.i[k][1], 0), matrixHelper.applyToX(pathNodes.v[k][0], pathNodes.v[k][1], 0), matrixHelper.applyToY(pathNodes.v[k][0], pathNodes.v[k][1], 0));
}
pathArr.push(matrixHelper.applyToX(pathNodes.o[k - 1][0], pathNodes.o[k - 1][1], 0), matrixHelper.applyToY(pathNodes.o[k - 1][0], pathNodes.o[k - 1][1], 0), matrixHelper.applyToX(pathNodes.i[0][0], pathNodes.i[0][1], 0), matrixHelper.applyToY(pathNodes.i[0][0], pathNodes.i[0][1], 0), matrixHelper.applyToX(pathNodes.v[0][0], pathNodes.v[0][1], 0), matrixHelper.applyToY(pathNodes.v[0][0], pathNodes.v[0][1], 0));
commands[commandsCounter] = pathArr;
commandsCounter += 1;
}
}
if (singleShape) {
xPos += letters[i].l;
xPos += trackingOffset;
}
if (this.textSpans[cnt]) {
this.textSpans[cnt].elem = commands;
} else {
this.textSpans[cnt] = {
elem: commands
};
}
cnt += 1;
}
};
CVTextElement.prototype.renderInnerContent = function() {
this.validateText();
var ctx = this.canvasContext;
ctx.font = this.values.fValue;
this.globalData.renderer.ctxLineCap("butt");
this.globalData.renderer.ctxLineJoin("miter");
this.globalData.renderer.ctxMiterLimit(4);
if (!this.data.singleShape) {
this.textAnimator.getMeasures(this.textProperty.currentData, this.lettersChangedFlag);
}
var i;
var len;
var j;
var jLen;
var k;
var kLen;
var renderedLetters = this.textAnimator.renderedLetters;
var letters = this.textProperty.currentData.l;
len = letters.length;
var renderedLetter;
var lastFill = null;
var lastStroke = null;
var lastStrokeW = null;
var commands;
var pathArr;
var renderer2 = this.globalData.renderer;
for (i = 0; i < len; i += 1) {
if (!letters[i].n) {
renderedLetter = renderedLetters[i];
if (renderedLetter) {
renderer2.save();
renderer2.ctxTransform(renderedLetter.p);
renderer2.ctxOpacity(renderedLetter.o);
}
if (this.fill) {
if (renderedLetter && renderedLetter.fc) {
if (lastFill !== renderedLetter.fc) {
renderer2.ctxFillStyle(renderedLetter.fc);
lastFill = renderedLetter.fc;
}
} else if (lastFill !== this.values.fill) {
lastFill = this.values.fill;
renderer2.ctxFillStyle(this.values.fill);
}
commands = this.textSpans[i].elem;
jLen = commands.length;
this.globalData.canvasContext.beginPath();
for (j = 0; j < jLen; j += 1) {
pathArr = commands[j];
kLen = pathArr.length;
this.globalData.canvasContext.moveTo(pathArr[0], pathArr[1]);
for (k = 2; k < kLen; k += 6) {
this.globalData.canvasContext.bezierCurveTo(pathArr[k], pathArr[k + 1], pathArr[k + 2], pathArr[k + 3], pathArr[k + 4], pathArr[k + 5]);
}
}
this.globalData.canvasContext.closePath();
renderer2.ctxFill();
}
if (this.stroke) {
if (renderedLetter && renderedLetter.sw) {
if (lastStrokeW !== renderedLetter.sw) {
lastStrokeW = renderedLetter.sw;
renderer2.ctxLineWidth(renderedLetter.sw);
}
} else if (lastStrokeW !== this.values.sWidth) {
lastStrokeW = this.values.sWidth;
renderer2.ctxLineWidth(this.values.sWidth);
}
if (renderedLetter && renderedLetter.sc) {
if (lastStroke !== renderedLetter.sc) {
lastStroke = renderedLetter.sc;
renderer2.ctxStrokeStyle(renderedLetter.sc);
}
} else if (lastStroke !== this.values.stroke) {
lastStroke = this.values.stroke;
renderer2.ctxStrokeStyle(this.values.stroke);
}
commands = this.textSpans[i].elem;
jLen = commands.length;
this.globalData.canvasContext.beginPath();
for (j = 0; j < jLen; j += 1) {
pathArr = commands[j];
kLen = pathArr.length;
this.globalData.canvasContext.moveTo(pathArr[0], pathArr[1]);
for (k = 2; k < kLen; k += 6) {
this.globalData.canvasContext.bezierCurveTo(pathArr[k], pathArr[k + 1], pathArr[k + 2], pathArr[k + 3], pathArr[k + 4], pathArr[k + 5]);
}
}
this.globalData.canvasContext.closePath();
renderer2.ctxStroke();
}
if (renderedLetter) {
this.globalData.renderer.restore();
}
}
}
};
function CVImageElement(data2, globalData2, comp2) {
this.assetData = globalData2.getAssetData(data2.refId);
this.img = globalData2.imageLoader.getAsset(this.assetData);
this.initElement(data2, globalData2, comp2);
}
extendPrototype([BaseElement, TransformElement, CVBaseElement, HierarchyElement, FrameElement, RenderableElement], CVImageElement);
CVImageElement.prototype.initElement = SVGShapeElement.prototype.initElement;
CVImageElement.prototype.prepareFrame = IImageElement.prototype.prepareFrame;
CVImageElement.prototype.createContent = function() {
if (this.img.width && (this.assetData.w !== this.img.width || this.assetData.h !== this.img.height)) {
var canvas = createTag("canvas");
canvas.width = this.assetData.w;
canvas.height = this.assetData.h;
var ctx = canvas.getContext("2d");
var imgW = this.img.width;
var imgH = this.img.height;
var imgRel = imgW / imgH;
var canvasRel = this.assetData.w / this.assetData.h;
var widthCrop;
var heightCrop;
var par = this.assetData.pr || this.globalData.renderConfig.imagePreserveAspectRatio;
if (imgRel > canvasRel && par === "xMidYMid slice" || imgRel < canvasRel && par !== "xMidYMid slice") {
heightCrop = imgH;
widthCrop = heightCrop * canvasRel;
} else {
widthCrop = imgW;
heightCrop = widthCrop / canvasRel;
}
ctx.drawImage(this.img, (imgW - widthCrop) / 2, (imgH - heightCrop) / 2, widthCrop, heightCrop, 0, 0, this.assetData.w, this.assetData.h);
this.img = canvas;
}
};
CVImageElement.prototype.renderInnerContent = function() {
this.canvasContext.drawImage(this.img, 0, 0);
};
CVImageElement.prototype.destroy = function() {
this.img = null;
};
function CVSolidElement(data2, globalData2, comp2) {
this.initElement(data2, globalData2, comp2);
}
extendPrototype([BaseElement, TransformElement, CVBaseElement, HierarchyElement, FrameElement, RenderableElement], CVSolidElement);
CVSolidElement.prototype.initElement = SVGShapeElement.prototype.initElement;
CVSolidElement.prototype.prepareFrame = IImageElement.prototype.prepareFrame;
CVSolidElement.prototype.renderInnerContent = function() {
this.globalData.renderer.ctxFillStyle(this.data.sc);
this.globalData.renderer.ctxFillRect(0, 0, this.data.sw, this.data.sh);
};
function CanvasRendererBase() {
}
extendPrototype([BaseRenderer], CanvasRendererBase);
CanvasRendererBase.prototype.createShape = function(data2) {
return new CVShapeElement(data2, this.globalData, this);
};
CanvasRendererBase.prototype.createText = function(data2) {
return new CVTextElement(data2, this.globalData, this);
};
CanvasRendererBase.prototype.createImage = function(data2) {
return new CVImageElement(data2, this.globalData, this);
};
CanvasRendererBase.prototype.createSolid = function(data2) {
return new CVSolidElement(data2, this.globalData, this);
};
CanvasRendererBase.prototype.createNull = SVGRenderer.prototype.createNull;
CanvasRendererBase.prototype.ctxTransform = function(props) {
if (props[0] === 1 && props[1] === 0 && props[4] === 0 && props[5] === 1 && props[12] === 0 && props[13] === 0) {
return;
}
this.canvasContext.transform(props[0], props[1], props[4], props[5], props[12], props[13]);
};
CanvasRendererBase.prototype.ctxOpacity = function(op) {
this.canvasContext.globalAlpha *= op < 0 ? 0 : op;
};
CanvasRendererBase.prototype.ctxFillStyle = function(value2) {
this.canvasContext.fillStyle = value2;
};
CanvasRendererBase.prototype.ctxStrokeStyle = function(value2) {
this.canvasContext.strokeStyle = value2;
};
CanvasRendererBase.prototype.ctxLineWidth = function(value2) {
this.canvasContext.lineWidth = value2;
};
CanvasRendererBase.prototype.ctxLineCap = function(value2) {
this.canvasContext.lineCap = value2;
};
CanvasRendererBase.prototype.ctxLineJoin = function(value2) {
this.canvasContext.lineJoin = value2;
};
CanvasRendererBase.prototype.ctxMiterLimit = function(value2) {
this.canvasContext.miterLimit = value2;
};
CanvasRendererBase.prototype.ctxFill = function(rule) {
this.canvasContext.fill(rule);
};
CanvasRendererBase.prototype.ctxFillRect = function(x, y, w, h) {
this.canvasContext.fillRect(x, y, w, h);
};
CanvasRendererBase.prototype.ctxStroke = function() {
this.canvasContext.stroke();
};
CanvasRendererBase.prototype.reset = function() {
if (!this.renderConfig.clearCanvas) {
this.canvasContext.restore();
return;
}
this.contextData.reset();
};
CanvasRendererBase.prototype.save = function() {
this.canvasContext.save();
};
CanvasRendererBase.prototype.restore = function(actionFlag) {
if (!this.renderConfig.clearCanvas) {
this.canvasContext.restore();
return;
}
if (actionFlag) {
this.globalData.blendMode = "source-over";
}
this.contextData.restore(actionFlag);
};
CanvasRendererBase.prototype.configAnimation = function(animData) {
if (this.animationItem.wrapper) {
this.animationItem.container = createTag("canvas");
var containerStyle = this.animationItem.container.style;
containerStyle.width = "100%";
containerStyle.height = "100%";
var origin = "0px 0px 0px";
containerStyle.transformOrigin = origin;
containerStyle.mozTransformOrigin = origin;
containerStyle.webkitTransformOrigin = origin;
containerStyle["-webkit-transform"] = origin;
containerStyle.contentVisibility = this.renderConfig.contentVisibility;
this.animationItem.wrapper.appendChild(this.animationItem.container);
this.canvasContext = this.animationItem.container.getContext("2d");
if (this.renderConfig.className) {
this.animationItem.container.setAttribute("class", this.renderConfig.className);
}
if (this.renderConfig.id) {
this.animationItem.container.setAttribute("id", this.renderConfig.id);
}
} else {
this.canvasContext = this.renderConfig.context;
}
this.contextData.setContext(this.canvasContext);
this.data = animData;
this.layers = animData.layers;
this.transformCanvas = {
w: animData.w,
h: animData.h,
sx: 0,
sy: 0,
tx: 0,
ty: 0
};
this.setupGlobalData(animData, document.body);
this.globalData.canvasContext = this.canvasContext;
this.globalData.renderer = this;
this.globalData.isDashed = false;
this.globalData.progressiveLoad = this.renderConfig.progressiveLoad;
this.globalData.transformCanvas = this.transformCanvas;
this.elements = createSizedArray(animData.layers.length);
this.updateContainerSize();
};
CanvasRendererBase.prototype.updateContainerSize = function(width2, height2) {
this.reset();
var elementWidth;
var elementHeight;
if (width2) {
elementWidth = width2;
elementHeight = height2;
this.canvasContext.canvas.width = elementWidth;
this.canvasContext.canvas.height = elementHeight;
} else {
if (this.animationItem.wrapper && this.animationItem.container) {
elementWidth = this.animationItem.wrapper.offsetWidth;
elementHeight = this.animationItem.wrapper.offsetHeight;
} else {
elementWidth = this.canvasContext.canvas.width;
elementHeight = this.canvasContext.canvas.height;
}
this.canvasContext.canvas.width = elementWidth * this.renderConfig.dpr;
this.canvasContext.canvas.height = elementHeight * this.renderConfig.dpr;
}
var elementRel;
var animationRel;
if (this.renderConfig.preserveAspectRatio.indexOf("meet") !== -1 || this.renderConfig.preserveAspectRatio.indexOf("slice") !== -1) {
var par = this.renderConfig.preserveAspectRatio.split(" ");
var fillType = par[1] || "meet";
var pos = par[0] || "xMidYMid";
var xPos = pos.substr(0, 4);
var yPos = pos.substr(4);
elementRel = elementWidth / elementHeight;
animationRel = this.transformCanvas.w / this.transformCanvas.h;
if (animationRel > elementRel && fillType === "meet" || animationRel < elementRel && fillType === "slice") {
this.transformCanvas.sx = elementWidth / (this.transformCanvas.w / this.renderConfig.dpr);
this.transformCanvas.sy = elementWidth / (this.transformCanvas.w / this.renderConfig.dpr);
} else {
this.transformCanvas.sx = elementHeight / (this.transformCanvas.h / this.renderConfig.dpr);
this.transformCanvas.sy = elementHeight / (this.transformCanvas.h / this.renderConfig.dpr);
}
if (xPos === "xMid" && (animationRel < elementRel && fillType === "meet" || animationRel > elementRel && fillType === "slice")) {
this.transformCanvas.tx = (elementWidth - this.transformCanvas.w * (elementHeight / this.transformCanvas.h)) / 2 * this.renderConfig.dpr;
} else if (xPos === "xMax" && (animationRel < elementRel && fillType === "meet" || animationRel > elementRel && fillType === "slice")) {
this.transformCanvas.tx = (elementWidth - this.transformCanvas.w * (elementHeight / this.transformCanvas.h)) * this.renderConfig.dpr;
} else {
this.transformCanvas.tx = 0;
}
if (yPos === "YMid" && (animationRel > elementRel && fillType === "meet" || animationRel < elementRel && fillType === "slice")) {
this.transformCanvas.ty = (elementHeight - this.transformCanvas.h * (elementWidth / this.transformCanvas.w)) / 2 * this.renderConfig.dpr;
} else if (yPos === "YMax" && (animationRel > elementRel && fillType === "meet" || animationRel < elementRel && fillType === "slice")) {
this.transformCanvas.ty = (elementHeight - this.transformCanvas.h * (elementWidth / this.transformCanvas.w)) * this.renderConfig.dpr;
} else {
this.transformCanvas.ty = 0;
}
} else if (this.renderConfig.preserveAspectRatio === "none") {
this.transformCanvas.sx = elementWidth / (this.transformCanvas.w / this.renderConfig.dpr);
this.transformCanvas.sy = elementHeight / (this.transformCanvas.h / this.renderConfig.dpr);
this.transformCanvas.tx = 0;
this.transformCanvas.ty = 0;
} else {
this.transformCanvas.sx = this.renderConfig.dpr;
this.transformCanvas.sy = this.renderConfig.dpr;
this.transformCanvas.tx = 0;
this.transformCanvas.ty = 0;
}
this.transformCanvas.props = [this.transformCanvas.sx, 0, 0, 0, 0, this.transformCanvas.sy, 0, 0, 0, 0, 1, 0, this.transformCanvas.tx, this.transformCanvas.ty, 0, 1];
this.ctxTransform(this.transformCanvas.props);
this.canvasContext.beginPath();
this.canvasContext.rect(0, 0, this.transformCanvas.w, this.transformCanvas.h);
this.canvasContext.closePath();
this.canvasContext.clip();
this.renderFrame(this.renderedFrame, true);
};
CanvasRendererBase.prototype.destroy = function() {
if (this.renderConfig.clearCanvas && this.animationItem.wrapper) {
this.animationItem.wrapper.innerText = "";
}
var i;
var len = this.layers ? this.layers.length : 0;
for (i = len - 1; i >= 0; i -= 1) {
if (this.elements[i] && this.elements[i].destroy) {
this.elements[i].destroy();
}
}
this.elements.length = 0;
this.globalData.canvasContext = null;
this.animationItem.container = null;
this.destroyed = true;
};
CanvasRendererBase.prototype.renderFrame = function(num, forceRender) {
if (this.renderedFrame === num && this.renderConfig.clearCanvas === true && !forceRender || this.destroyed || num === -1) {
return;
}
this.renderedFrame = num;
this.globalData.frameNum = num - this.animationItem._isFirstFrame;
this.globalData.frameId += 1;
this.globalData._mdf = !this.renderConfig.clearCanvas || forceRender;
this.globalData.projectInterface.currentFrame = num;
var i;
var len = this.layers.length;
if (!this.completeLayers) {
this.checkLayers(num);
}
for (i = len - 1; i >= 0; i -= 1) {
if (this.completeLayers || this.elements[i]) {
this.elements[i].prepareFrame(num - this.layers[i].st);
}
}
if (this.globalData._mdf) {
if (this.renderConfig.clearCanvas === true) {
this.canvasContext.clearRect(0, 0, this.transformCanvas.w, this.transformCanvas.h);
} else {
this.save();
}
for (i = len - 1; i >= 0; i -= 1) {
if (this.completeLayers || this.elements[i]) {
this.elements[i].renderFrame();
}
}
if (this.renderConfig.clearCanvas !== true) {
this.restore();
}
}
};
CanvasRendererBase.prototype.buildItem = function(pos) {
var elements = this.elements;
if (elements[pos] || this.layers[pos].ty === 99) {
return;
}
var element = this.createItem(this.layers[pos], this, this.globalData);
elements[pos] = element;
element.initExpressions();
};
CanvasRendererBase.prototype.checkPendingElements = function() {
while (this.pendingElements.length) {
var element = this.pendingElements.pop();
element.checkParenting();
}
};
CanvasRendererBase.prototype.hide = function() {
this.animationItem.container.style.display = "none";
};
CanvasRendererBase.prototype.show = function() {
this.animationItem.container.style.display = "block";
};
function CanvasContext() {
this.opacity = -1;
this.transform = createTypedArray("float32", 16);
this.fillStyle = "";
this.strokeStyle = "";
this.lineWidth = "";
this.lineCap = "";
this.lineJoin = "";
this.miterLimit = "";
this.id = Math.random();
}
function CVContextData() {
this.stack = [];
this.cArrPos = 0;
this.cTr = new Matrix();
var i;
var len = 15;
for (i = 0; i < len; i += 1) {
var canvasContext = new CanvasContext();
this.stack[i] = canvasContext;
}
this._length = len;
this.nativeContext = null;
this.transformMat = new Matrix();
this.currentOpacity = 1;
this.currentFillStyle = "";
this.appliedFillStyle = "";
this.currentStrokeStyle = "";
this.appliedStrokeStyle = "";
this.currentLineWidth = "";
this.appliedLineWidth = "";
this.currentLineCap = "";
this.appliedLineCap = "";
this.currentLineJoin = "";
this.appliedLineJoin = "";
this.appliedMiterLimit = "";
this.currentMiterLimit = "";
}
CVContextData.prototype.duplicate = function() {
var newLength = this._length * 2;
var i = 0;
for (i = this._length; i < newLength; i += 1) {
this.stack[i] = new CanvasContext();
}
this._length = newLength;
};
CVContextData.prototype.reset = function() {
this.cArrPos = 0;
this.cTr.reset();
this.stack[this.cArrPos].opacity = 1;
};
CVContextData.prototype.restore = function(forceRestore) {
this.cArrPos -= 1;
var currentContext = this.stack[this.cArrPos];
var transform2 = currentContext.transform;
var i;
var arr = this.cTr.props;
for (i = 0; i < 16; i += 1) {
arr[i] = transform2[i];
}
if (forceRestore) {
this.nativeContext.restore();
var prevStack = this.stack[this.cArrPos + 1];
this.appliedFillStyle = prevStack.fillStyle;
this.appliedStrokeStyle = prevStack.strokeStyle;
this.appliedLineWidth = prevStack.lineWidth;
this.appliedLineCap = prevStack.lineCap;
this.appliedLineJoin = prevStack.lineJoin;
this.appliedMiterLimit = prevStack.miterLimit;
}
this.nativeContext.setTransform(transform2[0], transform2[1], transform2[4], transform2[5], transform2[12], transform2[13]);
if (forceRestore || currentContext.opacity !== -1 && this.currentOpacity !== currentContext.opacity) {
this.nativeContext.globalAlpha = currentContext.opacity;
this.currentOpacity = currentContext.opacity;
}
this.currentFillStyle = currentContext.fillStyle;
this.currentStrokeStyle = currentContext.strokeStyle;
this.currentLineWidth = currentContext.lineWidth;
this.currentLineCap = currentContext.lineCap;
this.currentLineJoin = currentContext.lineJoin;
this.currentMiterLimit = currentContext.miterLimit;
};
CVContextData.prototype.save = function(saveOnNativeFlag) {
if (saveOnNativeFlag) {
this.nativeContext.save();
}
var props = this.cTr.props;
if (this._length <= this.cArrPos) {
this.duplicate();
}
var currentStack = this.stack[this.cArrPos];
var i;
for (i = 0; i < 16; i += 1) {
currentStack.transform[i] = props[i];
}
this.cArrPos += 1;
var newStack = this.stack[this.cArrPos];
newStack.opacity = currentStack.opacity;
newStack.fillStyle = currentStack.fillStyle;
newStack.strokeStyle = currentStack.strokeStyle;
newStack.lineWidth = currentStack.lineWidth;
newStack.lineCap = currentStack.lineCap;
newStack.lineJoin = currentStack.lineJoin;
newStack.miterLimit = currentStack.miterLimit;
};
CVContextData.prototype.setOpacity = function(value2) {
this.stack[this.cArrPos].opacity = value2;
};
CVContextData.prototype.setContext = function(value2) {
this.nativeContext = value2;
};
CVContextData.prototype.fillStyle = function(value2) {
if (this.stack[this.cArrPos].fillStyle !== value2) {
this.currentFillStyle = value2;
this.stack[this.cArrPos].fillStyle = value2;
}
};
CVContextData.prototype.strokeStyle = function(value2) {
if (this.stack[this.cArrPos].strokeStyle !== value2) {
this.currentStrokeStyle = value2;
this.stack[this.cArrPos].strokeStyle = value2;
}
};
CVContextData.prototype.lineWidth = function(value2) {
if (this.stack[this.cArrPos].lineWidth !== value2) {
this.currentLineWidth = value2;
this.stack[this.cArrPos].lineWidth = value2;
}
};
CVContextData.prototype.lineCap = function(value2) {
if (this.stack[this.cArrPos].lineCap !== value2) {
this.currentLineCap = value2;
this.stack[this.cArrPos].lineCap = value2;
}
};
CVContextData.prototype.lineJoin = function(value2) {
if (this.stack[this.cArrPos].lineJoin !== value2) {
this.currentLineJoin = value2;
this.stack[this.cArrPos].lineJoin = value2;
}
};
CVContextData.prototype.miterLimit = function(value2) {
if (this.stack[this.cArrPos].miterLimit !== value2) {
this.currentMiterLimit = value2;
this.stack[this.cArrPos].miterLimit = value2;
}
};
CVContextData.prototype.transform = function(props) {
this.transformMat.cloneFromProps(props);
var currentTransform = this.cTr;
this.transformMat.multiply(currentTransform);
currentTransform.cloneFromProps(this.transformMat.props);
var trProps = currentTransform.props;
this.nativeContext.setTransform(trProps[0], trProps[1], trProps[4], trProps[5], trProps[12], trProps[13]);
};
CVContextData.prototype.opacity = function(op) {
var currentOpacity = this.stack[this.cArrPos].opacity;
currentOpacity *= op < 0 ? 0 : op;
if (this.stack[this.cArrPos].opacity !== currentOpacity) {
if (this.currentOpacity !== op) {
this.nativeContext.globalAlpha = op;
this.currentOpacity = op;
}
this.stack[this.cArrPos].opacity = currentOpacity;
}
};
CVContextData.prototype.fill = function(rule) {
if (this.appliedFillStyle !== this.currentFillStyle) {
this.appliedFillStyle = this.currentFillStyle;
this.nativeContext.fillStyle = this.appliedFillStyle;
}
this.nativeContext.fill(rule);
};
CVContextData.prototype.fillRect = function(x, y, w, h) {
if (this.appliedFillStyle !== this.currentFillStyle) {
this.appliedFillStyle = this.currentFillStyle;
this.nativeContext.fillStyle = this.appliedFillStyle;
}
this.nativeContext.fillRect(x, y, w, h);
};
CVContextData.prototype.stroke = function() {
if (this.appliedStrokeStyle !== this.currentStrokeStyle) {
this.appliedStrokeStyle = this.currentStrokeStyle;
this.nativeContext.strokeStyle = this.appliedStrokeStyle;
}
if (this.appliedLineWidth !== this.currentLineWidth) {
this.appliedLineWidth = this.currentLineWidth;
this.nativeContext.lineWidth = this.appliedLineWidth;
}
if (this.appliedLineCap !== this.currentLineCap) {
this.appliedLineCap = this.currentLineCap;
this.nativeContext.lineCap = this.appliedLineCap;
}
if (this.appliedLineJoin !== this.currentLineJoin) {
this.appliedLineJoin = this.currentLineJoin;
this.nativeContext.lineJoin = this.appliedLineJoin;
}
if (this.appliedMiterLimit !== this.currentMiterLimit) {
this.appliedMiterLimit = this.currentMiterLimit;
this.nativeContext.miterLimit = this.appliedMiterLimit;
}
this.nativeContext.stroke();
};
function CVCompElement(data2, globalData2, comp2) {
this.completeLayers = false;
this.layers = data2.layers;
this.pendingElements = [];
this.elements = createSizedArray(this.layers.length);
this.initElement(data2, globalData2, comp2);
this.tm = data2.tm ? PropertyFactory.getProp(this, data2.tm, 0, globalData2.frameRate, this) : {
_placeholder: true
};
}
extendPrototype([CanvasRendererBase, ICompElement, CVBaseElement], CVCompElement);
CVCompElement.prototype.renderInnerContent = function() {
var ctx = this.canvasContext;
ctx.beginPath();
ctx.moveTo(0, 0);
ctx.lineTo(this.data.w, 0);
ctx.lineTo(this.data.w, this.data.h);
ctx.lineTo(0, this.data.h);
ctx.lineTo(0, 0);
ctx.clip();
var i;
var len = this.layers.length;
for (i = len - 1; i >= 0; i -= 1) {
if (this.completeLayers || this.elements[i]) {
this.elements[i].renderFrame();
}
}
};
CVCompElement.prototype.destroy = function() {
var i;
var len = this.layers.length;
for (i = len - 1; i >= 0; i -= 1) {
if (this.elements[i]) {
this.elements[i].destroy();
}
}
this.layers = null;
this.elements = null;
};
CVCompElement.prototype.createComp = function(data2) {
return new CVCompElement(data2, this.globalData, this);
};
function CanvasRenderer(animationItem, config2) {
this.animationItem = animationItem;
this.renderConfig = {
clearCanvas: config2 && config2.clearCanvas !== void 0 ? config2.clearCanvas : true,
context: config2 && config2.context || null,
progressiveLoad: config2 && config2.progressiveLoad || false,
preserveAspectRatio: config2 && config2.preserveAspectRatio || "xMidYMid meet",
imagePreserveAspectRatio: config2 && config2.imagePreserveAspectRatio || "xMidYMid slice",
contentVisibility: config2 && config2.contentVisibility || "visible",
className: config2 && config2.className || "",
id: config2 && config2.id || "",
runExpressions: !config2 || config2.runExpressions === void 0 || config2.runExpressions
};
this.renderConfig.dpr = config2 && config2.dpr || 1;
if (this.animationItem.wrapper) {
this.renderConfig.dpr = config2 && config2.dpr || window.devicePixelRatio || 1;
}
this.renderedFrame = -1;
this.globalData = {
frameNum: -1,
_mdf: false,
renderConfig: this.renderConfig,
currentGlobalAlpha: -1
};
this.contextData = new CVContextData();
this.elements = [];
this.pendingElements = [];
this.transformMat = new Matrix();
this.completeLayers = false;
this.rendererType = "canvas";
if (this.renderConfig.clearCanvas) {
this.ctxTransform = this.contextData.transform.bind(this.contextData);
this.ctxOpacity = this.contextData.opacity.bind(this.contextData);
this.ctxFillStyle = this.contextData.fillStyle.bind(this.contextData);
this.ctxStrokeStyle = this.contextData.strokeStyle.bind(this.contextData);
this.ctxLineWidth = this.contextData.lineWidth.bind(this.contextData);
this.ctxLineCap = this.contextData.lineCap.bind(this.contextData);
this.ctxLineJoin = this.contextData.lineJoin.bind(this.contextData);
this.ctxMiterLimit = this.contextData.miterLimit.bind(this.contextData);
this.ctxFill = this.contextData.fill.bind(this.contextData);
this.ctxFillRect = this.contextData.fillRect.bind(this.contextData);
this.ctxStroke = this.contextData.stroke.bind(this.contextData);
this.save = this.contextData.save.bind(this.contextData);
}
}
extendPrototype([CanvasRendererBase], CanvasRenderer);
CanvasRenderer.prototype.createComp = function(data2) {
return new CVCompElement(data2, this.globalData, this);
};
function HBaseElement() {
}
HBaseElement.prototype = {
checkBlendMode: function checkBlendMode() {
},
initRendererElement: function initRendererElement() {
this.baseElement = createTag(this.data.tg || "div");
if (this.data.hasMask) {
this.svgElement = createNS("svg");
this.layerElement = createNS("g");
this.maskedElement = this.layerElement;
this.svgElement.appendChild(this.layerElement);
this.baseElement.appendChild(this.svgElement);
} else {
this.layerElement = this.baseElement;
}
styleDiv(this.baseElement);
},
createContainerElements: function createContainerElements() {
this.renderableEffectsManager = new CVEffects(this);
this.transformedElement = this.baseElement;
this.maskedElement = this.layerElement;
if (this.data.ln) {
this.layerElement.setAttribute("id", this.data.ln);
}
if (this.data.cl) {
this.layerElement.setAttribute("class", this.data.cl);
}
if (this.data.bm !== 0) {
this.setBlendMode();
}
},
renderElement: function renderElement() {
var transformedElementStyle = this.transformedElement ? this.transformedElement.style : {};
if (this.finalTransform._matMdf) {
var matrixValue = this.finalTransform.mat.toCSS();
transformedElementStyle.transform = matrixValue;
transformedElementStyle.webkitTransform = matrixValue;
}
if (this.finalTransform._opMdf) {
transformedElementStyle.opacity = this.finalTransform.mProp.o.v;
}
},
renderFrame: function renderFrame() {
if (this.data.hd || this.hidden) {
return;
}
this.renderTransform();
this.renderRenderable();
this.renderElement();
this.renderInnerContent();
if (this._isFirstFrame) {
this._isFirstFrame = false;
}
},
destroy: function destroy() {
this.layerElement = null;
this.transformedElement = null;
if (this.matteElement) {
this.matteElement = null;
}
if (this.maskManager) {
this.maskManager.destroy();
this.maskManager = null;
}
},
createRenderableComponents: function createRenderableComponents() {
this.maskManager = new MaskElement(this.data, this, this.globalData);
},
addEffects: function addEffects() {
},
setMatte: function setMatte() {
}
};
HBaseElement.prototype.getBaseElement = SVGBaseElement.prototype.getBaseElement;
HBaseElement.prototype.destroyBaseElement = HBaseElement.prototype.destroy;
HBaseElement.prototype.buildElementParenting = BaseRenderer.prototype.buildElementParenting;
function HSolidElement(data2, globalData2, comp2) {
this.initElement(data2, globalData2, comp2);
}
extendPrototype([BaseElement, TransformElement, HBaseElement, HierarchyElement, FrameElement, RenderableDOMElement], HSolidElement);
HSolidElement.prototype.createContent = function() {
var rect;
if (this.data.hasMask) {
rect = createNS("rect");
rect.setAttribute("width", this.data.sw);
rect.setAttribute("height", this.data.sh);
rect.setAttribute("fill", this.data.sc);
this.svgElement.setAttribute("width", this.data.sw);
this.svgElement.setAttribute("height", this.data.sh);
} else {
rect = createTag("div");
rect.style.width = this.data.sw + "px";
rect.style.height = this.data.sh + "px";
rect.style.backgroundColor = this.data.sc;
}
this.layerElement.appendChild(rect);
};
function HShapeElement(data2, globalData2, comp2) {
this.shapes = [];
this.shapesData = data2.shapes;
this.stylesList = [];
this.shapeModifiers = [];
this.itemsData = [];
this.processedElements = [];
this.animatedContents = [];
this.shapesContainer = createNS("g");
this.initElement(data2, globalData2, comp2);
this.prevViewData = [];
this.currentBBox = {
x: 999999,
y: -999999,
h: 0,
w: 0
};
}
extendPrototype([BaseElement, TransformElement, HSolidElement, SVGShapeElement, HBaseElement, HierarchyElement, FrameElement, RenderableElement], HShapeElement);
HShapeElement.prototype._renderShapeFrame = HShapeElement.prototype.renderInnerContent;
HShapeElement.prototype.createContent = function() {
var cont;
this.baseElement.style.fontSize = 0;
if (this.data.hasMask) {
this.layerElement.appendChild(this.shapesContainer);
cont = this.svgElement;
} else {
cont = createNS("svg");
var size = this.comp.data ? this.comp.data : this.globalData.compSize;
cont.setAttribute("width", size.w);
cont.setAttribute("height", size.h);
cont.appendChild(this.shapesContainer);
this.layerElement.appendChild(cont);
}
this.searchShapes(this.shapesData, this.itemsData, this.prevViewData, this.shapesContainer, 0, [], true);
this.filterUniqueShapes();
this.shapeCont = cont;
};
HShapeElement.prototype.getTransformedPoint = function(transformers, point) {
var i;
var len = transformers.length;
for (i = 0; i < len; i += 1) {
point = transformers[i].mProps.v.applyToPointArray(point[0], point[1], 0);
}
return point;
};
HShapeElement.prototype.calculateShapeBoundingBox = function(item, boundingBox) {
var shape = item.sh.v;
var transformers = item.transformers;
var i;
var len = shape._length;
var vPoint;
var oPoint;
var nextIPoint;
var nextVPoint;
if (len <= 1) {
return;
}
for (i = 0; i < len - 1; i += 1) {
vPoint = this.getTransformedPoint(transformers, shape.v[i]);
oPoint = this.getTransformedPoint(transformers, shape.o[i]);
nextIPoint = this.getTransformedPoint(transformers, shape.i[i + 1]);
nextVPoint = this.getTransformedPoint(transformers, shape.v[i + 1]);
this.checkBounds(vPoint, oPoint, nextIPoint, nextVPoint, boundingBox);
}
if (shape.c) {
vPoint = this.getTransformedPoint(transformers, shape.v[i]);
oPoint = this.getTransformedPoint(transformers, shape.o[i]);
nextIPoint = this.getTransformedPoint(transformers, shape.i[0]);
nextVPoint = this.getTransformedPoint(transformers, shape.v[0]);
this.checkBounds(vPoint, oPoint, nextIPoint, nextVPoint, boundingBox);
}
};
HShapeElement.prototype.checkBounds = function(vPoint, oPoint, nextIPoint, nextVPoint, boundingBox) {
this.getBoundsOfCurve(vPoint, oPoint, nextIPoint, nextVPoint);
var bounds = this.shapeBoundingBox;
boundingBox.x = bmMin(bounds.left, boundingBox.x);
boundingBox.xMax = bmMax(bounds.right, boundingBox.xMax);
boundingBox.y = bmMin(bounds.top, boundingBox.y);
boundingBox.yMax = bmMax(bounds.bottom, boundingBox.yMax);
};
HShapeElement.prototype.shapeBoundingBox = {
left: 0,
right: 0,
top: 0,
bottom: 0
};
HShapeElement.prototype.tempBoundingBox = {
x: 0,
xMax: 0,
y: 0,
yMax: 0,
width: 0,
height: 0
};
HShapeElement.prototype.getBoundsOfCurve = function(p0, p1, p2, p3) {
var bounds = [[p0[0], p3[0]], [p0[1], p3[1]]];
for (var a, b, c, t, b2ac, t1, t2, i = 0; i < 2; ++i) {
b = 6 * p0[i] - 12 * p1[i] + 6 * p2[i];
a = -3 * p0[i] + 9 * p1[i] - 9 * p2[i] + 3 * p3[i];
c = 3 * p1[i] - 3 * p0[i];
b |= 0;
a |= 0;
c |= 0;
if (a === 0 && b === 0) {
} else if (a === 0) {
t = -c / b;
if (t > 0 && t < 1) {
bounds[i].push(this.calculateF(t, p0, p1, p2, p3, i));
}
} else {
b2ac = b * b - 4 * c * a;
if (b2ac >= 0) {
t1 = (-b + bmSqrt(b2ac)) / (2 * a);
if (t1 > 0 && t1 < 1)
bounds[i].push(this.calculateF(t1, p0, p1, p2, p3, i));
t2 = (-b - bmSqrt(b2ac)) / (2 * a);
if (t2 > 0 && t2 < 1)
bounds[i].push(this.calculateF(t2, p0, p1, p2, p3, i));
}
}
}
this.shapeBoundingBox.left = bmMin.apply(null, bounds[0]);
this.shapeBoundingBox.top = bmMin.apply(null, bounds[1]);
this.shapeBoundingBox.right = bmMax.apply(null, bounds[0]);
this.shapeBoundingBox.bottom = bmMax.apply(null, bounds[1]);
};
HShapeElement.prototype.calculateF = function(t, p0, p1, p2, p3, i) {
return bmPow(1 - t, 3) * p0[i] + 3 * bmPow(1 - t, 2) * t * p1[i] + 3 * (1 - t) * bmPow(t, 2) * p2[i] + bmPow(t, 3) * p3[i];
};
HShapeElement.prototype.calculateBoundingBox = function(itemsData, boundingBox) {
var i;
var len = itemsData.length;
for (i = 0; i < len; i += 1) {
if (itemsData[i] && itemsData[i].sh) {
this.calculateShapeBoundingBox(itemsData[i], boundingBox);
} else if (itemsData[i] && itemsData[i].it) {
this.calculateBoundingBox(itemsData[i].it, boundingBox);
} else if (itemsData[i] && itemsData[i].style && itemsData[i].w) {
this.expandStrokeBoundingBox(itemsData[i].w, boundingBox);
}
}
};
HShapeElement.prototype.expandStrokeBoundingBox = function(widthProperty, boundingBox) {
var width2 = 0;
if (widthProperty.keyframes) {
for (var i = 0; i < widthProperty.keyframes.length; i += 1) {
var kfw = widthProperty.keyframes[i].s;
if (kfw > width2) {
width2 = kfw;
}
}
width2 *= widthProperty.mult;
} else {
width2 = widthProperty.v * widthProperty.mult;
}
boundingBox.x -= width2;
boundingBox.xMax += width2;
boundingBox.y -= width2;
boundingBox.yMax += width2;
};
HShapeElement.prototype.currentBoxContains = function(box) {
return this.currentBBox.x <= box.x && this.currentBBox.y <= box.y && this.currentBBox.width + this.currentBBox.x >= box.x + box.width && this.currentBBox.height + this.currentBBox.y >= box.y + box.height;
};
HShapeElement.prototype.renderInnerContent = function() {
this._renderShapeFrame();
if (!this.hidden && (this._isFirstFrame || this._mdf)) {
var tempBoundingBox = this.tempBoundingBox;
var max = 999999;
tempBoundingBox.x = max;
tempBoundingBox.xMax = -max;
tempBoundingBox.y = max;
tempBoundingBox.yMax = -max;
this.calculateBoundingBox(this.itemsData, tempBoundingBox);
tempBoundingBox.width = tempBoundingBox.xMax < tempBoundingBox.x ? 0 : tempBoundingBox.xMax - tempBoundingBox.x;
tempBoundingBox.height = tempBoundingBox.yMax < tempBoundingBox.y ? 0 : tempBoundingBox.yMax - tempBoundingBox.y;
if (this.currentBoxContains(tempBoundingBox)) {
return;
}
var changed = false;
if (this.currentBBox.w !== tempBoundingBox.width) {
this.currentBBox.w = tempBoundingBox.width;
this.shapeCont.setAttribute("width", tempBoundingBox.width);
changed = true;
}
if (this.currentBBox.h !== tempBoundingBox.height) {
this.currentBBox.h = tempBoundingBox.height;
this.shapeCont.setAttribute("height", tempBoundingBox.height);
changed = true;
}
if (changed || this.currentBBox.x !== tempBoundingBox.x || this.currentBBox.y !== tempBoundingBox.y) {
this.currentBBox.w = tempBoundingBox.width;
this.currentBBox.h = tempBoundingBox.height;
this.currentBBox.x = tempBoundingBox.x;
this.currentBBox.y = tempBoundingBox.y;
this.shapeCont.setAttribute("viewBox", this.currentBBox.x + " " + this.currentBBox.y + " " + this.currentBBox.w + " " + this.currentBBox.h);
var shapeStyle = this.shapeCont.style;
var shapeTransform = "translate(" + this.currentBBox.x + "px," + this.currentBBox.y + "px)";
shapeStyle.transform = shapeTransform;
shapeStyle.webkitTransform = shapeTransform;
}
}
};
function HTextElement(data2, globalData2, comp2) {
this.textSpans = [];
this.textPaths = [];
this.currentBBox = {
x: 999999,
y: -999999,
h: 0,
w: 0
};
this.renderType = "svg";
this.isMasked = false;
this.initElement(data2, globalData2, comp2);
}
extendPrototype([BaseElement, TransformElement, HBaseElement, HierarchyElement, FrameElement, RenderableDOMElement, ITextElement], HTextElement);
HTextElement.prototype.createContent = function() {
this.isMasked = this.checkMasks();
if (this.isMasked) {
this.renderType = "svg";
this.compW = this.comp.data.w;
this.compH = this.comp.data.h;
this.svgElement.setAttribute("width", this.compW);
this.svgElement.setAttribute("height", this.compH);
var g = createNS("g");
this.maskedElement.appendChild(g);
this.innerElem = g;
} else {
this.renderType = "html";
this.innerElem = this.layerElement;
}
this.checkParenting();
};
HTextElement.prototype.buildNewText = function() {
var documentData = this.textProperty.currentData;
this.renderedLetters = createSizedArray(documentData.l ? documentData.l.length : 0);
var innerElemStyle = this.innerElem.style;
var textColor = documentData.fc ? this.buildColor(documentData.fc) : "rgba(0,0,0,0)";
innerElemStyle.fill = textColor;
innerElemStyle.color = textColor;
if (documentData.sc) {
innerElemStyle.stroke = this.buildColor(documentData.sc);
innerElemStyle.strokeWidth = documentData.sw + "px";
}
var fontData = this.globalData.fontManager.getFontByName(documentData.f);
if (!this.globalData.fontManager.chars) {
innerElemStyle.fontSize = documentData.finalSize + "px";
innerElemStyle.lineHeight = documentData.finalSize + "px";
if (fontData.fClass) {
this.innerElem.className = fontData.fClass;
} else {
innerElemStyle.fontFamily = fontData.fFamily;
var fWeight = documentData.fWeight;
var fStyle = documentData.fStyle;
innerElemStyle.fontStyle = fStyle;
innerElemStyle.fontWeight = fWeight;
}
}
var i;
var len;
var letters = documentData.l;
len = letters.length;
var tSpan;
var tParent;
var tCont;
var matrixHelper = this.mHelper;
var shapes;
var shapeStr = "";
var cnt = 0;
for (i = 0; i < len; i += 1) {
if (this.globalData.fontManager.chars) {
if (!this.textPaths[cnt]) {
tSpan = createNS("path");
tSpan.setAttribute("stroke-linecap", lineCapEnum[1]);
tSpan.setAttribute("stroke-linejoin", lineJoinEnum[2]);
tSpan.setAttribute("stroke-miterlimit", "4");
} else {
tSpan = this.textPaths[cnt];
}
if (!this.isMasked) {
if (this.textSpans[cnt]) {
tParent = this.textSpans[cnt];
tCont = tParent.children[0];
} else {
tParent = createTag("div");
tParent.style.lineHeight = 0;
tCont = createNS("svg");
tCont.appendChild(tSpan);
styleDiv(tParent);
}
}
} else if (!this.isMasked) {
if (this.textSpans[cnt]) {
tParent = this.textSpans[cnt];
tSpan = this.textPaths[cnt];
} else {
tParent = createTag("span");
styleDiv(tParent);
tSpan = createTag("span");
styleDiv(tSpan);
tParent.appendChild(tSpan);
}
} else {
tSpan = this.textPaths[cnt] ? this.textPaths[cnt] : createNS("text");
}
if (this.globalData.fontManager.chars) {
var charData = this.globalData.fontManager.getCharData(documentData.finalText[i], fontData.fStyle, this.globalData.fontManager.getFontByName(documentData.f).fFamily);
var shapeData;
if (charData) {
shapeData = charData.data;
} else {
shapeData = null;
}
matrixHelper.reset();
if (shapeData && shapeData.shapes && shapeData.shapes.length) {
shapes = shapeData.shapes[0].it;
matrixHelper.scale(documentData.finalSize / 100, documentData.finalSize / 100);
shapeStr = this.createPathShape(matrixHelper, shapes);
tSpan.setAttribute("d", shapeStr);
}
if (!this.isMasked) {
this.innerElem.appendChild(tParent);
if (shapeData && shapeData.shapes) {
document.body.appendChild(tCont);
var boundingBox = tCont.getBBox();
tCont.setAttribute("width", boundingBox.width + 2);
tCont.setAttribute("height", boundingBox.height + 2);
tCont.setAttribute("viewBox", boundingBox.x - 1 + " " + (boundingBox.y - 1) + " " + (boundingBox.width + 2) + " " + (boundingBox.height + 2));
var tContStyle = tCont.style;
var tContTranslation = "translate(" + (boundingBox.x - 1) + "px," + (boundingBox.y - 1) + "px)";
tContStyle.transform = tContTranslation;
tContStyle.webkitTransform = tContTranslation;
letters[i].yOffset = boundingBox.y - 1;
} else {
tCont.setAttribute("width", 1);
tCont.setAttribute("height", 1);
}
tParent.appendChild(tCont);
} else {
this.innerElem.appendChild(tSpan);
}
} else {
tSpan.textContent = letters[i].val;
tSpan.setAttributeNS("http://www.w3.org/XML/1998/namespace", "xml:space", "preserve");
if (!this.isMasked) {
this.innerElem.appendChild(tParent);
var tStyle = tSpan.style;
var tSpanTranslation = "translate3d(0," + -documentData.finalSize / 1.2 + "px,0)";
tStyle.transform = tSpanTranslation;
tStyle.webkitTransform = tSpanTranslation;
} else {
this.innerElem.appendChild(tSpan);
}
}
if (!this.isMasked) {
this.textSpans[cnt] = tParent;
} else {
this.textSpans[cnt] = tSpan;
}
this.textSpans[cnt].style.display = "block";
this.textPaths[cnt] = tSpan;
cnt += 1;
}
while (cnt < this.textSpans.length) {
this.textSpans[cnt].style.display = "none";
cnt += 1;
}
};
HTextElement.prototype.renderInnerContent = function() {
this.validateText();
var svgStyle;
if (this.data.singleShape) {
if (!this._isFirstFrame && !this.lettersChangedFlag) {
return;
}
if (this.isMasked && this.finalTransform._matMdf) {
this.svgElement.setAttribute("viewBox", -this.finalTransform.mProp.p.v[0] + " " + -this.finalTransform.mProp.p.v[1] + " " + this.compW + " " + this.compH);
svgStyle = this.svgElement.style;
var translation = "translate(" + -this.finalTransform.mProp.p.v[0] + "px," + -this.finalTransform.mProp.p.v[1] + "px)";
svgStyle.transform = translation;
svgStyle.webkitTransform = translation;
}
}
this.textAnimator.getMeasures(this.textProperty.currentData, this.lettersChangedFlag);
if (!this.lettersChangedFlag && !this.textAnimator.lettersChangedFlag) {
return;
}
var i;
var len;
var count = 0;
var renderedLetters = this.textAnimator.renderedLetters;
var letters = this.textProperty.currentData.l;
len = letters.length;
var renderedLetter;
var textSpan;
var textPath;
for (i = 0; i < len; i += 1) {
if (letters[i].n) {
count += 1;
} else {
textSpan = this.textSpans[i];
textPath = this.textPaths[i];
renderedLetter = renderedLetters[count];
count += 1;
if (renderedLetter._mdf.m) {
if (!this.isMasked) {
textSpan.style.webkitTransform = renderedLetter.m;
textSpan.style.transform = renderedLetter.m;
} else {
textSpan.setAttribute("transform", renderedLetter.m);
}
}
textSpan.style.opacity = renderedLetter.o;
if (renderedLetter.sw && renderedLetter._mdf.sw) {
textPath.setAttribute("stroke-width", renderedLetter.sw);
}
if (renderedLetter.sc && renderedLetter._mdf.sc) {
textPath.setAttribute("stroke", renderedLetter.sc);
}
if (renderedLetter.fc && renderedLetter._mdf.fc) {
textPath.setAttribute("fill", renderedLetter.fc);
textPath.style.color = renderedLetter.fc;
}
}
}
if (this.innerElem.getBBox && !this.hidden && (this._isFirstFrame || this._mdf)) {
var boundingBox = this.innerElem.getBBox();
if (this.currentBBox.w !== boundingBox.width) {
this.currentBBox.w = boundingBox.width;
this.svgElement.setAttribute("width", boundingBox.width);
}
if (this.currentBBox.h !== boundingBox.height) {
this.currentBBox.h = boundingBox.height;
this.svgElement.setAttribute("height", boundingBox.height);
}
var margin = 1;
if (this.currentBBox.w !== boundingBox.width + margin * 2 || this.currentBBox.h !== boundingBox.height + margin * 2 || this.currentBBox.x !== boundingBox.x - margin || this.currentBBox.y !== boundingBox.y - margin) {
this.currentBBox.w = boundingBox.width + margin * 2;
this.currentBBox.h = boundingBox.height + margin * 2;
this.currentBBox.x = boundingBox.x - margin;
this.currentBBox.y = boundingBox.y - margin;
this.svgElement.setAttribute("viewBox", this.currentBBox.x + " " + this.currentBBox.y + " " + this.currentBBox.w + " " + this.currentBBox.h);
svgStyle = this.svgElement.style;
var svgTransform = "translate(" + this.currentBBox.x + "px," + this.currentBBox.y + "px)";
svgStyle.transform = svgTransform;
svgStyle.webkitTransform = svgTransform;
}
}
};
function HCameraElement(data2, globalData2, comp2) {
this.initFrame();
this.initBaseData(data2, globalData2, comp2);
this.initHierarchy();
var getProp = PropertyFactory.getProp;
this.pe = getProp(this, data2.pe, 0, 0, this);
if (data2.ks.p.s) {
this.px = getProp(this, data2.ks.p.x, 1, 0, this);
this.py = getProp(this, data2.ks.p.y, 1, 0, this);
this.pz = getProp(this, data2.ks.p.z, 1, 0, this);
} else {
this.p = getProp(this, data2.ks.p, 1, 0, this);
}
if (data2.ks.a) {
this.a = getProp(this, data2.ks.a, 1, 0, this);
}
if (data2.ks.or.k.length && data2.ks.or.k[0].to) {
var i;
var len = data2.ks.or.k.length;
for (i = 0; i < len; i += 1) {
data2.ks.or.k[i].to = null;
data2.ks.or.k[i].ti = null;
}
}
this.or = getProp(this, data2.ks.or, 1, degToRads, this);
this.or.sh = true;
this.rx = getProp(this, data2.ks.rx, 0, degToRads, this);
this.ry = getProp(this, data2.ks.ry, 0, degToRads, this);
this.rz = getProp(this, data2.ks.rz, 0, degToRads, this);
this.mat = new Matrix();
this._prevMat = new Matrix();
this._isFirstFrame = true;
this.finalTransform = {
mProp: this
};
}
extendPrototype([BaseElement, FrameElement, HierarchyElement], HCameraElement);
HCameraElement.prototype.setup = function() {
var i;
var len = this.comp.threeDElements.length;
var comp2;
var perspectiveStyle;
var containerStyle;
for (i = 0; i < len; i += 1) {
comp2 = this.comp.threeDElements[i];
if (comp2.type === "3d") {
perspectiveStyle = comp2.perspectiveElem.style;
containerStyle = comp2.container.style;
var perspective = this.pe.v + "px";
var origin = "0px 0px 0px";
var matrix = "matrix3d(1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1)";
perspectiveStyle.perspective = perspective;
perspectiveStyle.webkitPerspective = perspective;
containerStyle.transformOrigin = origin;
containerStyle.mozTransformOrigin = origin;
containerStyle.webkitTransformOrigin = origin;
perspectiveStyle.transform = matrix;
perspectiveStyle.webkitTransform = matrix;
}
}
};
HCameraElement.prototype.createElements = function() {
};
HCameraElement.prototype.hide = function() {
};
HCameraElement.prototype.renderFrame = function() {
var _mdf = this._isFirstFrame;
var i;
var len;
if (this.hierarchy) {
len = this.hierarchy.length;
for (i = 0; i < len; i += 1) {
_mdf = this.hierarchy[i].finalTransform.mProp._mdf || _mdf;
}
}
if (_mdf || this.pe._mdf || this.p && this.p._mdf || this.px && (this.px._mdf || this.py._mdf || this.pz._mdf) || this.rx._mdf || this.ry._mdf || this.rz._mdf || this.or._mdf || this.a && this.a._mdf) {
this.mat.reset();
if (this.hierarchy) {
len = this.hierarchy.length - 1;
for (i = len; i >= 0; i -= 1) {
var mTransf = this.hierarchy[i].finalTransform.mProp;
this.mat.translate(-mTransf.p.v[0], -mTransf.p.v[1], mTransf.p.v[2]);
this.mat.rotateX(-mTransf.or.v[0]).rotateY(-mTransf.or.v[1]).rotateZ(mTransf.or.v[2]);
this.mat.rotateX(-mTransf.rx.v).rotateY(-mTransf.ry.v).rotateZ(mTransf.rz.v);
this.mat.scale(1 / mTransf.s.v[0], 1 / mTransf.s.v[1], 1 / mTransf.s.v[2]);
this.mat.translate(mTransf.a.v[0], mTransf.a.v[1], mTransf.a.v[2]);
}
}
if (this.p) {
this.mat.translate(-this.p.v[0], -this.p.v[1], this.p.v[2]);
} else {
this.mat.translate(-this.px.v, -this.py.v, this.pz.v);
}
if (this.a) {
var diffVector;
if (this.p) {
diffVector = [this.p.v[0] - this.a.v[0], this.p.v[1] - this.a.v[1], this.p.v[2] - this.a.v[2]];
} else {
diffVector = [this.px.v - this.a.v[0], this.py.v - this.a.v[1], this.pz.v - this.a.v[2]];
}
var mag = Math.sqrt(Math.pow(diffVector[0], 2) + Math.pow(diffVector[1], 2) + Math.pow(diffVector[2], 2));
var lookDir = [diffVector[0] / mag, diffVector[1] / mag, diffVector[2] / mag];
var lookLengthOnXZ = Math.sqrt(lookDir[2] * lookDir[2] + lookDir[0] * lookDir[0]);
var mRotationX = Math.atan2(lookDir[1], lookLengthOnXZ);
var mRotationY = Math.atan2(lookDir[0], -lookDir[2]);
this.mat.rotateY(mRotationY).rotateX(-mRotationX);
}
this.mat.rotateX(-this.rx.v).rotateY(-this.ry.v).rotateZ(this.rz.v);
this.mat.rotateX(-this.or.v[0]).rotateY(-this.or.v[1]).rotateZ(this.or.v[2]);
this.mat.translate(this.globalData.compSize.w / 2, this.globalData.compSize.h / 2, 0);
this.mat.translate(0, 0, this.pe.v);
var hasMatrixChanged = !this._prevMat.equals(this.mat);
if ((hasMatrixChanged || this.pe._mdf) && this.comp.threeDElements) {
len = this.comp.threeDElements.length;
var comp2;
var perspectiveStyle;
var containerStyle;
for (i = 0; i < len; i += 1) {
comp2 = this.comp.threeDElements[i];
if (comp2.type === "3d") {
if (hasMatrixChanged) {
var matValue = this.mat.toCSS();
containerStyle = comp2.container.style;
containerStyle.transform = matValue;
containerStyle.webkitTransform = matValue;
}
if (this.pe._mdf) {
perspectiveStyle = comp2.perspectiveElem.style;
perspectiveStyle.perspective = this.pe.v + "px";
perspectiveStyle.webkitPerspective = this.pe.v + "px";
}
}
}
this.mat.clone(this._prevMat);
}
}
this._isFirstFrame = false;
};
HCameraElement.prototype.prepareFrame = function(num) {
this.prepareProperties(num, true);
};
HCameraElement.prototype.destroy = function() {
};
HCameraElement.prototype.getBaseElement = function() {
return null;
};
function HImageElement(data2, globalData2, comp2) {
this.assetData = globalData2.getAssetData(data2.refId);
this.initElement(data2, globalData2, comp2);
}
extendPrototype([BaseElement, TransformElement, HBaseElement, HSolidElement, HierarchyElement, FrameElement, RenderableElement], HImageElement);
HImageElement.prototype.createContent = function() {
var assetPath = this.globalData.getAssetsPath(this.assetData);
var img = new Image();
if (this.data.hasMask) {
this.imageElem = createNS("image");
this.imageElem.setAttribute("width", this.assetData.w + "px");
this.imageElem.setAttribute("height", this.assetData.h + "px");
this.imageElem.setAttributeNS("http://www.w3.org/1999/xlink", "href", assetPath);
this.layerElement.appendChild(this.imageElem);
this.baseElement.setAttribute("width", this.assetData.w);
this.baseElement.setAttribute("height", this.assetData.h);
} else {
this.layerElement.appendChild(img);
}
img.crossOrigin = "anonymous";
img.src = assetPath;
if (this.data.ln) {
this.baseElement.setAttribute("id", this.data.ln);
}
};
function HybridRendererBase(animationItem, config2) {
this.animationItem = animationItem;
this.layers = null;
this.renderedFrame = -1;
this.renderConfig = {
className: config2 && config2.className || "",
imagePreserveAspectRatio: config2 && config2.imagePreserveAspectRatio || "xMidYMid slice",
hideOnTransparent: !(config2 && config2.hideOnTransparent === false),
filterSize: {
width: config2 && config2.filterSize && config2.filterSize.width || "400%",
height: config2 && config2.filterSize && config2.filterSize.height || "400%",
x: config2 && config2.filterSize && config2.filterSize.x || "-100%",
y: config2 && config2.filterSize && config2.filterSize.y || "-100%"
}
};
this.globalData = {
_mdf: false,
frameNum: -1,
renderConfig: this.renderConfig
};
this.pendingElements = [];
this.elements = [];
this.threeDElements = [];
this.destroyed = false;
this.camera = null;
this.supports3d = true;
this.rendererType = "html";
}
extendPrototype([BaseRenderer], HybridRendererBase);
HybridRendererBase.prototype.buildItem = SVGRenderer.prototype.buildItem;
HybridRendererBase.prototype.checkPendingElements = function() {
while (this.pendingElements.length) {
var element = this.pendingElements.pop();
element.checkParenting();
}
};
HybridRendererBase.prototype.appendElementInPos = function(element, pos) {
var newDOMElement = element.getBaseElement();
if (!newDOMElement) {
return;
}
var layer = this.layers[pos];
if (!layer.ddd || !this.supports3d) {
if (this.threeDElements) {
this.addTo3dContainer(newDOMElement, pos);
} else {
var i = 0;
var nextDOMElement;
var nextLayer;
var tmpDOMElement;
while (i < pos) {
if (this.elements[i] && this.elements[i] !== true && this.elements[i].getBaseElement) {
nextLayer = this.elements[i];
tmpDOMElement = this.layers[i].ddd ? this.getThreeDContainerByPos(i) : nextLayer.getBaseElement();
nextDOMElement = tmpDOMElement || nextDOMElement;
}
i += 1;
}
if (nextDOMElement) {
if (!layer.ddd || !this.supports3d) {
this.layerElement.insertBefore(newDOMElement, nextDOMElement);
}
} else if (!layer.ddd || !this.supports3d) {
this.layerElement.appendChild(newDOMElement);
}
}
} else {
this.addTo3dContainer(newDOMElement, pos);
}
};
HybridRendererBase.prototype.createShape = function(data2) {
if (!this.supports3d) {
return new SVGShapeElement(data2, this.globalData, this);
}
return new HShapeElement(data2, this.globalData, this);
};
HybridRendererBase.prototype.createText = function(data2) {
if (!this.supports3d) {
return new SVGTextLottieElement(data2, this.globalData, this);
}
return new HTextElement(data2, this.globalData, this);
};
HybridRendererBase.prototype.createCamera = function(data2) {
this.camera = new HCameraElement(data2, this.globalData, this);
return this.camera;
};
HybridRendererBase.prototype.createImage = function(data2) {
if (!this.supports3d) {
return new IImageElement(data2, this.globalData, this);
}
return new HImageElement(data2, this.globalData, this);
};
HybridRendererBase.prototype.createSolid = function(data2) {
if (!this.supports3d) {
return new ISolidElement(data2, this.globalData, this);
}
return new HSolidElement(data2, this.globalData, this);
};
HybridRendererBase.prototype.createNull = SVGRenderer.prototype.createNull;
HybridRendererBase.prototype.getThreeDContainerByPos = function(pos) {
var i = 0;
var len = this.threeDElements.length;
while (i < len) {
if (this.threeDElements[i].startPos <= pos && this.threeDElements[i].endPos >= pos) {
return this.threeDElements[i].perspectiveElem;
}
i += 1;
}
return null;
};
HybridRendererBase.prototype.createThreeDContainer = function(pos, type) {
var perspectiveElem = createTag("div");
var style;
var containerStyle;
styleDiv(perspectiveElem);
var container = createTag("div");
styleDiv(container);
if (type === "3d") {
style = perspectiveElem.style;
style.width = this.globalData.compSize.w + "px";
style.height = this.globalData.compSize.h + "px";
var center = "50% 50%";
style.webkitTransformOrigin = center;
style.mozTransformOrigin = center;
style.transformOrigin = center;
containerStyle = container.style;
var matrix = "matrix3d(1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1)";
containerStyle.transform = matrix;
containerStyle.webkitTransform = matrix;
}
perspectiveElem.appendChild(container);
var threeDContainerData = {
container,
perspectiveElem,
startPos: pos,
endPos: pos,
type
};
this.threeDElements.push(threeDContainerData);
return threeDContainerData;
};
HybridRendererBase.prototype.build3dContainers = function() {
var i;
var len = this.layers.length;
var lastThreeDContainerData;
var currentContainer = "";
for (i = 0; i < len; i += 1) {
if (this.layers[i].ddd && this.layers[i].ty !== 3) {
if (currentContainer !== "3d") {
currentContainer = "3d";
lastThreeDContainerData = this.createThreeDContainer(i, "3d");
}
lastThreeDContainerData.endPos = Math.max(lastThreeDContainerData.endPos, i);
} else {
if (currentContainer !== "2d") {
currentContainer = "2d";
lastThreeDContainerData = this.createThreeDContainer(i, "2d");
}
lastThreeDContainerData.endPos = Math.max(lastThreeDContainerData.endPos, i);
}
}
len = this.threeDElements.length;
for (i = len - 1; i >= 0; i -= 1) {
this.resizerElem.appendChild(this.threeDElements[i].perspectiveElem);
}
};
HybridRendererBase.prototype.addTo3dContainer = function(elem2, pos) {
var i = 0;
var len = this.threeDElements.length;
while (i < len) {
if (pos <= this.threeDElements[i].endPos) {
var j = this.threeDElements[i].startPos;
var nextElement;
while (j < pos) {
if (this.elements[j] && this.elements[j].getBaseElement) {
nextElement = this.elements[j].getBaseElement();
}
j += 1;
}
if (nextElement) {
this.threeDElements[i].container.insertBefore(elem2, nextElement);
} else {
this.threeDElements[i].container.appendChild(elem2);
}
break;
}
i += 1;
}
};
HybridRendererBase.prototype.configAnimation = function(animData) {
var resizerElem = createTag("div");
var wrapper = this.animationItem.wrapper;
var style = resizerElem.style;
style.width = animData.w + "px";
style.height = animData.h + "px";
this.resizerElem = resizerElem;
styleDiv(resizerElem);
style.transformStyle = "flat";
style.mozTransformStyle = "flat";
style.webkitTransformStyle = "flat";
if (this.renderConfig.className) {
resizerElem.setAttribute("class", this.renderConfig.className);
}
wrapper.appendChild(resizerElem);
style.overflow = "hidden";
var svg = createNS("svg");
svg.setAttribute("width", "1");
svg.setAttribute("height", "1");
styleDiv(svg);
this.resizerElem.appendChild(svg);
var defs = createNS("defs");
svg.appendChild(defs);
this.data = animData;
this.setupGlobalData(animData, svg);
this.globalData.defs = defs;
this.layers = animData.layers;
this.layerElement = this.resizerElem;
this.build3dContainers();
this.updateContainerSize();
};
HybridRendererBase.prototype.destroy = function() {
if (this.animationItem.wrapper) {
this.animationItem.wrapper.innerText = "";
}
this.animationItem.container = null;
this.globalData.defs = null;
var i;
var len = this.layers ? this.layers.length : 0;
for (i = 0; i < len; i += 1) {
if (this.elements[i] && this.elements[i].destroy) {
this.elements[i].destroy();
}
}
this.elements.length = 0;
this.destroyed = true;
this.animationItem = null;
};
HybridRendererBase.prototype.updateContainerSize = function() {
var elementWidth = this.animationItem.wrapper.offsetWidth;
var elementHeight = this.animationItem.wrapper.offsetHeight;
var elementRel = elementWidth / elementHeight;
var animationRel = this.globalData.compSize.w / this.globalData.compSize.h;
var sx;
var sy;
var tx;
var ty;
if (animationRel > elementRel) {
sx = elementWidth / this.globalData.compSize.w;
sy = elementWidth / this.globalData.compSize.w;
tx = 0;
ty = (elementHeight - this.globalData.compSize.h * (elementWidth / this.globalData.compSize.w)) / 2;
} else {
sx = elementHeight / this.globalData.compSize.h;
sy = elementHeight / this.globalData.compSize.h;
tx = (elementWidth - this.globalData.compSize.w * (elementHeight / this.globalData.compSize.h)) / 2;
ty = 0;
}
var style = this.resizerElem.style;
style.webkitTransform = "matrix3d(" + sx + ",0,0,0,0," + sy + ",0,0,0,0,1,0," + tx + "," + ty + ",0,1)";
style.transform = style.webkitTransform;
};
HybridRendererBase.prototype.renderFrame = SVGRenderer.prototype.renderFrame;
HybridRendererBase.prototype.hide = function() {
this.resizerElem.style.display = "none";
};
HybridRendererBase.prototype.show = function() {
this.resizerElem.style.display = "block";
};
HybridRendererBase.prototype.initItems = function() {
this.buildAllItems();
if (this.camera) {
this.camera.setup();
} else {
var cWidth = this.globalData.compSize.w;
var cHeight = this.globalData.compSize.h;
var i;
var len = this.threeDElements.length;
for (i = 0; i < len; i += 1) {
var style = this.threeDElements[i].perspectiveElem.style;
style.webkitPerspective = Math.sqrt(Math.pow(cWidth, 2) + Math.pow(cHeight, 2)) + "px";
style.perspective = style.webkitPerspective;
}
}
};
HybridRendererBase.prototype.searchExtraCompositions = function(assets) {
var i;
var len = assets.length;
var floatingContainer = createTag("div");
for (i = 0; i < len; i += 1) {
if (assets[i].xt) {
var comp2 = this.createComp(assets[i], floatingContainer, this.globalData.comp, null);
comp2.initExpressions();
this.globalData.projectInterface.registerComposition(comp2);
}
}
};
function HCompElement(data2, globalData2, comp2) {
this.layers = data2.layers;
this.supports3d = !data2.hasMask;
this.completeLayers = false;
this.pendingElements = [];
this.elements = this.layers ? createSizedArray(this.layers.length) : [];
this.initElement(data2, globalData2, comp2);
this.tm = data2.tm ? PropertyFactory.getProp(this, data2.tm, 0, globalData2.frameRate, this) : {
_placeholder: true
};
}
extendPrototype([HybridRendererBase, ICompElement, HBaseElement], HCompElement);
HCompElement.prototype._createBaseContainerElements = HCompElement.prototype.createContainerElements;
HCompElement.prototype.createContainerElements = function() {
this._createBaseContainerElements();
if (this.data.hasMask) {
this.svgElement.setAttribute("width", this.data.w);
this.svgElement.setAttribute("height", this.data.h);
this.transformedElement = this.baseElement;
} else {
this.transformedElement = this.layerElement;
}
};
HCompElement.prototype.addTo3dContainer = function(elem2, pos) {
var j = 0;
var nextElement;
while (j < pos) {
if (this.elements[j] && this.elements[j].getBaseElement) {
nextElement = this.elements[j].getBaseElement();
}
j += 1;
}
if (nextElement) {
this.layerElement.insertBefore(elem2, nextElement);
} else {
this.layerElement.appendChild(elem2);
}
};
HCompElement.prototype.createComp = function(data2) {
if (!this.supports3d) {
return new SVGCompElement(data2, this.globalData, this);
}
return new HCompElement(data2, this.globalData, this);
};
function HybridRenderer(animationItem, config2) {
this.animationItem = animationItem;
this.layers = null;
this.renderedFrame = -1;
this.renderConfig = {
className: config2 && config2.className || "",
imagePreserveAspectRatio: config2 && config2.imagePreserveAspectRatio || "xMidYMid slice",
hideOnTransparent: !(config2 && config2.hideOnTransparent === false),
filterSize: {
width: config2 && config2.filterSize && config2.filterSize.width || "400%",
height: config2 && config2.filterSize && config2.filterSize.height || "400%",
x: config2 && config2.filterSize && config2.filterSize.x || "-100%",
y: config2 && config2.filterSize && config2.filterSize.y || "-100%"
},
runExpressions: !config2 || config2.runExpressions === void 0 || config2.runExpressions
};
this.globalData = {
_mdf: false,
frameNum: -1,
renderConfig: this.renderConfig
};
this.pendingElements = [];
this.elements = [];
this.threeDElements = [];
this.destroyed = false;
this.camera = null;
this.supports3d = true;
this.rendererType = "html";
}
extendPrototype([HybridRendererBase], HybridRenderer);
HybridRenderer.prototype.createComp = function(data2) {
if (!this.supports3d) {
return new SVGCompElement(data2, this.globalData, this);
}
return new HCompElement(data2, this.globalData, this);
};
var CompExpressionInterface = /* @__PURE__ */ function() {
return function(comp2) {
function _thisLayerFunction(name2) {
var i = 0;
var len = comp2.layers.length;
while (i < len) {
if (comp2.layers[i].nm === name2 || comp2.layers[i].ind === name2) {
return comp2.elements[i].layerInterface;
}
i += 1;
}
return null;
}
Object.defineProperty(_thisLayerFunction, "_name", {
value: comp2.data.nm
});
_thisLayerFunction.layer = _thisLayerFunction;
_thisLayerFunction.pixelAspect = 1;
_thisLayerFunction.height = comp2.data.h || comp2.globalData.compSize.h;
_thisLayerFunction.width = comp2.data.w || comp2.globalData.compSize.w;
_thisLayerFunction.pixelAspect = 1;
_thisLayerFunction.frameDuration = 1 / comp2.globalData.frameRate;
_thisLayerFunction.displayStartTime = 0;
_thisLayerFunction.numLayers = comp2.layers.length;
return _thisLayerFunction;
};
}();
function _typeof$2(obj) {
"@babel/helpers - typeof";
if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
_typeof$2 = function _typeof2(obj2) {
return typeof obj2;
};
} else {
_typeof$2 = function _typeof2(obj2) {
return obj2 && typeof Symbol === "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
};
}
return _typeof$2(obj);
}
function seedRandom(pool, math) {
var global2 = this, width2 = 256, chunks = 6, digits = 52, rngname = "random", startdenom = math.pow(width2, chunks), significance = math.pow(2, digits), overflow = significance * 2, mask2 = width2 - 1, nodecrypto;
function seedrandom(seed, options, callback) {
var key2 = [];
options = options === true ? {
entropy: true
} : options || {};
var shortseed = mixkey(flatten2(options.entropy ? [seed, tostring(pool)] : seed === null ? autoseed() : seed, 3), key2);
var arc4 = new ARC4(key2);
var prng = function prng2() {
var n = arc4.g(chunks), d = startdenom, x = 0;
while (n < significance) {
n = (n + x) * width2;
d *= width2;
x = arc4.g(1);
}
while (n >= overflow) {
n /= 2;
d /= 2;
x >>>= 1;
}
return (n + x) / d;
};
prng.int32 = function() {
return arc4.g(4) | 0;
};
prng.quick = function() {
return arc4.g(4) / 4294967296;
};
prng["double"] = prng;
mixkey(tostring(arc4.S), pool);
return (options.pass || callback || function(prng2, seed2, is_math_call, state) {
if (state) {
if (state.S) {
copy(state, arc4);
}
prng2.state = function() {
return copy(arc4, {});
};
}
if (is_math_call) {
math[rngname] = prng2;
return seed2;
} else
return prng2;
})(prng, shortseed, "global" in options ? options.global : this == math, options.state);
}
math["seed" + rngname] = seedrandom;
function ARC4(key2) {
var t, keylen = key2.length, me = this, i = 0, j = me.i = me.j = 0, s = me.S = [];
if (!keylen) {
key2 = [keylen++];
}
while (i < width2) {
s[i] = i++;
}
for (i = 0; i < width2; i++) {
s[i] = s[j = mask2 & j + key2[i % keylen] + (t = s[i])];
s[j] = t;
}
me.g = function(count) {
var t2, r = 0, i2 = me.i, j2 = me.j, s2 = me.S;
while (count--) {
t2 = s2[i2 = mask2 & i2 + 1];
r = r * width2 + s2[mask2 & (s2[i2] = s2[j2 = mask2 & j2 + t2]) + (s2[j2] = t2)];
}
me.i = i2;
me.j = j2;
return r;
};
}
function copy(f, t) {
t.i = f.i;
t.j = f.j;
t.S = f.S.slice();
return t;
}
function flatten2(obj, depth) {
var result = [], typ = _typeof$2(obj), prop;
if (depth && typ == "object") {
for (prop in obj) {
try {
result.push(flatten2(obj[prop], depth - 1));
} catch (e) {
}
}
}
return result.length ? result : typ == "string" ? obj : obj + "\0";
}
function mixkey(seed, key2) {
var stringseed = seed + "", smear, j = 0;
while (j < stringseed.length) {
key2[mask2 & j] = mask2 & (smear ^= key2[mask2 & j] * 19) + stringseed.charCodeAt(j++);
}
return tostring(key2);
}
function autoseed() {
try {
if (nodecrypto) {
return tostring(nodecrypto.randomBytes(width2));
}
var out = new Uint8Array(width2);
(global2.crypto || global2.msCrypto).getRandomValues(out);
return tostring(out);
} catch (e) {
var browser = global2.navigator, plugins = browser && browser.plugins;
return [+/* @__PURE__ */ new Date(), global2, plugins, global2.screen, tostring(pool)];
}
}
function tostring(a) {
return String.fromCharCode.apply(0, a);
}
mixkey(math.random(), pool);
}
;
function initialize$2(BMMath2) {
seedRandom([], BMMath2);
}
var propTypes = {
SHAPE: "shape"
};
function _typeof$1(obj) {
"@babel/helpers - typeof";
if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
_typeof$1 = function _typeof2(obj2) {
return typeof obj2;
};
} else {
_typeof$1 = function _typeof2(obj2) {
return obj2 && typeof Symbol === "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
};
}
return _typeof$1(obj);
}
var ExpressionManager = function() {
"use strict";
var ob = {};
var Math = BMMath;
var window = null;
var document = null;
var XMLHttpRequest = null;
var fetch = null;
var frames = null;
var _lottieGlobal = {};
initialize$2(BMMath);
function resetFrame() {
_lottieGlobal = {};
}
function $bm_isInstanceOfArray(arr) {
return arr.constructor === Array || arr.constructor === Float32Array;
}
function isNumerable(tOfV, v) {
return tOfV === "number" || v instanceof Number || tOfV === "boolean" || tOfV === "string";
}
function $bm_neg(a) {
var tOfA = _typeof$1(a);
if (tOfA === "number" || a instanceof Number || tOfA === "boolean") {
return -a;
}
if ($bm_isInstanceOfArray(a)) {
var i;
var lenA = a.length;
var retArr = [];
for (i = 0; i < lenA; i += 1) {
retArr[i] = -a[i];
}
return retArr;
}
if (a.propType) {
return a.v;
}
return -a;
}
var easeInBez = BezierFactory.getBezierEasing(0.333, 0, 0.833, 0.833, "easeIn").get;
var easeOutBez = BezierFactory.getBezierEasing(0.167, 0.167, 0.667, 1, "easeOut").get;
var easeInOutBez = BezierFactory.getBezierEasing(0.33, 0, 0.667, 1, "easeInOut").get;
function sum(a, b) {
var tOfA = _typeof$1(a);
var tOfB = _typeof$1(b);
if (isNumerable(tOfA, a) && isNumerable(tOfB, b) || tOfA === "string" || tOfB === "string") {
return a + b;
}
if ($bm_isInstanceOfArray(a) && isNumerable(tOfB, b)) {
a = a.slice(0);
a[0] += b;
return a;
}
if (isNumerable(tOfA, a) && $bm_isInstanceOfArray(b)) {
b = b.slice(0);
b[0] = a + b[0];
return b;
}
if ($bm_isInstanceOfArray(a) && $bm_isInstanceOfArray(b)) {
var i = 0;
var lenA = a.length;
var lenB = b.length;
var retArr = [];
while (i < lenA || i < lenB) {
if ((typeof a[i] === "number" || a[i] instanceof Number) && (typeof b[i] === "number" || b[i] instanceof Number)) {
retArr[i] = a[i] + b[i];
} else {
retArr[i] = b[i] === void 0 ? a[i] : a[i] || b[i];
}
i += 1;
}
return retArr;
}
return 0;
}
var add = sum;
function sub(a, b) {
var tOfA = _typeof$1(a);
var tOfB = _typeof$1(b);
if (isNumerable(tOfA, a) && isNumerable(tOfB, b)) {
if (tOfA === "string") {
a = parseInt(a, 10);
}
if (tOfB === "string") {
b = parseInt(b, 10);
}
return a - b;
}
if ($bm_isInstanceOfArray(a) && isNumerable(tOfB, b)) {
a = a.slice(0);
a[0] -= b;
return a;
}
if (isNumerable(tOfA, a) && $bm_isInstanceOfArray(b)) {
b = b.slice(0);
b[0] = a - b[0];
return b;
}
if ($bm_isInstanceOfArray(a) && $bm_isInstanceOfArray(b)) {
var i = 0;
var lenA = a.length;
var lenB = b.length;
var retArr = [];
while (i < lenA || i < lenB) {
if ((typeof a[i] === "number" || a[i] instanceof Number) && (typeof b[i] === "number" || b[i] instanceof Number)) {
retArr[i] = a[i] - b[i];
} else {
retArr[i] = b[i] === void 0 ? a[i] : a[i] || b[i];
}
i += 1;
}
return retArr;
}
return 0;
}
function mul(a, b) {
var tOfA = _typeof$1(a);
var tOfB = _typeof$1(b);
var arr;
if (isNumerable(tOfA, a) && isNumerable(tOfB, b)) {
return a * b;
}
var i;
var len;
if ($bm_isInstanceOfArray(a) && isNumerable(tOfB, b)) {
len = a.length;
arr = createTypedArray("float32", len);
for (i = 0; i < len; i += 1) {
arr[i] = a[i] * b;
}
return arr;
}
if (isNumerable(tOfA, a) && $bm_isInstanceOfArray(b)) {
len = b.length;
arr = createTypedArray("float32", len);
for (i = 0; i < len; i += 1) {
arr[i] = a * b[i];
}
return arr;
}
return 0;
}
function div(a, b) {
var tOfA = _typeof$1(a);
var tOfB = _typeof$1(b);
var arr;
if (isNumerable(tOfA, a) && isNumerable(tOfB, b)) {
return a / b;
}
var i;
var len;
if ($bm_isInstanceOfArray(a) && isNumerable(tOfB, b)) {
len = a.length;
arr = createTypedArray("float32", len);
for (i = 0; i < len; i += 1) {
arr[i] = a[i] / b;
}
return arr;
}
if (isNumerable(tOfA, a) && $bm_isInstanceOfArray(b)) {
len = b.length;
arr = createTypedArray("float32", len);
for (i = 0; i < len; i += 1) {
arr[i] = a / b[i];
}
return arr;
}
return 0;
}
function mod(a, b) {
if (typeof a === "string") {
a = parseInt(a, 10);
}
if (typeof b === "string") {
b = parseInt(b, 10);
}
return a % b;
}
var $bm_sum = sum;
var $bm_sub = sub;
var $bm_mul = mul;
var $bm_div = div;
var $bm_mod = mod;
function clamp(num, min, max) {
if (min > max) {
var mm = max;
max = min;
min = mm;
}
return Math.min(Math.max(num, min), max);
}
function radiansToDegrees(val2) {
return val2 / degToRads;
}
var radians_to_degrees = radiansToDegrees;
function degreesToRadians(val2) {
return val2 * degToRads;
}
var degrees_to_radians = radiansToDegrees;
var helperLengthArray = [0, 0, 0, 0, 0, 0];
function length(arr1, arr2) {
if (typeof arr1 === "number" || arr1 instanceof Number) {
arr2 = arr2 || 0;
return Math.abs(arr1 - arr2);
}
if (!arr2) {
arr2 = helperLengthArray;
}
var i;
var len = Math.min(arr1.length, arr2.length);
var addedLength = 0;
for (i = 0; i < len; i += 1) {
addedLength += Math.pow(arr2[i] - arr1[i], 2);
}
return Math.sqrt(addedLength);
}
function normalize(vec) {
return div(vec, length(vec));
}
function rgbToHsl(val2) {
var r = val2[0];
var g = val2[1];
var b = val2[2];
var max = Math.max(r, g, b);
var min = Math.min(r, g, b);
var h;
var s;
var l = (max + min) / 2;
if (max === min) {
h = 0;
s = 0;
} else {
var d = max - min;
s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
switch (max) {
case r:
h = (g - b) / d + (g < b ? 6 : 0);
break;
case g:
h = (b - r) / d + 2;
break;
case b:
h = (r - g) / d + 4;
break;
default:
break;
}
h /= 6;
}
return [h, s, l, val2[3]];
}
function hue2rgb(p, q, t) {
if (t < 0)
t += 1;
if (t > 1)
t -= 1;
if (t < 1 / 6)
return p + (q - p) * 6 * t;
if (t < 1 / 2)
return q;
if (t < 2 / 3)
return p + (q - p) * (2 / 3 - t) * 6;
return p;
}
function hslToRgb(val2) {
var h = val2[0];
var s = val2[1];
var l = val2[2];
var r;
var g;
var b;
if (s === 0) {
r = l;
b = l;
g = l;
} else {
var q = l < 0.5 ? l * (1 + s) : l + s - l * s;
var p = 2 * l - q;
r = hue2rgb(p, q, h + 1 / 3);
g = hue2rgb(p, q, h);
b = hue2rgb(p, q, h - 1 / 3);
}
return [r, g, b, val2[3]];
}
function linear(t, tMin, tMax, value1, value2) {
if (value1 === void 0 || value2 === void 0) {
value1 = tMin;
value2 = tMax;
tMin = 0;
tMax = 1;
}
if (tMax < tMin) {
var _tMin = tMax;
tMax = tMin;
tMin = _tMin;
}
if (t <= tMin) {
return value1;
}
if (t >= tMax) {
return value2;
}
var perc = tMax === tMin ? 0 : (t - tMin) / (tMax - tMin);
if (!value1.length) {
return value1 + (value2 - value1) * perc;
}
var i;
var len = value1.length;
var arr = createTypedArray("float32", len);
for (i = 0; i < len; i += 1) {
arr[i] = value1[i] + (value2[i] - value1[i]) * perc;
}
return arr;
}
function random(min, max) {
if (max === void 0) {
if (min === void 0) {
min = 0;
max = 1;
} else {
max = min;
min = void 0;
}
}
if (max.length) {
var i;
var len = max.length;
if (!min) {
min = createTypedArray("float32", len);
}
var arr = createTypedArray("float32", len);
var rnd = BMMath.random();
for (i = 0; i < len; i += 1) {
arr[i] = min[i] + rnd * (max[i] - min[i]);
}
return arr;
}
if (min === void 0) {
min = 0;
}
var rndm = BMMath.random();
return min + rndm * (max - min);
}
function createPath(points, inTangents, outTangents, closed) {
var i;
var len = points.length;
var path = shapePool.newElement();
path.setPathData(!!closed, len);
var arrPlaceholder = [0, 0];
var inVertexPoint;
var outVertexPoint;
for (i = 0; i < len; i += 1) {
inVertexPoint = inTangents && inTangents[i] ? inTangents[i] : arrPlaceholder;
outVertexPoint = outTangents && outTangents[i] ? outTangents[i] : arrPlaceholder;
path.setTripleAt(points[i][0], points[i][1], outVertexPoint[0] + points[i][0], outVertexPoint[1] + points[i][1], inVertexPoint[0] + points[i][0], inVertexPoint[1] + points[i][1], i, true);
}
return path;
}
function initiateExpression(elem, data, property) {
function noOp(_value) {
return _value;
}
if (!elem.globalData.renderConfig.runExpressions) {
return noOp;
}
var val = data.x;
var needsVelocity = /velocity(?![\w\d])/.test(val);
var _needsRandom = val.indexOf("random") !== -1;
var elemType = elem.data.ty;
var transform;
var $bm_transform;
var content;
var effect;
var thisProperty = property;
thisProperty.valueAtTime = thisProperty.getValueAtTime;
Object.defineProperty(thisProperty, "value", {
get: function get() {
return thisProperty.v;
}
});
elem.comp.frameDuration = 1 / elem.comp.globalData.frameRate;
elem.comp.displayStartTime = 0;
var inPoint = elem.data.ip / elem.comp.globalData.frameRate;
var outPoint = elem.data.op / elem.comp.globalData.frameRate;
var width = elem.data.sw ? elem.data.sw : 0;
var height = elem.data.sh ? elem.data.sh : 0;
var name = elem.data.nm;
var loopIn;
var loop_in;
var loopOut;
var loop_out;
var smooth;
var toWorld;
var fromWorld;
var fromComp;
var toComp;
var fromCompToSurface;
var position;
var rotation;
var anchorPoint;
var scale;
var thisLayer;
var thisComp;
var mask;
var valueAtTime;
var velocityAtTime;
var scoped_bm_rt;
var expression_function = eval("[function _expression_function(){" + val + ";scoped_bm_rt=$bm_rt}]")[0];
var numKeys = property.kf ? data.k.length : 0;
var active = !this.data || this.data.hd !== true;
var wiggle = (function wiggle2(freq, amp) {
var iWiggle;
var j;
var lenWiggle = this.pv.length ? this.pv.length : 1;
var addedAmps = createTypedArray("float32", lenWiggle);
freq = 5;
var iterations = Math.floor(time * freq);
iWiggle = 0;
j = 0;
while (iWiggle < iterations) {
for (j = 0; j < lenWiggle; j += 1) {
addedAmps[j] += -amp + amp * 2 * BMMath.random();
}
iWiggle += 1;
}
var periods = time * freq;
var perc = periods - Math.floor(periods);
var arr = createTypedArray("float32", lenWiggle);
if (lenWiggle > 1) {
for (j = 0; j < lenWiggle; j += 1) {
arr[j] = this.pv[j] + addedAmps[j] + (-amp + amp * 2 * BMMath.random()) * perc;
}
return arr;
}
return this.pv + addedAmps[0] + (-amp + amp * 2 * BMMath.random()) * perc;
}).bind(this);
if (thisProperty.loopIn) {
loopIn = thisProperty.loopIn.bind(thisProperty);
loop_in = loopIn;
}
if (thisProperty.loopOut) {
loopOut = thisProperty.loopOut.bind(thisProperty);
loop_out = loopOut;
}
if (thisProperty.smooth) {
smooth = thisProperty.smooth.bind(thisProperty);
}
function loopInDuration(type, duration) {
return loopIn(type, duration, true);
}
function loopOutDuration(type, duration) {
return loopOut(type, duration, true);
}
if (this.getValueAtTime) {
valueAtTime = this.getValueAtTime.bind(this);
}
if (this.getVelocityAtTime) {
velocityAtTime = this.getVelocityAtTime.bind(this);
}
var comp = elem.comp.globalData.projectInterface.bind(elem.comp.globalData.projectInterface);
function lookAt(elem1, elem2) {
var fVec = [elem2[0] - elem1[0], elem2[1] - elem1[1], elem2[2] - elem1[2]];
var pitch = Math.atan2(fVec[0], Math.sqrt(fVec[1] * fVec[1] + fVec[2] * fVec[2])) / degToRads;
var yaw = -Math.atan2(fVec[1], fVec[2]) / degToRads;
return [yaw, pitch, 0];
}
function easeOut(t, tMin, tMax, val1, val2) {
return applyEase(easeOutBez, t, tMin, tMax, val1, val2);
}
function easeIn(t, tMin, tMax, val1, val2) {
return applyEase(easeInBez, t, tMin, tMax, val1, val2);
}
function ease(t, tMin, tMax, val1, val2) {
return applyEase(easeInOutBez, t, tMin, tMax, val1, val2);
}
function applyEase(fn, t, tMin, tMax, val1, val2) {
if (val1 === void 0) {
val1 = tMin;
val2 = tMax;
} else {
t = (t - tMin) / (tMax - tMin);
}
if (t > 1) {
t = 1;
} else if (t < 0) {
t = 0;
}
var mult = fn(t);
if ($bm_isInstanceOfArray(val1)) {
var iKey;
var lenKey = val1.length;
var arr = createTypedArray("float32", lenKey);
for (iKey = 0; iKey < lenKey; iKey += 1) {
arr[iKey] = (val2[iKey] - val1[iKey]) * mult + val1[iKey];
}
return arr;
}
return (val2 - val1) * mult + val1;
}
function nearestKey(time2) {
var iKey;
var lenKey = data.k.length;
var index2;
var keyTime;
if (!data.k.length || typeof data.k[0] === "number") {
index2 = 0;
keyTime = 0;
} else {
index2 = -1;
time2 *= elem.comp.globalData.frameRate;
if (time2 < data.k[0].t) {
index2 = 1;
keyTime = data.k[0].t;
} else {
for (iKey = 0; iKey < lenKey - 1; iKey += 1) {
if (time2 === data.k[iKey].t) {
index2 = iKey + 1;
keyTime = data.k[iKey].t;
break;
} else if (time2 > data.k[iKey].t && time2 < data.k[iKey + 1].t) {
if (time2 - data.k[iKey].t > data.k[iKey + 1].t - time2) {
index2 = iKey + 2;
keyTime = data.k[iKey + 1].t;
} else {
index2 = iKey + 1;
keyTime = data.k[iKey].t;
}
break;
}
}
if (index2 === -1) {
index2 = iKey + 1;
keyTime = data.k[iKey].t;
}
}
}
var obKey = {};
obKey.index = index2;
obKey.time = keyTime / elem.comp.globalData.frameRate;
return obKey;
}
function key(ind) {
var obKey;
var iKey;
var lenKey;
if (!data.k.length || typeof data.k[0] === "number") {
throw new Error("The property has no keyframe at index " + ind);
}
ind -= 1;
obKey = {
time: data.k[ind].t / elem.comp.globalData.frameRate,
value: []
};
var arr = Object.prototype.hasOwnProperty.call(data.k[ind], "s") ? data.k[ind].s : data.k[ind - 1].e;
lenKey = arr.length;
for (iKey = 0; iKey < lenKey; iKey += 1) {
obKey[iKey] = arr[iKey];
obKey.value[iKey] = arr[iKey];
}
return obKey;
}
function framesToTime(fr, fps) {
if (!fps) {
fps = elem.comp.globalData.frameRate;
}
return fr / fps;
}
function timeToFrames(t, fps) {
if (!t && t !== 0) {
t = time;
}
if (!fps) {
fps = elem.comp.globalData.frameRate;
}
return t * fps;
}
function seedRandom(seed) {
BMMath.seedrandom(randSeed + seed);
}
function sourceRectAtTime() {
return elem.sourceRectAtTime();
}
function substring(init, end) {
if (typeof value === "string") {
if (end === void 0) {
return value.substring(init);
}
return value.substring(init, end);
}
return "";
}
function substr(init, end) {
if (typeof value === "string") {
if (end === void 0) {
return value.substr(init);
}
return value.substr(init, end);
}
return "";
}
function posterizeTime(framesPerSecond) {
time = framesPerSecond === 0 ? 0 : Math.floor(time * framesPerSecond) / framesPerSecond;
value = valueAtTime(time);
}
var time;
var velocity;
var value;
var text;
var textIndex;
var textTotal;
var selectorValue;
var index = elem.data.ind;
var hasParent = !!(elem.hierarchy && elem.hierarchy.length);
var parent;
var randSeed = Math.floor(Math.random() * 1e6);
var globalData = elem.globalData;
function executeExpression(_value) {
value = _value;
if (this.frameExpressionId === elem.globalData.frameId && this.propType !== "textSelector") {
return value;
}
if (this.propType === "textSelector") {
textIndex = this.textIndex;
textTotal = this.textTotal;
selectorValue = this.selectorValue;
}
if (!thisLayer) {
text = elem.layerInterface.text;
thisLayer = elem.layerInterface;
thisComp = elem.comp.compInterface;
toWorld = thisLayer.toWorld.bind(thisLayer);
fromWorld = thisLayer.fromWorld.bind(thisLayer);
fromComp = thisLayer.fromComp.bind(thisLayer);
toComp = thisLayer.toComp.bind(thisLayer);
mask = thisLayer.mask ? thisLayer.mask.bind(thisLayer) : null;
fromCompToSurface = fromComp;
}
if (!transform) {
transform = elem.layerInterface("ADBE Transform Group");
$bm_transform = transform;
if (transform) {
anchorPoint = transform.anchorPoint;
}
}
if (elemType === 4 && !content) {
content = thisLayer("ADBE Root Vectors Group");
}
if (!effect) {
effect = thisLayer(4);
}
hasParent = !!(elem.hierarchy && elem.hierarchy.length);
if (hasParent && !parent) {
parent = elem.hierarchy[0].layerInterface;
}
time = this.comp.renderedFrame / this.comp.globalData.frameRate;
if (_needsRandom) {
seedRandom(randSeed + time);
}
if (needsVelocity) {
velocity = velocityAtTime(time);
}
expression_function();
this.frameExpressionId = elem.globalData.frameId;
scoped_bm_rt = scoped_bm_rt.propType === propTypes.SHAPE ? scoped_bm_rt.v : scoped_bm_rt;
return scoped_bm_rt;
}
executeExpression.__preventDeadCodeRemoval = [$bm_transform, anchorPoint, time, velocity, inPoint, outPoint, width, height, name, loop_in, loop_out, smooth, toComp, fromCompToSurface, toWorld, fromWorld, mask, position, rotation, scale, thisComp, numKeys, active, wiggle, loopInDuration, loopOutDuration, comp, lookAt, easeOut, easeIn, ease, nearestKey, key, text, textIndex, textTotal, selectorValue, framesToTime, timeToFrames, sourceRectAtTime, substring, substr, posterizeTime, index, globalData];
return executeExpression;
}
ob.initiateExpression = initiateExpression;
ob.__preventDeadCodeRemoval = [window, document, XMLHttpRequest, fetch, frames, $bm_neg, add, $bm_sum, $bm_sub, $bm_mul, $bm_div, $bm_mod, clamp, radians_to_degrees, degreesToRadians, degrees_to_radians, normalize, rgbToHsl, hslToRgb, linear, random, createPath, _lottieGlobal];
ob.resetFrame = resetFrame;
return ob;
}();
var Expressions = function() {
var ob2 = {};
ob2.initExpressions = initExpressions;
ob2.resetFrame = ExpressionManager.resetFrame;
function initExpressions(animation) {
var stackCount = 0;
var registers = [];
function pushExpression() {
stackCount += 1;
}
function popExpression() {
stackCount -= 1;
if (stackCount === 0) {
releaseInstances();
}
}
function registerExpressionProperty(expression) {
if (registers.indexOf(expression) === -1) {
registers.push(expression);
}
}
function releaseInstances() {
var i;
var len = registers.length;
for (i = 0; i < len; i += 1) {
registers[i].release();
}
registers.length = 0;
}
animation.renderer.compInterface = CompExpressionInterface(animation.renderer);
animation.renderer.globalData.projectInterface.registerComposition(animation.renderer);
animation.renderer.globalData.pushExpression = pushExpression;
animation.renderer.globalData.popExpression = popExpression;
animation.renderer.globalData.registerExpressionProperty = registerExpressionProperty;
}
return ob2;
}();
var MaskManagerInterface = function() {
function MaskInterface(mask2, data2) {
this._mask = mask2;
this._data = data2;
}
Object.defineProperty(MaskInterface.prototype, "maskPath", {
get: function get() {
if (this._mask.prop.k) {
this._mask.prop.getValue();
}
return this._mask.prop;
}
});
Object.defineProperty(MaskInterface.prototype, "maskOpacity", {
get: function get() {
if (this._mask.op.k) {
this._mask.op.getValue();
}
return this._mask.op.v * 100;
}
});
var MaskManager = function MaskManager2(maskManager) {
var _masksInterfaces = createSizedArray(maskManager.viewData.length);
var i;
var len = maskManager.viewData.length;
for (i = 0; i < len; i += 1) {
_masksInterfaces[i] = new MaskInterface(maskManager.viewData[i], maskManager.masksProperties[i]);
}
var maskFunction = function maskFunction2(name2) {
i = 0;
while (i < len) {
if (maskManager.masksProperties[i].nm === name2) {
return _masksInterfaces[i];
}
i += 1;
}
return null;
};
return maskFunction;
};
return MaskManager;
}();
var ExpressionPropertyInterface = /* @__PURE__ */ function() {
var defaultUnidimensionalValue = {
pv: 0,
v: 0,
mult: 1
};
var defaultMultidimensionalValue = {
pv: [0, 0, 0],
v: [0, 0, 0],
mult: 1
};
function completeProperty(expressionValue, property2, type) {
Object.defineProperty(expressionValue, "velocity", {
get: function get() {
return property2.getVelocityAtTime(property2.comp.currentFrame);
}
});
expressionValue.numKeys = property2.keyframes ? property2.keyframes.length : 0;
expressionValue.key = function(pos) {
if (!expressionValue.numKeys) {
return 0;
}
var value2 = "";
if ("s" in property2.keyframes[pos - 1]) {
value2 = property2.keyframes[pos - 1].s;
} else if ("e" in property2.keyframes[pos - 2]) {
value2 = property2.keyframes[pos - 2].e;
} else {
value2 = property2.keyframes[pos - 2].s;
}
var valueProp = type === "unidimensional" ? new Number(value2) : Object.assign({}, value2);
valueProp.time = property2.keyframes[pos - 1].t / property2.elem.comp.globalData.frameRate;
valueProp.value = type === "unidimensional" ? value2[0] : value2;
return valueProp;
};
expressionValue.valueAtTime = property2.getValueAtTime;
expressionValue.speedAtTime = property2.getSpeedAtTime;
expressionValue.velocityAtTime = property2.getVelocityAtTime;
expressionValue.propertyGroup = property2.propertyGroup;
}
function UnidimensionalPropertyInterface(property2) {
if (!property2 || !("pv" in property2)) {
property2 = defaultUnidimensionalValue;
}
var mult = 1 / property2.mult;
var val2 = property2.pv * mult;
var expressionValue = new Number(val2);
expressionValue.value = val2;
completeProperty(expressionValue, property2, "unidimensional");
return function() {
if (property2.k) {
property2.getValue();
}
val2 = property2.v * mult;
if (expressionValue.value !== val2) {
expressionValue = new Number(val2);
expressionValue.value = val2;
completeProperty(expressionValue, property2, "unidimensional");
}
return expressionValue;
};
}
function MultidimensionalPropertyInterface(property2) {
if (!property2 || !("pv" in property2)) {
property2 = defaultMultidimensionalValue;
}
var mult = 1 / property2.mult;
var len = property2.data && property2.data.l || property2.pv.length;
var expressionValue = createTypedArray("float32", len);
var arrValue = createTypedArray("float32", len);
expressionValue.value = arrValue;
completeProperty(expressionValue, property2, "multidimensional");
return function() {
if (property2.k) {
property2.getValue();
}
for (var i = 0; i < len; i += 1) {
arrValue[i] = property2.v[i] * mult;
expressionValue[i] = arrValue[i];
}
return expressionValue;
};
}
function defaultGetter() {
return defaultUnidimensionalValue;
}
return function(property2) {
if (!property2) {
return defaultGetter;
}
if (property2.propType === "unidimensional") {
return UnidimensionalPropertyInterface(property2);
}
return MultidimensionalPropertyInterface(property2);
};
}();
var TransformExpressionInterface = /* @__PURE__ */ function() {
return function(transform2) {
function _thisFunction(name2) {
switch (name2) {
case "scale":
case "Scale":
case "ADBE Scale":
case 6:
return _thisFunction.scale;
case "rotation":
case "Rotation":
case "ADBE Rotation":
case "ADBE Rotate Z":
case 10:
return _thisFunction.rotation;
case "ADBE Rotate X":
return _thisFunction.xRotation;
case "ADBE Rotate Y":
return _thisFunction.yRotation;
case "position":
case "Position":
case "ADBE Position":
case 2:
return _thisFunction.position;
case "ADBE Position_0":
return _thisFunction.xPosition;
case "ADBE Position_1":
return _thisFunction.yPosition;
case "ADBE Position_2":
return _thisFunction.zPosition;
case "anchorPoint":
case "AnchorPoint":
case "Anchor Point":
case "ADBE AnchorPoint":
case 1:
return _thisFunction.anchorPoint;
case "opacity":
case "Opacity":
case 11:
return _thisFunction.opacity;
default:
return null;
}
}
Object.defineProperty(_thisFunction, "rotation", {
get: ExpressionPropertyInterface(transform2.r || transform2.rz)
});
Object.defineProperty(_thisFunction, "zRotation", {
get: ExpressionPropertyInterface(transform2.rz || transform2.r)
});
Object.defineProperty(_thisFunction, "xRotation", {
get: ExpressionPropertyInterface(transform2.rx)
});
Object.defineProperty(_thisFunction, "yRotation", {
get: ExpressionPropertyInterface(transform2.ry)
});
Object.defineProperty(_thisFunction, "scale", {
get: ExpressionPropertyInterface(transform2.s)
});
var _px;
var _py;
var _pz;
var _transformFactory;
if (transform2.p) {
_transformFactory = ExpressionPropertyInterface(transform2.p);
} else {
_px = ExpressionPropertyInterface(transform2.px);
_py = ExpressionPropertyInterface(transform2.py);
if (transform2.pz) {
_pz = ExpressionPropertyInterface(transform2.pz);
}
}
Object.defineProperty(_thisFunction, "position", {
get: function get() {
if (transform2.p) {
return _transformFactory();
}
return [_px(), _py(), _pz ? _pz() : 0];
}
});
Object.defineProperty(_thisFunction, "xPosition", {
get: ExpressionPropertyInterface(transform2.px)
});
Object.defineProperty(_thisFunction, "yPosition", {
get: ExpressionPropertyInterface(transform2.py)
});
Object.defineProperty(_thisFunction, "zPosition", {
get: ExpressionPropertyInterface(transform2.pz)
});
Object.defineProperty(_thisFunction, "anchorPoint", {
get: ExpressionPropertyInterface(transform2.a)
});
Object.defineProperty(_thisFunction, "opacity", {
get: ExpressionPropertyInterface(transform2.o)
});
Object.defineProperty(_thisFunction, "skew", {
get: ExpressionPropertyInterface(transform2.sk)
});
Object.defineProperty(_thisFunction, "skewAxis", {
get: ExpressionPropertyInterface(transform2.sa)
});
Object.defineProperty(_thisFunction, "orientation", {
get: ExpressionPropertyInterface(transform2.or)
});
return _thisFunction;
};
}();
var LayerExpressionInterface = /* @__PURE__ */ function() {
function getMatrix(time2) {
var toWorldMat = new Matrix();
if (time2 !== void 0) {
var propMatrix = this._elem.finalTransform.mProp.getValueAtTime(time2);
propMatrix.clone(toWorldMat);
} else {
var transformMat = this._elem.finalTransform.mProp;
transformMat.applyToMatrix(toWorldMat);
}
return toWorldMat;
}
function toWorldVec(arr, time2) {
var toWorldMat = this.getMatrix(time2);
toWorldMat.props[12] = 0;
toWorldMat.props[13] = 0;
toWorldMat.props[14] = 0;
return this.applyPoint(toWorldMat, arr);
}
function toWorld2(arr, time2) {
var toWorldMat = this.getMatrix(time2);
return this.applyPoint(toWorldMat, arr);
}
function fromWorldVec(arr, time2) {
var toWorldMat = this.getMatrix(time2);
toWorldMat.props[12] = 0;
toWorldMat.props[13] = 0;
toWorldMat.props[14] = 0;
return this.invertPoint(toWorldMat, arr);
}
function fromWorld2(arr, time2) {
var toWorldMat = this.getMatrix(time2);
return this.invertPoint(toWorldMat, arr);
}
function applyPoint(matrix, arr) {
if (this._elem.hierarchy && this._elem.hierarchy.length) {
var i;
var len = this._elem.hierarchy.length;
for (i = 0; i < len; i += 1) {
this._elem.hierarchy[i].finalTransform.mProp.applyToMatrix(matrix);
}
}
return matrix.applyToPointArray(arr[0], arr[1], arr[2] || 0);
}
function invertPoint(matrix, arr) {
if (this._elem.hierarchy && this._elem.hierarchy.length) {
var i;
var len = this._elem.hierarchy.length;
for (i = 0; i < len; i += 1) {
this._elem.hierarchy[i].finalTransform.mProp.applyToMatrix(matrix);
}
}
return matrix.inversePoint(arr);
}
function fromComp2(arr) {
var toWorldMat = new Matrix();
toWorldMat.reset();
this._elem.finalTransform.mProp.applyToMatrix(toWorldMat);
if (this._elem.hierarchy && this._elem.hierarchy.length) {
var i;
var len = this._elem.hierarchy.length;
for (i = 0; i < len; i += 1) {
this._elem.hierarchy[i].finalTransform.mProp.applyToMatrix(toWorldMat);
}
return toWorldMat.inversePoint(arr);
}
return toWorldMat.inversePoint(arr);
}
function sampleImage() {
return [1, 1, 1, 1];
}
return function(elem2) {
var transformInterface;
function _registerMaskInterface(maskManager) {
_thisLayerFunction.mask = new MaskManagerInterface(maskManager, elem2);
}
function _registerEffectsInterface(effects) {
_thisLayerFunction.effect = effects;
}
function _thisLayerFunction(name2) {
switch (name2) {
case "ADBE Root Vectors Group":
case "Contents":
case 2:
return _thisLayerFunction.shapeInterface;
case 1:
case 6:
case "Transform":
case "transform":
case "ADBE Transform Group":
return transformInterface;
case 4:
case "ADBE Effect Parade":
case "effects":
case "Effects":
return _thisLayerFunction.effect;
case "ADBE Text Properties":
return _thisLayerFunction.textInterface;
default:
return null;
}
}
_thisLayerFunction.getMatrix = getMatrix;
_thisLayerFunction.invertPoint = invertPoint;
_thisLayerFunction.applyPoint = applyPoint;
_thisLayerFunction.toWorld = toWorld2;
_thisLayerFunction.toWorldVec = toWorldVec;
_thisLayerFunction.fromWorld = fromWorld2;
_thisLayerFunction.fromWorldVec = fromWorldVec;
_thisLayerFunction.toComp = toWorld2;
_thisLayerFunction.fromComp = fromComp2;
_thisLayerFunction.sampleImage = sampleImage;
_thisLayerFunction.sourceRectAtTime = elem2.sourceRectAtTime.bind(elem2);
_thisLayerFunction._elem = elem2;
transformInterface = TransformExpressionInterface(elem2.finalTransform.mProp);
var anchorPointDescriptor = getDescriptor(transformInterface, "anchorPoint");
Object.defineProperties(_thisLayerFunction, {
hasParent: {
get: function get() {
return elem2.hierarchy.length;
}
},
parent: {
get: function get() {
return elem2.hierarchy[0].layerInterface;
}
},
rotation: getDescriptor(transformInterface, "rotation"),
scale: getDescriptor(transformInterface, "scale"),
position: getDescriptor(transformInterface, "position"),
opacity: getDescriptor(transformInterface, "opacity"),
anchorPoint: anchorPointDescriptor,
anchor_point: anchorPointDescriptor,
transform: {
get: function get() {
return transformInterface;
}
},
active: {
get: function get() {
return elem2.isInRange;
}
}
});
_thisLayerFunction.startTime = elem2.data.st;
_thisLayerFunction.index = elem2.data.ind;
_thisLayerFunction.source = elem2.data.refId;
_thisLayerFunction.height = elem2.data.ty === 0 ? elem2.data.h : 100;
_thisLayerFunction.width = elem2.data.ty === 0 ? elem2.data.w : 100;
_thisLayerFunction.inPoint = elem2.data.ip / elem2.comp.globalData.frameRate;
_thisLayerFunction.outPoint = elem2.data.op / elem2.comp.globalData.frameRate;
_thisLayerFunction._name = elem2.data.nm;
_thisLayerFunction.registerMaskInterface = _registerMaskInterface;
_thisLayerFunction.registerEffectsInterface = _registerEffectsInterface;
return _thisLayerFunction;
};
}();
var propertyGroupFactory = /* @__PURE__ */ function() {
return function(interfaceFunction, parentPropertyGroup) {
return function(val2) {
val2 = val2 === void 0 ? 1 : val2;
if (val2 <= 0) {
return interfaceFunction;
}
return parentPropertyGroup(val2 - 1);
};
};
}();
var PropertyInterface = /* @__PURE__ */ function() {
return function(propertyName, propertyGroup) {
var interfaceFunction = {
_name: propertyName
};
function _propertyGroup(val2) {
val2 = val2 === void 0 ? 1 : val2;
if (val2 <= 0) {
return interfaceFunction;
}
return propertyGroup(val2 - 1);
}
return _propertyGroup;
};
}();
var EffectsExpressionInterface = /* @__PURE__ */ function() {
var ob2 = {
createEffectsInterface
};
function createEffectsInterface(elem2, propertyGroup) {
if (elem2.effectsManager) {
var effectElements = [];
var effectsData = elem2.data.ef;
var i;
var len = elem2.effectsManager.effectElements.length;
for (i = 0; i < len; i += 1) {
effectElements.push(createGroupInterface(effectsData[i], elem2.effectsManager.effectElements[i], propertyGroup, elem2));
}
var effects = elem2.data.ef || [];
var groupInterface = function groupInterface2(name2) {
i = 0;
len = effects.length;
while (i < len) {
if (name2 === effects[i].nm || name2 === effects[i].mn || name2 === effects[i].ix) {
return effectElements[i];
}
i += 1;
}
return null;
};
Object.defineProperty(groupInterface, "numProperties", {
get: function get() {
return effects.length;
}
});
return groupInterface;
}
return null;
}
function createGroupInterface(data2, elements, propertyGroup, elem2) {
function groupInterface(name2) {
var effects = data2.ef;
var i2 = 0;
var len2 = effects.length;
while (i2 < len2) {
if (name2 === effects[i2].nm || name2 === effects[i2].mn || name2 === effects[i2].ix) {
if (effects[i2].ty === 5) {
return effectElements[i2];
}
return effectElements[i2]();
}
i2 += 1;
}
throw new Error();
}
var _propertyGroup = propertyGroupFactory(groupInterface, propertyGroup);
var effectElements = [];
var i;
var len = data2.ef.length;
for (i = 0; i < len; i += 1) {
if (data2.ef[i].ty === 5) {
effectElements.push(createGroupInterface(data2.ef[i], elements.effectElements[i], elements.effectElements[i].propertyGroup, elem2));
} else {
effectElements.push(createValueInterface(elements.effectElements[i], data2.ef[i].ty, elem2, _propertyGroup));
}
}
if (data2.mn === "ADBE Color Control") {
Object.defineProperty(groupInterface, "color", {
get: function get() {
return effectElements[0]();
}
});
}
Object.defineProperties(groupInterface, {
numProperties: {
get: function get() {
return data2.np;
}
},
_name: {
value: data2.nm
},
propertyGroup: {
value: _propertyGroup
}
});
groupInterface.enabled = data2.en !== 0;
groupInterface.active = groupInterface.enabled;
return groupInterface;
}
function createValueInterface(element, type, elem2, propertyGroup) {
var expressionProperty = ExpressionPropertyInterface(element.p);
function interfaceFunction() {
if (type === 10) {
return elem2.comp.compInterface(element.p.v);
}
return expressionProperty();
}
if (element.p.setGroupProperty) {
element.p.setGroupProperty(PropertyInterface("", propertyGroup));
}
return interfaceFunction;
}
return ob2;
}();
var ShapePathInterface = /* @__PURE__ */ function() {
return function pathInterfaceFactory(shape, view, propertyGroup) {
var prop = view.sh;
function interfaceFunction(val2) {
if (val2 === "Shape" || val2 === "shape" || val2 === "Path" || val2 === "path" || val2 === "ADBE Vector Shape" || val2 === 2) {
return interfaceFunction.path;
}
return null;
}
var _propertyGroup = propertyGroupFactory(interfaceFunction, propertyGroup);
prop.setGroupProperty(PropertyInterface("Path", _propertyGroup));
Object.defineProperties(interfaceFunction, {
path: {
get: function get() {
if (prop.k) {
prop.getValue();
}
return prop;
}
},
shape: {
get: function get() {
if (prop.k) {
prop.getValue();
}
return prop;
}
},
_name: {
value: shape.nm
},
ix: {
value: shape.ix
},
propertyIndex: {
value: shape.ix
},
mn: {
value: shape.mn
},
propertyGroup: {
value: propertyGroup
}
});
return interfaceFunction;
};
}();
var ShapeExpressionInterface = /* @__PURE__ */ function() {
function iterateElements(shapes, view, propertyGroup) {
var arr = [];
var i;
var len = shapes ? shapes.length : 0;
for (i = 0; i < len; i += 1) {
if (shapes[i].ty === "gr") {
arr.push(groupInterfaceFactory(shapes[i], view[i], propertyGroup));
} else if (shapes[i].ty === "fl") {
arr.push(fillInterfaceFactory(shapes[i], view[i], propertyGroup));
} else if (shapes[i].ty === "st") {
arr.push(strokeInterfaceFactory(shapes[i], view[i], propertyGroup));
} else if (shapes[i].ty === "tm") {
arr.push(trimInterfaceFactory(shapes[i], view[i], propertyGroup));
} else if (shapes[i].ty === "tr") {
} else if (shapes[i].ty === "el") {
arr.push(ellipseInterfaceFactory(shapes[i], view[i], propertyGroup));
} else if (shapes[i].ty === "sr") {
arr.push(starInterfaceFactory(shapes[i], view[i], propertyGroup));
} else if (shapes[i].ty === "sh") {
arr.push(ShapePathInterface(shapes[i], view[i], propertyGroup));
} else if (shapes[i].ty === "rc") {
arr.push(rectInterfaceFactory(shapes[i], view[i], propertyGroup));
} else if (shapes[i].ty === "rd") {
arr.push(roundedInterfaceFactory(shapes[i], view[i], propertyGroup));
} else if (shapes[i].ty === "rp") {
arr.push(repeaterInterfaceFactory(shapes[i], view[i], propertyGroup));
} else if (shapes[i].ty === "gf") {
arr.push(gradientFillInterfaceFactory(shapes[i], view[i], propertyGroup));
} else {
arr.push(defaultInterfaceFactory(shapes[i], view[i], propertyGroup));
}
}
return arr;
}
function contentsInterfaceFactory(shape, view, propertyGroup) {
var interfaces2;
var interfaceFunction = function _interfaceFunction(value2) {
var i = 0;
var len = interfaces2.length;
while (i < len) {
if (interfaces2[i]._name === value2 || interfaces2[i].mn === value2 || interfaces2[i].propertyIndex === value2 || interfaces2[i].ix === value2 || interfaces2[i].ind === value2) {
return interfaces2[i];
}
i += 1;
}
if (typeof value2 === "number") {
return interfaces2[value2 - 1];
}
return null;
};
interfaceFunction.propertyGroup = propertyGroupFactory(interfaceFunction, propertyGroup);
interfaces2 = iterateElements(shape.it, view.it, interfaceFunction.propertyGroup);
interfaceFunction.numProperties = interfaces2.length;
var transformInterface = transformInterfaceFactory(shape.it[shape.it.length - 1], view.it[view.it.length - 1], interfaceFunction.propertyGroup);
interfaceFunction.transform = transformInterface;
interfaceFunction.propertyIndex = shape.cix;
interfaceFunction._name = shape.nm;
return interfaceFunction;
}
function groupInterfaceFactory(shape, view, propertyGroup) {
var interfaceFunction = function _interfaceFunction(value2) {
switch (value2) {
case "ADBE Vectors Group":
case "Contents":
case 2:
return interfaceFunction.content;
default:
return interfaceFunction.transform;
}
};
interfaceFunction.propertyGroup = propertyGroupFactory(interfaceFunction, propertyGroup);
var content2 = contentsInterfaceFactory(shape, view, interfaceFunction.propertyGroup);
var transformInterface = transformInterfaceFactory(shape.it[shape.it.length - 1], view.it[view.it.length - 1], interfaceFunction.propertyGroup);
interfaceFunction.content = content2;
interfaceFunction.transform = transformInterface;
Object.defineProperty(interfaceFunction, "_name", {
get: function get() {
return shape.nm;
}
});
interfaceFunction.numProperties = shape.np;
interfaceFunction.propertyIndex = shape.ix;
interfaceFunction.nm = shape.nm;
interfaceFunction.mn = shape.mn;
return interfaceFunction;
}
function fillInterfaceFactory(shape, view, propertyGroup) {
function interfaceFunction(val2) {
if (val2 === "Color" || val2 === "color") {
return interfaceFunction.color;
}
if (val2 === "Opacity" || val2 === "opacity") {
return interfaceFunction.opacity;
}
return null;
}
Object.defineProperties(interfaceFunction, {
color: {
get: ExpressionPropertyInterface(view.c)
},
opacity: {
get: ExpressionPropertyInterface(view.o)
},
_name: {
value: shape.nm
},
mn: {
value: shape.mn
}
});
view.c.setGroupProperty(PropertyInterface("Color", propertyGroup));
view.o.setGroupProperty(PropertyInterface("Opacity", propertyGroup));
return interfaceFunction;
}
function gradientFillInterfaceFactory(shape, view, propertyGroup) {
function interfaceFunction(val2) {
if (val2 === "Start Point" || val2 === "start point") {
return interfaceFunction.startPoint;
}
if (val2 === "End Point" || val2 === "end point") {
return interfaceFunction.endPoint;
}
if (val2 === "Opacity" || val2 === "opacity") {
return interfaceFunction.opacity;
}
return null;
}
Object.defineProperties(interfaceFunction, {
startPoint: {
get: ExpressionPropertyInterface(view.s)
},
endPoint: {
get: ExpressionPropertyInterface(view.e)
},
opacity: {
get: ExpressionPropertyInterface(view.o)
},
type: {
get: function get() {
return "a";
}
},
_name: {
value: shape.nm
},
mn: {
value: shape.mn
}
});
view.s.setGroupProperty(PropertyInterface("Start Point", propertyGroup));
view.e.setGroupProperty(PropertyInterface("End Point", propertyGroup));
view.o.setGroupProperty(PropertyInterface("Opacity", propertyGroup));
return interfaceFunction;
}
function defaultInterfaceFactory() {
function interfaceFunction() {
return null;
}
return interfaceFunction;
}
function strokeInterfaceFactory(shape, view, propertyGroup) {
var _propertyGroup = propertyGroupFactory(interfaceFunction, propertyGroup);
var _dashPropertyGroup = propertyGroupFactory(dashOb, _propertyGroup);
function addPropertyToDashOb(i2) {
Object.defineProperty(dashOb, shape.d[i2].nm, {
get: ExpressionPropertyInterface(view.d.dataProps[i2].p)
});
}
var i;
var len = shape.d ? shape.d.length : 0;
var dashOb = {};
for (i = 0; i < len; i += 1) {
addPropertyToDashOb(i);
view.d.dataProps[i].p.setGroupProperty(_dashPropertyGroup);
}
function interfaceFunction(val2) {
if (val2 === "Color" || val2 === "color") {
return interfaceFunction.color;
}
if (val2 === "Opacity" || val2 === "opacity") {
return interfaceFunction.opacity;
}
if (val2 === "Stroke Width" || val2 === "stroke width") {
return interfaceFunction.strokeWidth;
}
return null;
}
Object.defineProperties(interfaceFunction, {
color: {
get: ExpressionPropertyInterface(view.c)
},
opacity: {
get: ExpressionPropertyInterface(view.o)
},
strokeWidth: {
get: ExpressionPropertyInterface(view.w)
},
dash: {
get: function get() {
return dashOb;
}
},
_name: {
value: shape.nm
},
mn: {
value: shape.mn
}
});
view.c.setGroupProperty(PropertyInterface("Color", _propertyGroup));
view.o.setGroupProperty(PropertyInterface("Opacity", _propertyGroup));
view.w.setGroupProperty(PropertyInterface("Stroke Width", _propertyGroup));
return interfaceFunction;
}
function trimInterfaceFactory(shape, view, propertyGroup) {
function interfaceFunction(val2) {
if (val2 === shape.e.ix || val2 === "End" || val2 === "end") {
return interfaceFunction.end;
}
if (val2 === shape.s.ix) {
return interfaceFunction.start;
}
if (val2 === shape.o.ix) {
return interfaceFunction.offset;
}
return null;
}
var _propertyGroup = propertyGroupFactory(interfaceFunction, propertyGroup);
interfaceFunction.propertyIndex = shape.ix;
view.s.setGroupProperty(PropertyInterface("Start", _propertyGroup));
view.e.setGroupProperty(PropertyInterface("End", _propertyGroup));
view.o.setGroupProperty(PropertyInterface("Offset", _propertyGroup));
interfaceFunction.propertyIndex = shape.ix;
interfaceFunction.propertyGroup = propertyGroup;
Object.defineProperties(interfaceFunction, {
start: {
get: ExpressionPropertyInterface(view.s)
},
end: {
get: ExpressionPropertyInterface(view.e)
},
offset: {
get: ExpressionPropertyInterface(view.o)
},
_name: {
value: shape.nm
}
});
interfaceFunction.mn = shape.mn;
return interfaceFunction;
}
function transformInterfaceFactory(shape, view, propertyGroup) {
function interfaceFunction(value2) {
if (shape.a.ix === value2 || value2 === "Anchor Point") {
return interfaceFunction.anchorPoint;
}
if (shape.o.ix === value2 || value2 === "Opacity") {
return interfaceFunction.opacity;
}
if (shape.p.ix === value2 || value2 === "Position") {
return interfaceFunction.position;
}
if (shape.r.ix === value2 || value2 === "Rotation" || value2 === "ADBE Vector Rotation") {
return interfaceFunction.rotation;
}
if (shape.s.ix === value2 || value2 === "Scale") {
return interfaceFunction.scale;
}
if (shape.sk && shape.sk.ix === value2 || value2 === "Skew") {
return interfaceFunction.skew;
}
if (shape.sa && shape.sa.ix === value2 || value2 === "Skew Axis") {
return interfaceFunction.skewAxis;
}
return null;
}
var _propertyGroup = propertyGroupFactory(interfaceFunction, propertyGroup);
view.transform.mProps.o.setGroupProperty(PropertyInterface("Opacity", _propertyGroup));
view.transform.mProps.p.setGroupProperty(PropertyInterface("Position", _propertyGroup));
view.transform.mProps.a.setGroupProperty(PropertyInterface("Anchor Point", _propertyGroup));
view.transform.mProps.s.setGroupProperty(PropertyInterface("Scale", _propertyGroup));
view.transform.mProps.r.setGroupProperty(PropertyInterface("Rotation", _propertyGroup));
if (view.transform.mProps.sk) {
view.transform.mProps.sk.setGroupProperty(PropertyInterface("Skew", _propertyGroup));
view.transform.mProps.sa.setGroupProperty(PropertyInterface("Skew Angle", _propertyGroup));
}
view.transform.op.setGroupProperty(PropertyInterface("Opacity", _propertyGroup));
Object.defineProperties(interfaceFunction, {
opacity: {
get: ExpressionPropertyInterface(view.transform.mProps.o)
},
position: {
get: ExpressionPropertyInterface(view.transform.mProps.p)
},
anchorPoint: {
get: ExpressionPropertyInterface(view.transform.mProps.a)
},
scale: {
get: ExpressionPropertyInterface(view.transform.mProps.s)
},
rotation: {
get: ExpressionPropertyInterface(view.transform.mProps.r)
},
skew: {
get: ExpressionPropertyInterface(view.transform.mProps.sk)
},
skewAxis: {
get: ExpressionPropertyInterface(view.transform.mProps.sa)
},
_name: {
value: shape.nm
}
});
interfaceFunction.ty = "tr";
interfaceFunction.mn = shape.mn;
interfaceFunction.propertyGroup = propertyGroup;
return interfaceFunction;
}
function ellipseInterfaceFactory(shape, view, propertyGroup) {
function interfaceFunction(value2) {
if (shape.p.ix === value2) {
return interfaceFunction.position;
}
if (shape.s.ix === value2) {
return interfaceFunction.size;
}
return null;
}
var _propertyGroup = propertyGroupFactory(interfaceFunction, propertyGroup);
interfaceFunction.propertyIndex = shape.ix;
var prop = view.sh.ty === "tm" ? view.sh.prop : view.sh;
prop.s.setGroupProperty(PropertyInterface("Size", _propertyGroup));
prop.p.setGroupProperty(PropertyInterface("Position", _propertyGroup));
Object.defineProperties(interfaceFunction, {
size: {
get: ExpressionPropertyInterface(prop.s)
},
position: {
get: ExpressionPropertyInterface(prop.p)
},
_name: {
value: shape.nm
}
});
interfaceFunction.mn = shape.mn;
return interfaceFunction;
}
function starInterfaceFactory(shape, view, propertyGroup) {
function interfaceFunction(value2) {
if (shape.p.ix === value2) {
return interfaceFunction.position;
}
if (shape.r.ix === value2) {
return interfaceFunction.rotation;
}
if (shape.pt.ix === value2) {
return interfaceFunction.points;
}
if (shape.or.ix === value2 || value2 === "ADBE Vector Star Outer Radius") {
return interfaceFunction.outerRadius;
}
if (shape.os.ix === value2) {
return interfaceFunction.outerRoundness;
}
if (shape.ir && (shape.ir.ix === value2 || value2 === "ADBE Vector Star Inner Radius")) {
return interfaceFunction.innerRadius;
}
if (shape.is && shape.is.ix === value2) {
return interfaceFunction.innerRoundness;
}
return null;
}
var _propertyGroup = propertyGroupFactory(interfaceFunction, propertyGroup);
var prop = view.sh.ty === "tm" ? view.sh.prop : view.sh;
interfaceFunction.propertyIndex = shape.ix;
prop.or.setGroupProperty(PropertyInterface("Outer Radius", _propertyGroup));
prop.os.setGroupProperty(PropertyInterface("Outer Roundness", _propertyGroup));
prop.pt.setGroupProperty(PropertyInterface("Points", _propertyGroup));
prop.p.setGroupProperty(PropertyInterface("Position", _propertyGroup));
prop.r.setGroupProperty(PropertyInterface("Rotation", _propertyGroup));
if (shape.ir) {
prop.ir.setGroupProperty(PropertyInterface("Inner Radius", _propertyGroup));
prop.is.setGroupProperty(PropertyInterface("Inner Roundness", _propertyGroup));
}
Object.defineProperties(interfaceFunction, {
position: {
get: ExpressionPropertyInterface(prop.p)
},
rotation: {
get: ExpressionPropertyInterface(prop.r)
},
points: {
get: ExpressionPropertyInterface(prop.pt)
},
outerRadius: {
get: ExpressionPropertyInterface(prop.or)
},
outerRoundness: {
get: ExpressionPropertyInterface(prop.os)
},
innerRadius: {
get: ExpressionPropertyInterface(prop.ir)
},
innerRoundness: {
get: ExpressionPropertyInterface(prop.is)
},
_name: {
value: shape.nm
}
});
interfaceFunction.mn = shape.mn;
return interfaceFunction;
}
function rectInterfaceFactory(shape, view, propertyGroup) {
function interfaceFunction(value2) {
if (shape.p.ix === value2) {
return interfaceFunction.position;
}
if (shape.r.ix === value2) {
return interfaceFunction.roundness;
}
if (shape.s.ix === value2 || value2 === "Size" || value2 === "ADBE Vector Rect Size") {
return interfaceFunction.size;
}
return null;
}
var _propertyGroup = propertyGroupFactory(interfaceFunction, propertyGroup);
var prop = view.sh.ty === "tm" ? view.sh.prop : view.sh;
interfaceFunction.propertyIndex = shape.ix;
prop.p.setGroupProperty(PropertyInterface("Position", _propertyGroup));
prop.s.setGroupProperty(PropertyInterface("Size", _propertyGroup));
prop.r.setGroupProperty(PropertyInterface("Rotation", _propertyGroup));
Object.defineProperties(interfaceFunction, {
position: {
get: ExpressionPropertyInterface(prop.p)
},
roundness: {
get: ExpressionPropertyInterface(prop.r)
},
size: {
get: ExpressionPropertyInterface(prop.s)
},
_name: {
value: shape.nm
}
});
interfaceFunction.mn = shape.mn;
return interfaceFunction;
}
function roundedInterfaceFactory(shape, view, propertyGroup) {
function interfaceFunction(value2) {
if (shape.r.ix === value2 || value2 === "Round Corners 1") {
return interfaceFunction.radius;
}
return null;
}
var _propertyGroup = propertyGroupFactory(interfaceFunction, propertyGroup);
var prop = view;
interfaceFunction.propertyIndex = shape.ix;
prop.rd.setGroupProperty(PropertyInterface("Radius", _propertyGroup));
Object.defineProperties(interfaceFunction, {
radius: {
get: ExpressionPropertyInterface(prop.rd)
},
_name: {
value: shape.nm
}
});
interfaceFunction.mn = shape.mn;
return interfaceFunction;
}
function repeaterInterfaceFactory(shape, view, propertyGroup) {
function interfaceFunction(value2) {
if (shape.c.ix === value2 || value2 === "Copies") {
return interfaceFunction.copies;
}
if (shape.o.ix === value2 || value2 === "Offset") {
return interfaceFunction.offset;
}
return null;
}
var _propertyGroup = propertyGroupFactory(interfaceFunction, propertyGroup);
var prop = view;
interfaceFunction.propertyIndex = shape.ix;
prop.c.setGroupProperty(PropertyInterface("Copies", _propertyGroup));
prop.o.setGroupProperty(PropertyInterface("Offset", _propertyGroup));
Object.defineProperties(interfaceFunction, {
copies: {
get: ExpressionPropertyInterface(prop.c)
},
offset: {
get: ExpressionPropertyInterface(prop.o)
},
_name: {
value: shape.nm
}
});
interfaceFunction.mn = shape.mn;
return interfaceFunction;
}
return function(shapes, view, propertyGroup) {
var interfaces2;
function _interfaceFunction(value2) {
if (typeof value2 === "number") {
value2 = value2 === void 0 ? 1 : value2;
if (value2 === 0) {
return propertyGroup;
}
return interfaces2[value2 - 1];
}
var i = 0;
var len = interfaces2.length;
while (i < len) {
if (interfaces2[i]._name === value2) {
return interfaces2[i];
}
i += 1;
}
return null;
}
function parentGroupWrapper() {
return propertyGroup;
}
_interfaceFunction.propertyGroup = propertyGroupFactory(_interfaceFunction, parentGroupWrapper);
interfaces2 = iterateElements(shapes, view, _interfaceFunction.propertyGroup);
_interfaceFunction.numProperties = interfaces2.length;
_interfaceFunction._name = "Contents";
return _interfaceFunction;
};
}();
var TextExpressionInterface = /* @__PURE__ */ function() {
return function(elem2) {
var _sourceText;
function _thisLayerFunction(name2) {
switch (name2) {
case "ADBE Text Document":
return _thisLayerFunction.sourceText;
default:
return null;
}
}
Object.defineProperty(_thisLayerFunction, "sourceText", {
get: function get() {
elem2.textProperty.getValue();
var stringValue = elem2.textProperty.currentData.t;
if (!_sourceText || stringValue !== _sourceText.value) {
_sourceText = new String(stringValue);
_sourceText.value = stringValue || new String(stringValue);
Object.defineProperty(_sourceText, "style", {
get: function get2() {
return {
fillColor: elem2.textProperty.currentData.fc
};
}
});
}
return _sourceText;
}
});
return _thisLayerFunction;
};
}();
function _typeof(obj) {
"@babel/helpers - typeof";
if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
_typeof = function _typeof2(obj2) {
return typeof obj2;
};
} else {
_typeof = function _typeof2(obj2) {
return obj2 && typeof Symbol === "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
};
}
return _typeof(obj);
}
var FootageInterface = /* @__PURE__ */ function() {
var outlineInterfaceFactory = function outlineInterfaceFactory2(elem2) {
var currentPropertyName = "";
var currentProperty = elem2.getFootageData();
function init() {
currentPropertyName = "";
currentProperty = elem2.getFootageData();
return searchProperty;
}
function searchProperty(value2) {
if (currentProperty[value2]) {
currentPropertyName = value2;
currentProperty = currentProperty[value2];
if (_typeof(currentProperty) === "object") {
return searchProperty;
}
return currentProperty;
}
var propertyNameIndex = value2.indexOf(currentPropertyName);
if (propertyNameIndex !== -1) {
var index2 = parseInt(value2.substr(propertyNameIndex + currentPropertyName.length), 10);
currentProperty = currentProperty[index2];
if (_typeof(currentProperty) === "object") {
return searchProperty;
}
return currentProperty;
}
return "";
}
return init;
};
var dataInterfaceFactory = function dataInterfaceFactory2(elem2) {
function interfaceFunction(value2) {
if (value2 === "Outline") {
return interfaceFunction.outlineInterface();
}
return null;
}
interfaceFunction._name = "Outline";
interfaceFunction.outlineInterface = outlineInterfaceFactory(elem2);
return interfaceFunction;
};
return function(elem2) {
function _interfaceFunction(value2) {
if (value2 === "Data") {
return _interfaceFunction.dataInterface;
}
return null;
}
_interfaceFunction._name = "Data";
_interfaceFunction.dataInterface = dataInterfaceFactory(elem2);
return _interfaceFunction;
};
}();
var interfaces = {
layer: LayerExpressionInterface,
effects: EffectsExpressionInterface,
comp: CompExpressionInterface,
shape: ShapeExpressionInterface,
text: TextExpressionInterface,
footage: FootageInterface
};
function getInterface(type) {
return interfaces[type] || null;
}
var expressionHelpers = /* @__PURE__ */ function() {
function searchExpressions(elem2, data2, prop) {
if (data2.x) {
prop.k = true;
prop.x = true;
prop.initiateExpression = ExpressionManager.initiateExpression;
prop.effectsSequence.push(prop.initiateExpression(elem2, data2, prop).bind(prop));
}
}
function getValueAtTime(frameNum) {
frameNum *= this.elem.globalData.frameRate;
frameNum -= this.offsetTime;
if (frameNum !== this._cachingAtTime.lastFrame) {
this._cachingAtTime.lastIndex = this._cachingAtTime.lastFrame < frameNum ? this._cachingAtTime.lastIndex : 0;
this._cachingAtTime.value = this.interpolateValue(frameNum, this._cachingAtTime);
this._cachingAtTime.lastFrame = frameNum;
}
return this._cachingAtTime.value;
}
function getSpeedAtTime(frameNum) {
var delta = -0.01;
var v1 = this.getValueAtTime(frameNum);
var v2 = this.getValueAtTime(frameNum + delta);
var speed = 0;
if (v1.length) {
var i;
for (i = 0; i < v1.length; i += 1) {
speed += Math.pow(v2[i] - v1[i], 2);
}
speed = Math.sqrt(speed) * 100;
} else {
speed = 0;
}
return speed;
}
function getVelocityAtTime(frameNum) {
if (this.vel !== void 0) {
return this.vel;
}
var delta = -1e-3;
var v1 = this.getValueAtTime(frameNum);
var v2 = this.getValueAtTime(frameNum + delta);
var velocity2;
if (v1.length) {
velocity2 = createTypedArray("float32", v1.length);
var i;
for (i = 0; i < v1.length; i += 1) {
velocity2[i] = (v2[i] - v1[i]) / delta;
}
} else {
velocity2 = (v2 - v1) / delta;
}
return velocity2;
}
function getStaticValueAtTime() {
return this.pv;
}
function setGroupProperty(propertyGroup) {
this.propertyGroup = propertyGroup;
}
return {
searchExpressions,
getSpeedAtTime,
getVelocityAtTime,
getValueAtTime,
getStaticValueAtTime,
setGroupProperty
};
}();
function addPropertyDecorator() {
function loopOut2(type, duration, durationFlag) {
if (!this.k || !this.keyframes) {
return this.pv;
}
type = type ? type.toLowerCase() : "";
var currentFrame = this.comp.renderedFrame;
var keyframes = this.keyframes;
var lastKeyFrame = keyframes[keyframes.length - 1].t;
if (currentFrame <= lastKeyFrame) {
return this.pv;
}
var cycleDuration;
var firstKeyFrame;
if (!durationFlag) {
if (!duration || duration > keyframes.length - 1) {
duration = keyframes.length - 1;
}
firstKeyFrame = keyframes[keyframes.length - 1 - duration].t;
cycleDuration = lastKeyFrame - firstKeyFrame;
} else {
if (!duration) {
cycleDuration = Math.max(0, lastKeyFrame - this.elem.data.ip);
} else {
cycleDuration = Math.abs(lastKeyFrame - this.elem.comp.globalData.frameRate * duration);
}
firstKeyFrame = lastKeyFrame - cycleDuration;
}
var i;
var len;
var ret;
if (type === "pingpong") {
var iterations = Math.floor((currentFrame - firstKeyFrame) / cycleDuration);
if (iterations % 2 !== 0) {
return this.getValueAtTime((cycleDuration - (currentFrame - firstKeyFrame) % cycleDuration + firstKeyFrame) / this.comp.globalData.frameRate, 0);
}
} else if (type === "offset") {
var initV = this.getValueAtTime(firstKeyFrame / this.comp.globalData.frameRate, 0);
var endV = this.getValueAtTime(lastKeyFrame / this.comp.globalData.frameRate, 0);
var current = this.getValueAtTime(((currentFrame - firstKeyFrame) % cycleDuration + firstKeyFrame) / this.comp.globalData.frameRate, 0);
var repeats = Math.floor((currentFrame - firstKeyFrame) / cycleDuration);
if (this.pv.length) {
ret = new Array(initV.length);
len = ret.length;
for (i = 0; i < len; i += 1) {
ret[i] = (endV[i] - initV[i]) * repeats + current[i];
}
return ret;
}
return (endV - initV) * repeats + current;
} else if (type === "continue") {
var lastValue = this.getValueAtTime(lastKeyFrame / this.comp.globalData.frameRate, 0);
var nextLastValue = this.getValueAtTime((lastKeyFrame - 1e-3) / this.comp.globalData.frameRate, 0);
if (this.pv.length) {
ret = new Array(lastValue.length);
len = ret.length;
for (i = 0; i < len; i += 1) {
ret[i] = lastValue[i] + (lastValue[i] - nextLastValue[i]) * ((currentFrame - lastKeyFrame) / this.comp.globalData.frameRate) / 5e-4;
}
return ret;
}
return lastValue + (lastValue - nextLastValue) * ((currentFrame - lastKeyFrame) / 1e-3);
}
return this.getValueAtTime(((currentFrame - firstKeyFrame) % cycleDuration + firstKeyFrame) / this.comp.globalData.frameRate, 0);
}
function loopIn2(type, duration, durationFlag) {
if (!this.k) {
return this.pv;
}
type = type ? type.toLowerCase() : "";
var currentFrame = this.comp.renderedFrame;
var keyframes = this.keyframes;
var firstKeyFrame = keyframes[0].t;
if (currentFrame >= firstKeyFrame) {
return this.pv;
}
var cycleDuration;
var lastKeyFrame;
if (!durationFlag) {
if (!duration || duration > keyframes.length - 1) {
duration = keyframes.length - 1;
}
lastKeyFrame = keyframes[duration].t;
cycleDuration = lastKeyFrame - firstKeyFrame;
} else {
if (!duration) {
cycleDuration = Math.max(0, this.elem.data.op - firstKeyFrame);
} else {
cycleDuration = Math.abs(this.elem.comp.globalData.frameRate * duration);
}
lastKeyFrame = firstKeyFrame + cycleDuration;
}
var i;
var len;
var ret;
if (type === "pingpong") {
var iterations = Math.floor((firstKeyFrame - currentFrame) / cycleDuration);
if (iterations % 2 === 0) {
return this.getValueAtTime(((firstKeyFrame - currentFrame) % cycleDuration + firstKeyFrame) / this.comp.globalData.frameRate, 0);
}
} else if (type === "offset") {
var initV = this.getValueAtTime(firstKeyFrame / this.comp.globalData.frameRate, 0);
var endV = this.getValueAtTime(lastKeyFrame / this.comp.globalData.frameRate, 0);
var current = this.getValueAtTime((cycleDuration - (firstKeyFrame - currentFrame) % cycleDuration + firstKeyFrame) / this.comp.globalData.frameRate, 0);
var repeats = Math.floor((firstKeyFrame - currentFrame) / cycleDuration) + 1;
if (this.pv.length) {
ret = new Array(initV.length);
len = ret.length;
for (i = 0; i < len; i += 1) {
ret[i] = current[i] - (endV[i] - initV[i]) * repeats;
}
return ret;
}
return current - (endV - initV) * repeats;
} else if (type === "continue") {
var firstValue = this.getValueAtTime(firstKeyFrame / this.comp.globalData.frameRate, 0);
var nextFirstValue = this.getValueAtTime((firstKeyFrame + 1e-3) / this.comp.globalData.frameRate, 0);
if (this.pv.length) {
ret = new Array(firstValue.length);
len = ret.length;
for (i = 0; i < len; i += 1) {
ret[i] = firstValue[i] + (firstValue[i] - nextFirstValue[i]) * (firstKeyFrame - currentFrame) / 1e-3;
}
return ret;
}
return firstValue + (firstValue - nextFirstValue) * (firstKeyFrame - currentFrame) / 1e-3;
}
return this.getValueAtTime((cycleDuration - ((firstKeyFrame - currentFrame) % cycleDuration + firstKeyFrame)) / this.comp.globalData.frameRate, 0);
}
function smooth2(width2, samples) {
if (!this.k) {
return this.pv;
}
width2 = (width2 || 0.4) * 0.5;
samples = Math.floor(samples || 5);
if (samples <= 1) {
return this.pv;
}
var currentTime = this.comp.renderedFrame / this.comp.globalData.frameRate;
var initFrame2 = currentTime - width2;
var endFrame = currentTime + width2;
var sampleFrequency = samples > 1 ? (endFrame - initFrame2) / (samples - 1) : 1;
var i = 0;
var j = 0;
var value2;
if (this.pv.length) {
value2 = createTypedArray("float32", this.pv.length);
} else {
value2 = 0;
}
var sampleValue;
while (i < samples) {
sampleValue = this.getValueAtTime(initFrame2 + i * sampleFrequency);
if (this.pv.length) {
for (j = 0; j < this.pv.length; j += 1) {
value2[j] += sampleValue[j];
}
} else {
value2 += sampleValue;
}
i += 1;
}
if (this.pv.length) {
for (j = 0; j < this.pv.length; j += 1) {
value2[j] /= samples;
}
} else {
value2 /= samples;
}
return value2;
}
function getTransformValueAtTime(time2) {
if (!this._transformCachingAtTime) {
this._transformCachingAtTime = {
v: new Matrix()
};
}
var matrix = this._transformCachingAtTime.v;
matrix.cloneFromProps(this.pre.props);
if (this.appliedTransformations < 1) {
var anchor = this.a.getValueAtTime(time2);
matrix.translate(-anchor[0] * this.a.mult, -anchor[1] * this.a.mult, anchor[2] * this.a.mult);
}
if (this.appliedTransformations < 2) {
var scale2 = this.s.getValueAtTime(time2);
matrix.scale(scale2[0] * this.s.mult, scale2[1] * this.s.mult, scale2[2] * this.s.mult);
}
if (this.sk && this.appliedTransformations < 3) {
var skew = this.sk.getValueAtTime(time2);
var skewAxis = this.sa.getValueAtTime(time2);
matrix.skewFromAxis(-skew * this.sk.mult, skewAxis * this.sa.mult);
}
if (this.r && this.appliedTransformations < 4) {
var rotation2 = this.r.getValueAtTime(time2);
matrix.rotate(-rotation2 * this.r.mult);
} else if (!this.r && this.appliedTransformations < 4) {
var rotationZ = this.rz.getValueAtTime(time2);
var rotationY = this.ry.getValueAtTime(time2);
var rotationX = this.rx.getValueAtTime(time2);
var orientation = this.or.getValueAtTime(time2);
matrix.rotateZ(-rotationZ * this.rz.mult).rotateY(rotationY * this.ry.mult).rotateX(rotationX * this.rx.mult).rotateZ(-orientation[2] * this.or.mult).rotateY(orientation[1] * this.or.mult).rotateX(orientation[0] * this.or.mult);
}
if (this.data.p && this.data.p.s) {
var positionX = this.px.getValueAtTime(time2);
var positionY = this.py.getValueAtTime(time2);
if (this.data.p.z) {
var positionZ = this.pz.getValueAtTime(time2);
matrix.translate(positionX * this.px.mult, positionY * this.py.mult, -positionZ * this.pz.mult);
} else {
matrix.translate(positionX * this.px.mult, positionY * this.py.mult, 0);
}
} else {
var position2 = this.p.getValueAtTime(time2);
matrix.translate(position2[0] * this.p.mult, position2[1] * this.p.mult, -position2[2] * this.p.mult);
}
return matrix;
}
function getTransformStaticValueAtTime() {
return this.v.clone(new Matrix());
}
var getTransformProperty = TransformPropertyFactory.getTransformProperty;
TransformPropertyFactory.getTransformProperty = function(elem2, data2, container) {
var prop = getTransformProperty(elem2, data2, container);
if (prop.dynamicProperties.length) {
prop.getValueAtTime = getTransformValueAtTime.bind(prop);
} else {
prop.getValueAtTime = getTransformStaticValueAtTime.bind(prop);
}
prop.setGroupProperty = expressionHelpers.setGroupProperty;
return prop;
};
var propertyGetProp = PropertyFactory.getProp;
PropertyFactory.getProp = function(elem2, data2, type, mult, container) {
var prop = propertyGetProp(elem2, data2, type, mult, container);
if (prop.kf) {
prop.getValueAtTime = expressionHelpers.getValueAtTime.bind(prop);
} else {
prop.getValueAtTime = expressionHelpers.getStaticValueAtTime.bind(prop);
}
prop.setGroupProperty = expressionHelpers.setGroupProperty;
prop.loopOut = loopOut2;
prop.loopIn = loopIn2;
prop.smooth = smooth2;
prop.getVelocityAtTime = expressionHelpers.getVelocityAtTime.bind(prop);
prop.getSpeedAtTime = expressionHelpers.getSpeedAtTime.bind(prop);
prop.numKeys = data2.a === 1 ? data2.k.length : 0;
prop.propertyIndex = data2.ix;
var value2 = 0;
if (type !== 0) {
value2 = createTypedArray("float32", data2.a === 1 ? data2.k[0].s.length : data2.k.length);
}
prop._cachingAtTime = {
lastFrame: initialDefaultFrame,
lastIndex: 0,
value: value2
};
expressionHelpers.searchExpressions(elem2, data2, prop);
if (prop.k) {
container.addDynamicProperty(prop);
}
return prop;
};
function getShapeValueAtTime(frameNum) {
if (!this._cachingAtTime) {
this._cachingAtTime = {
shapeValue: shapePool.clone(this.pv),
lastIndex: 0,
lastTime: initialDefaultFrame
};
}
frameNum *= this.elem.globalData.frameRate;
frameNum -= this.offsetTime;
if (frameNum !== this._cachingAtTime.lastTime) {
this._cachingAtTime.lastIndex = this._cachingAtTime.lastTime < frameNum ? this._caching.lastIndex : 0;
this._cachingAtTime.lastTime = frameNum;
this.interpolateShape(frameNum, this._cachingAtTime.shapeValue, this._cachingAtTime);
}
return this._cachingAtTime.shapeValue;
}
var ShapePropertyConstructorFunction = ShapePropertyFactory.getConstructorFunction();
var KeyframedShapePropertyConstructorFunction = ShapePropertyFactory.getKeyframedConstructorFunction();
function ShapeExpressions() {
}
ShapeExpressions.prototype = {
vertices: function vertices(prop, time2) {
if (this.k) {
this.getValue();
}
var shapePath = this.v;
if (time2 !== void 0) {
shapePath = this.getValueAtTime(time2, 0);
}
var i;
var len = shapePath._length;
var vertices2 = shapePath[prop];
var points = shapePath.v;
var arr = createSizedArray(len);
for (i = 0; i < len; i += 1) {
if (prop === "i" || prop === "o") {
arr[i] = [vertices2[i][0] - points[i][0], vertices2[i][1] - points[i][1]];
} else {
arr[i] = [vertices2[i][0], vertices2[i][1]];
}
}
return arr;
},
points: function points(time2) {
return this.vertices("v", time2);
},
inTangents: function inTangents(time2) {
return this.vertices("i", time2);
},
outTangents: function outTangents(time2) {
return this.vertices("o", time2);
},
isClosed: function isClosed() {
return this.v.c;
},
pointOnPath: function pointOnPath(perc, time2) {
var shapePath = this.v;
if (time2 !== void 0) {
shapePath = this.getValueAtTime(time2, 0);
}
if (!this._segmentsLength) {
this._segmentsLength = bez.getSegmentsLength(shapePath);
}
var segmentsLength = this._segmentsLength;
var lengths = segmentsLength.lengths;
var lengthPos = segmentsLength.totalLength * perc;
var i = 0;
var len = lengths.length;
var accumulatedLength = 0;
var pt;
while (i < len) {
if (accumulatedLength + lengths[i].addedLength > lengthPos) {
var initIndex = i;
var endIndex = shapePath.c && i === len - 1 ? 0 : i + 1;
var segmentPerc = (lengthPos - accumulatedLength) / lengths[i].addedLength;
pt = bez.getPointInSegment(shapePath.v[initIndex], shapePath.v[endIndex], shapePath.o[initIndex], shapePath.i[endIndex], segmentPerc, lengths[i]);
break;
} else {
accumulatedLength += lengths[i].addedLength;
}
i += 1;
}
if (!pt) {
pt = shapePath.c ? [shapePath.v[0][0], shapePath.v[0][1]] : [shapePath.v[shapePath._length - 1][0], shapePath.v[shapePath._length - 1][1]];
}
return pt;
},
vectorOnPath: function vectorOnPath(perc, time2, vectorType) {
if (perc == 1) {
perc = this.v.c;
} else if (perc == 0) {
perc = 0.999;
}
var pt1 = this.pointOnPath(perc, time2);
var pt2 = this.pointOnPath(perc + 1e-3, time2);
var xLength = pt2[0] - pt1[0];
var yLength = pt2[1] - pt1[1];
var magnitude = Math.sqrt(Math.pow(xLength, 2) + Math.pow(yLength, 2));
if (magnitude === 0) {
return [0, 0];
}
var unitVector = vectorType === "tangent" ? [xLength / magnitude, yLength / magnitude] : [-yLength / magnitude, xLength / magnitude];
return unitVector;
},
tangentOnPath: function tangentOnPath(perc, time2) {
return this.vectorOnPath(perc, time2, "tangent");
},
normalOnPath: function normalOnPath(perc, time2) {
return this.vectorOnPath(perc, time2, "normal");
},
setGroupProperty: expressionHelpers.setGroupProperty,
getValueAtTime: expressionHelpers.getStaticValueAtTime
};
extendPrototype([ShapeExpressions], ShapePropertyConstructorFunction);
extendPrototype([ShapeExpressions], KeyframedShapePropertyConstructorFunction);
KeyframedShapePropertyConstructorFunction.prototype.getValueAtTime = getShapeValueAtTime;
KeyframedShapePropertyConstructorFunction.prototype.initiateExpression = ExpressionManager.initiateExpression;
var propertyGetShapeProp = ShapePropertyFactory.getShapeProp;
ShapePropertyFactory.getShapeProp = function(elem2, data2, type, arr, trims) {
var prop = propertyGetShapeProp(elem2, data2, type, arr, trims);
prop.propertyIndex = data2.ix;
prop.lock = false;
if (type === 3) {
expressionHelpers.searchExpressions(elem2, data2.pt, prop);
} else if (type === 4) {
expressionHelpers.searchExpressions(elem2, data2.ks, prop);
}
if (prop.k) {
elem2.addDynamicProperty(prop);
}
return prop;
};
}
function initialize$1() {
addPropertyDecorator();
}
function addDecorator() {
function searchExpressions() {
if (this.data.d.x) {
this.calculateExpression = ExpressionManager.initiateExpression.bind(this)(this.elem, this.data.d, this);
this.addEffect(this.getExpressionValue.bind(this));
return true;
}
return null;
}
TextProperty.prototype.getExpressionValue = function(currentValue, text2) {
var newValue = this.calculateExpression(text2);
if (currentValue.t !== newValue) {
var newData = {};
this.copyData(newData, currentValue);
newData.t = newValue.toString();
newData.__complete = false;
return newData;
}
return currentValue;
};
TextProperty.prototype.searchProperty = function() {
var isKeyframed = this.searchKeyframes();
var hasExpressions = this.searchExpressions();
this.kf = isKeyframed || hasExpressions;
return this.kf;
};
TextProperty.prototype.searchExpressions = searchExpressions;
}
function initialize() {
addDecorator();
}
function SVGComposableEffect() {
}
SVGComposableEffect.prototype = {
createMergeNode: function createMergeNode(resultId, ins) {
var feMerge = createNS("feMerge");
feMerge.setAttribute("result", resultId);
var feMergeNode;
var i;
for (i = 0; i < ins.length; i += 1) {
feMergeNode = createNS("feMergeNode");
feMergeNode.setAttribute("in", ins[i]);
feMerge.appendChild(feMergeNode);
feMerge.appendChild(feMergeNode);
}
return feMerge;
}
};
var linearFilterValue = "0.3333 0.3333 0.3333 0 0 0.3333 0.3333 0.3333 0 0 0.3333 0.3333 0.3333 0 0 0 0 0";
function SVGTintFilter(filter2, filterManager, elem2, id, source) {
this.filterManager = filterManager;
var feColorMatrix = createNS("feColorMatrix");
feColorMatrix.setAttribute("type", "matrix");
feColorMatrix.setAttribute("color-interpolation-filters", "linearRGB");
feColorMatrix.setAttribute("values", linearFilterValue + " 1 0");
this.linearFilter = feColorMatrix;
feColorMatrix.setAttribute("result", id + "_tint_1");
filter2.appendChild(feColorMatrix);
feColorMatrix = createNS("feColorMatrix");
feColorMatrix.setAttribute("type", "matrix");
feColorMatrix.setAttribute("color-interpolation-filters", "sRGB");
feColorMatrix.setAttribute("values", "1 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 1 0");
feColorMatrix.setAttribute("result", id + "_tint_2");
filter2.appendChild(feColorMatrix);
this.matrixFilter = feColorMatrix;
var feMerge = this.createMergeNode(id, [source, id + "_tint_1", id + "_tint_2"]);
filter2.appendChild(feMerge);
}
extendPrototype([SVGComposableEffect], SVGTintFilter);
SVGTintFilter.prototype.renderFrame = function(forceRender) {
if (forceRender || this.filterManager._mdf) {
var colorBlack = this.filterManager.effectElements[0].p.v;
var colorWhite = this.filterManager.effectElements[1].p.v;
var opacity = this.filterManager.effectElements[2].p.v / 100;
this.linearFilter.setAttribute("values", linearFilterValue + " " + opacity + " 0");
this.matrixFilter.setAttribute("values", colorWhite[0] - colorBlack[0] + " 0 0 0 " + colorBlack[0] + " " + (colorWhite[1] - colorBlack[1]) + " 0 0 0 " + colorBlack[1] + " " + (colorWhite[2] - colorBlack[2]) + " 0 0 0 " + colorBlack[2] + " 0 0 0 1 0");
}
};
function SVGFillFilter(filter2, filterManager, elem2, id) {
this.filterManager = filterManager;
var feColorMatrix = createNS("feColorMatrix");
feColorMatrix.setAttribute("type", "matrix");
feColorMatrix.setAttribute("color-interpolation-filters", "sRGB");
feColorMatrix.setAttribute("values", "1 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 1 0");
feColorMatrix.setAttribute("result", id);
filter2.appendChild(feColorMatrix);
this.matrixFilter = feColorMatrix;
}
SVGFillFilter.prototype.renderFrame = function(forceRender) {
if (forceRender || this.filterManager._mdf) {
var color = this.filterManager.effectElements[2].p.v;
var opacity = this.filterManager.effectElements[6].p.v;
this.matrixFilter.setAttribute("values", "0 0 0 0 " + color[0] + " 0 0 0 0 " + color[1] + " 0 0 0 0 " + color[2] + " 0 0 0 " + opacity + " 0");
}
};
function SVGStrokeEffect(fil, filterManager, elem2) {
this.initialized = false;
this.filterManager = filterManager;
this.elem = elem2;
this.paths = [];
}
SVGStrokeEffect.prototype.initialize = function() {
var elemChildren = this.elem.layerElement.children || this.elem.layerElement.childNodes;
var path;
var groupPath;
var i;
var len;
if (this.filterManager.effectElements[1].p.v === 1) {
len = this.elem.maskManager.masksProperties.length;
i = 0;
} else {
i = this.filterManager.effectElements[0].p.v - 1;
len = i + 1;
}
groupPath = createNS("g");
groupPath.setAttribute("fill", "none");
groupPath.setAttribute("stroke-linecap", "round");
groupPath.setAttribute("stroke-dashoffset", 1);
for (i; i < len; i += 1) {
path = createNS("path");
groupPath.appendChild(path);
this.paths.push({
p: path,
m: i
});
}
if (this.filterManager.effectElements[10].p.v === 3) {
var mask2 = createNS("mask");
var id = createElementID();
mask2.setAttribute("id", id);
mask2.setAttribute("mask-type", "alpha");
mask2.appendChild(groupPath);
this.elem.globalData.defs.appendChild(mask2);
var g = createNS("g");
g.setAttribute("mask", "url(" + getLocationHref() + "#" + id + ")");
while (elemChildren[0]) {
g.appendChild(elemChildren[0]);
}
this.elem.layerElement.appendChild(g);
this.masker = mask2;
groupPath.setAttribute("stroke", "#fff");
} else if (this.filterManager.effectElements[10].p.v === 1 || this.filterManager.effectElements[10].p.v === 2) {
if (this.filterManager.effectElements[10].p.v === 2) {
elemChildren = this.elem.layerElement.children || this.elem.layerElement.childNodes;
while (elemChildren.length) {
this.elem.layerElement.removeChild(elemChildren[0]);
}
}
this.elem.layerElement.appendChild(groupPath);
this.elem.layerElement.removeAttribute("mask");
groupPath.setAttribute("stroke", "#fff");
}
this.initialized = true;
this.pathMasker = groupPath;
};
SVGStrokeEffect.prototype.renderFrame = function(forceRender) {
if (!this.initialized) {
this.initialize();
}
var i;
var len = this.paths.length;
var mask2;
var path;
for (i = 0; i < len; i += 1) {
if (this.paths[i].m !== -1) {
mask2 = this.elem.maskManager.viewData[this.paths[i].m];
path = this.paths[i].p;
if (forceRender || this.filterManager._mdf || mask2.prop._mdf) {
path.setAttribute("d", mask2.lastPath);
}
if (forceRender || this.filterManager.effectElements[9].p._mdf || this.filterManager.effectElements[4].p._mdf || this.filterManager.effectElements[7].p._mdf || this.filterManager.effectElements[8].p._mdf || mask2.prop._mdf) {
var dasharrayValue;
if (this.filterManager.effectElements[7].p.v !== 0 || this.filterManager.effectElements[8].p.v !== 100) {
var s = Math.min(this.filterManager.effectElements[7].p.v, this.filterManager.effectElements[8].p.v) * 0.01;
var e = Math.max(this.filterManager.effectElements[7].p.v, this.filterManager.effectElements[8].p.v) * 0.01;
var l = path.getTotalLength();
dasharrayValue = "0 0 0 " + l * s + " ";
var lineLength = l * (e - s);
var segment = 1 + this.filterManager.effectElements[4].p.v * 2 * this.filterManager.effectElements[9].p.v * 0.01;
var units = Math.floor(lineLength / segment);
var j;
for (j = 0; j < units; j += 1) {
dasharrayValue += "1 " + this.filterManager.effectElements[4].p.v * 2 * this.filterManager.effectElements[9].p.v * 0.01 + " ";
}
dasharrayValue += "0 " + l * 10 + " 0 0";
} else {
dasharrayValue = "1 " + this.filterManager.effectElements[4].p.v * 2 * this.filterManager.effectElements[9].p.v * 0.01;
}
path.setAttribute("stroke-dasharray", dasharrayValue);
}
}
}
if (forceRender || this.filterManager.effectElements[4].p._mdf) {
this.pathMasker.setAttribute("stroke-width", this.filterManager.effectElements[4].p.v * 2);
}
if (forceRender || this.filterManager.effectElements[6].p._mdf) {
this.pathMasker.setAttribute("opacity", this.filterManager.effectElements[6].p.v);
}
if (this.filterManager.effectElements[10].p.v === 1 || this.filterManager.effectElements[10].p.v === 2) {
if (forceRender || this.filterManager.effectElements[3].p._mdf) {
var color = this.filterManager.effectElements[3].p.v;
this.pathMasker.setAttribute("stroke", "rgb(" + bmFloor(color[0] * 255) + "," + bmFloor(color[1] * 255) + "," + bmFloor(color[2] * 255) + ")");
}
}
};
function SVGTritoneFilter(filter2, filterManager, elem2, id) {
this.filterManager = filterManager;
var feColorMatrix = createNS("feColorMatrix");
feColorMatrix.setAttribute("type", "matrix");
feColorMatrix.setAttribute("color-interpolation-filters", "linearRGB");
feColorMatrix.setAttribute("values", "0.3333 0.3333 0.3333 0 0 0.3333 0.3333 0.3333 0 0 0.3333 0.3333 0.3333 0 0 0 0 0 1 0");
filter2.appendChild(feColorMatrix);
var feComponentTransfer = createNS("feComponentTransfer");
feComponentTransfer.setAttribute("color-interpolation-filters", "sRGB");
feComponentTransfer.setAttribute("result", id);
this.matrixFilter = feComponentTransfer;
var feFuncR = createNS("feFuncR");
feFuncR.setAttribute("type", "table");
feComponentTransfer.appendChild(feFuncR);
this.feFuncR = feFuncR;
var feFuncG = createNS("feFuncG");
feFuncG.setAttribute("type", "table");
feComponentTransfer.appendChild(feFuncG);
this.feFuncG = feFuncG;
var feFuncB = createNS("feFuncB");
feFuncB.setAttribute("type", "table");
feComponentTransfer.appendChild(feFuncB);
this.feFuncB = feFuncB;
filter2.appendChild(feComponentTransfer);
}
SVGTritoneFilter.prototype.renderFrame = function(forceRender) {
if (forceRender || this.filterManager._mdf) {
var color1 = this.filterManager.effectElements[0].p.v;
var color2 = this.filterManager.effectElements[1].p.v;
var color3 = this.filterManager.effectElements[2].p.v;
var tableR = color3[0] + " " + color2[0] + " " + color1[0];
var tableG = color3[1] + " " + color2[1] + " " + color1[1];
var tableB = color3[2] + " " + color2[2] + " " + color1[2];
this.feFuncR.setAttribute("tableValues", tableR);
this.feFuncG.setAttribute("tableValues", tableG);
this.feFuncB.setAttribute("tableValues", tableB);
}
};
function SVGProLevelsFilter(filter2, filterManager, elem2, id) {
this.filterManager = filterManager;
var effectElements = this.filterManager.effectElements;
var feComponentTransfer = createNS("feComponentTransfer");
if (effectElements[10].p.k || effectElements[10].p.v !== 0 || effectElements[11].p.k || effectElements[11].p.v !== 1 || effectElements[12].p.k || effectElements[12].p.v !== 1 || effectElements[13].p.k || effectElements[13].p.v !== 0 || effectElements[14].p.k || effectElements[14].p.v !== 1) {
this.feFuncR = this.createFeFunc("feFuncR", feComponentTransfer);
}
if (effectElements[17].p.k || effectElements[17].p.v !== 0 || effectElements[18].p.k || effectElements[18].p.v !== 1 || effectElements[19].p.k || effectElements[19].p.v !== 1 || effectElements[20].p.k || effectElements[20].p.v !== 0 || effectElements[21].p.k || effectElements[21].p.v !== 1) {
this.feFuncG = this.createFeFunc("feFuncG", feComponentTransfer);
}
if (effectElements[24].p.k || effectElements[24].p.v !== 0 || effectElements[25].p.k || effectElements[25].p.v !== 1 || effectElements[26].p.k || effectElements[26].p.v !== 1 || effectElements[27].p.k || effectElements[27].p.v !== 0 || effectElements[28].p.k || effectElements[28].p.v !== 1) {
this.feFuncB = this.createFeFunc("feFuncB", feComponentTransfer);
}
if (effectElements[31].p.k || effectElements[31].p.v !== 0 || effectElements[32].p.k || effectElements[32].p.v !== 1 || effectElements[33].p.k || effectElements[33].p.v !== 1 || effectElements[34].p.k || effectElements[34].p.v !== 0 || effectElements[35].p.k || effectElements[35].p.v !== 1) {
this.feFuncA = this.createFeFunc("feFuncA", feComponentTransfer);
}
if (this.feFuncR || this.feFuncG || this.feFuncB || this.feFuncA) {
feComponentTransfer.setAttribute("color-interpolation-filters", "sRGB");
filter2.appendChild(feComponentTransfer);
}
if (effectElements[3].p.k || effectElements[3].p.v !== 0 || effectElements[4].p.k || effectElements[4].p.v !== 1 || effectElements[5].p.k || effectElements[5].p.v !== 1 || effectElements[6].p.k || effectElements[6].p.v !== 0 || effectElements[7].p.k || effectElements[7].p.v !== 1) {
feComponentTransfer = createNS("feComponentTransfer");
feComponentTransfer.setAttribute("color-interpolation-filters", "sRGB");
feComponentTransfer.setAttribute("result", id);
filter2.appendChild(feComponentTransfer);
this.feFuncRComposed = this.createFeFunc("feFuncR", feComponentTransfer);
this.feFuncGComposed = this.createFeFunc("feFuncG", feComponentTransfer);
this.feFuncBComposed = this.createFeFunc("feFuncB", feComponentTransfer);
}
}
SVGProLevelsFilter.prototype.createFeFunc = function(type, feComponentTransfer) {
var feFunc = createNS(type);
feFunc.setAttribute("type", "table");
feComponentTransfer.appendChild(feFunc);
return feFunc;
};
SVGProLevelsFilter.prototype.getTableValue = function(inputBlack, inputWhite, gamma, outputBlack, outputWhite) {
var cnt = 0;
var segments = 256;
var perc;
var min = Math.min(inputBlack, inputWhite);
var max = Math.max(inputBlack, inputWhite);
var table = Array.call(null, {
length: segments
});
var colorValue;
var pos = 0;
var outputDelta = outputWhite - outputBlack;
var inputDelta = inputWhite - inputBlack;
while (cnt <= 256) {
perc = cnt / 256;
if (perc <= min) {
colorValue = inputDelta < 0 ? outputWhite : outputBlack;
} else if (perc >= max) {
colorValue = inputDelta < 0 ? outputBlack : outputWhite;
} else {
colorValue = outputBlack + outputDelta * Math.pow((perc - inputBlack) / inputDelta, 1 / gamma);
}
table[pos] = colorValue;
pos += 1;
cnt += 256 / (segments - 1);
}
return table.join(" ");
};
SVGProLevelsFilter.prototype.renderFrame = function(forceRender) {
if (forceRender || this.filterManager._mdf) {
var val2;
var effectElements = this.filterManager.effectElements;
if (this.feFuncRComposed && (forceRender || effectElements[3].p._mdf || effectElements[4].p._mdf || effectElements[5].p._mdf || effectElements[6].p._mdf || effectElements[7].p._mdf)) {
val2 = this.getTableValue(effectElements[3].p.v, effectElements[4].p.v, effectElements[5].p.v, effectElements[6].p.v, effectElements[7].p.v);
this.feFuncRComposed.setAttribute("tableValues", val2);
this.feFuncGComposed.setAttribute("tableValues", val2);
this.feFuncBComposed.setAttribute("tableValues", val2);
}
if (this.feFuncR && (forceRender || effectElements[10].p._mdf || effectElements[11].p._mdf || effectElements[12].p._mdf || effectElements[13].p._mdf || effectElements[14].p._mdf)) {
val2 = this.getTableValue(effectElements[10].p.v, effectElements[11].p.v, effectElements[12].p.v, effectElements[13].p.v, effectElements[14].p.v);
this.feFuncR.setAttribute("tableValues", val2);
}
if (this.feFuncG && (forceRender || effectElements[17].p._mdf || effectElements[18].p._mdf || effectElements[19].p._mdf || effectElements[20].p._mdf || effectElements[21].p._mdf)) {
val2 = this.getTableValue(effectElements[17].p.v, effectElements[18].p.v, effectElements[19].p.v, effectElements[20].p.v, effectElements[21].p.v);
this.feFuncG.setAttribute("tableValues", val2);
}
if (this.feFuncB && (forceRender || effectElements[24].p._mdf || effectElements[25].p._mdf || effectElements[26].p._mdf || effectElements[27].p._mdf || effectElements[28].p._mdf)) {
val2 = this.getTableValue(effectElements[24].p.v, effectElements[25].p.v, effectElements[26].p.v, effectElements[27].p.v, effectElements[28].p.v);
this.feFuncB.setAttribute("tableValues", val2);
}
if (this.feFuncA && (forceRender || effectElements[31].p._mdf || effectElements[32].p._mdf || effectElements[33].p._mdf || effectElements[34].p._mdf || effectElements[35].p._mdf)) {
val2 = this.getTableValue(effectElements[31].p.v, effectElements[32].p.v, effectElements[33].p.v, effectElements[34].p.v, effectElements[35].p.v);
this.feFuncA.setAttribute("tableValues", val2);
}
}
};
function SVGDropShadowEffect(filter2, filterManager, elem2, id, source) {
var globalFilterSize = filterManager.container.globalData.renderConfig.filterSize;
var filterSize = filterManager.data.fs || globalFilterSize;
filter2.setAttribute("x", filterSize.x || globalFilterSize.x);
filter2.setAttribute("y", filterSize.y || globalFilterSize.y);
filter2.setAttribute("width", filterSize.width || globalFilterSize.width);
filter2.setAttribute("height", filterSize.height || globalFilterSize.height);
this.filterManager = filterManager;
var feGaussianBlur = createNS("feGaussianBlur");
feGaussianBlur.setAttribute("in", "SourceAlpha");
feGaussianBlur.setAttribute("result", id + "_drop_shadow_1");
feGaussianBlur.setAttribute("stdDeviation", "0");
this.feGaussianBlur = feGaussianBlur;
filter2.appendChild(feGaussianBlur);
var feOffset = createNS("feOffset");
feOffset.setAttribute("dx", "25");
feOffset.setAttribute("dy", "0");
feOffset.setAttribute("in", id + "_drop_shadow_1");
feOffset.setAttribute("result", id + "_drop_shadow_2");
this.feOffset = feOffset;
filter2.appendChild(feOffset);
var feFlood = createNS("feFlood");
feFlood.setAttribute("flood-color", "#00ff00");
feFlood.setAttribute("flood-opacity", "1");
feFlood.setAttribute("result", id + "_drop_shadow_3");
this.feFlood = feFlood;
filter2.appendChild(feFlood);
var feComposite = createNS("feComposite");
feComposite.setAttribute("in", id + "_drop_shadow_3");
feComposite.setAttribute("in2", id + "_drop_shadow_2");
feComposite.setAttribute("operator", "in");
feComposite.setAttribute("result", id + "_drop_shadow_4");
filter2.appendChild(feComposite);
var feMerge = this.createMergeNode(id, [id + "_drop_shadow_4", source]);
filter2.appendChild(feMerge);
}
extendPrototype([SVGComposableEffect], SVGDropShadowEffect);
SVGDropShadowEffect.prototype.renderFrame = function(forceRender) {
if (forceRender || this.filterManager._mdf) {
if (forceRender || this.filterManager.effectElements[4].p._mdf) {
this.feGaussianBlur.setAttribute("stdDeviation", this.filterManager.effectElements[4].p.v / 4);
}
if (forceRender || this.filterManager.effectElements[0].p._mdf) {
var col = this.filterManager.effectElements[0].p.v;
this.feFlood.setAttribute("flood-color", rgbToHex(Math.round(col[0] * 255), Math.round(col[1] * 255), Math.round(col[2] * 255)));
}
if (forceRender || this.filterManager.effectElements[1].p._mdf) {
this.feFlood.setAttribute("flood-opacity", this.filterManager.effectElements[1].p.v / 255);
}
if (forceRender || this.filterManager.effectElements[2].p._mdf || this.filterManager.effectElements[3].p._mdf) {
var distance = this.filterManager.effectElements[3].p.v;
var angle = (this.filterManager.effectElements[2].p.v - 90) * degToRads;
var x = distance * Math.cos(angle);
var y = distance * Math.sin(angle);
this.feOffset.setAttribute("dx", x);
this.feOffset.setAttribute("dy", y);
}
}
};
var _svgMatteSymbols = [];
function SVGMatte3Effect(filterElem, filterManager, elem2) {
this.initialized = false;
this.filterManager = filterManager;
this.filterElem = filterElem;
this.elem = elem2;
elem2.matteElement = createNS("g");
elem2.matteElement.appendChild(elem2.layerElement);
elem2.matteElement.appendChild(elem2.transformedElement);
elem2.baseElement = elem2.matteElement;
}
SVGMatte3Effect.prototype.findSymbol = function(mask2) {
var i = 0;
var len = _svgMatteSymbols.length;
while (i < len) {
if (_svgMatteSymbols[i] === mask2) {
return _svgMatteSymbols[i];
}
i += 1;
}
return null;
};
SVGMatte3Effect.prototype.replaceInParent = function(mask2, symbolId) {
var parentNode = mask2.layerElement.parentNode;
if (!parentNode) {
return;
}
var children = parentNode.children;
var i = 0;
var len = children.length;
while (i < len) {
if (children[i] === mask2.layerElement) {
break;
}
i += 1;
}
var nextChild;
if (i <= len - 2) {
nextChild = children[i + 1];
}
var useElem = createNS("use");
useElem.setAttribute("href", "#" + symbolId);
if (nextChild) {
parentNode.insertBefore(useElem, nextChild);
} else {
parentNode.appendChild(useElem);
}
};
SVGMatte3Effect.prototype.setElementAsMask = function(elem2, mask2) {
if (!this.findSymbol(mask2)) {
var symbolId = createElementID();
var masker = createNS("mask");
masker.setAttribute("id", mask2.layerId);
masker.setAttribute("mask-type", "alpha");
_svgMatteSymbols.push(mask2);
var defs = elem2.globalData.defs;
defs.appendChild(masker);
var symbol = createNS("symbol");
symbol.setAttribute("id", symbolId);
this.replaceInParent(mask2, symbolId);
symbol.appendChild(mask2.layerElement);
defs.appendChild(symbol);
var useElem = createNS("use");
useElem.setAttribute("href", "#" + symbolId);
masker.appendChild(useElem);
mask2.data.hd = false;
mask2.show();
}
elem2.setMatte(mask2.layerId);
};
SVGMatte3Effect.prototype.initialize = function() {
var ind = this.filterManager.effectElements[0].p.v;
var elements = this.elem.comp.elements;
var i = 0;
var len = elements.length;
while (i < len) {
if (elements[i] && elements[i].data.ind === ind) {
this.setElementAsMask(this.elem, elements[i]);
}
i += 1;
}
this.initialized = true;
};
SVGMatte3Effect.prototype.renderFrame = function() {
if (!this.initialized) {
this.initialize();
}
};
function SVGGaussianBlurEffect(filter2, filterManager, elem2, id) {
filter2.setAttribute("x", "-100%");
filter2.setAttribute("y", "-100%");
filter2.setAttribute("width", "300%");
filter2.setAttribute("height", "300%");
this.filterManager = filterManager;
var feGaussianBlur = createNS("feGaussianBlur");
feGaussianBlur.setAttribute("result", id);
filter2.appendChild(feGaussianBlur);
this.feGaussianBlur = feGaussianBlur;
}
SVGGaussianBlurEffect.prototype.renderFrame = function(forceRender) {
if (forceRender || this.filterManager._mdf) {
var kBlurrinessToSigma = 0.3;
var sigma = this.filterManager.effectElements[0].p.v * kBlurrinessToSigma;
var dimensions = this.filterManager.effectElements[1].p.v;
var sigmaX = dimensions == 3 ? 0 : sigma;
var sigmaY = dimensions == 2 ? 0 : sigma;
this.feGaussianBlur.setAttribute("stdDeviation", sigmaX + " " + sigmaY);
var edgeMode = this.filterManager.effectElements[2].p.v == 1 ? "wrap" : "duplicate";
this.feGaussianBlur.setAttribute("edgeMode", edgeMode);
}
};
function TransformEffect() {
}
TransformEffect.prototype.init = function(effectsManager) {
this.effectsManager = effectsManager;
this.type = effectTypes.TRANSFORM_EFFECT;
this.matrix = new Matrix();
this.opacity = -1;
this._mdf = false;
this._opMdf = false;
};
TransformEffect.prototype.renderFrame = function(forceFrame) {
this._opMdf = false;
this._mdf = false;
if (forceFrame || this.effectsManager._mdf) {
var effectElements = this.effectsManager.effectElements;
var anchor = effectElements[0].p.v;
var position2 = effectElements[1].p.v;
var isUniformScale = effectElements[2].p.v === 1;
var scaleHeight = effectElements[3].p.v;
var scaleWidth = isUniformScale ? scaleHeight : effectElements[4].p.v;
var skew = effectElements[5].p.v;
var skewAxis = effectElements[6].p.v;
var rotation2 = effectElements[7].p.v;
this.matrix.reset();
this.matrix.translate(-anchor[0], -anchor[1], anchor[2]);
this.matrix.scale(scaleWidth * 0.01, scaleHeight * 0.01, 1);
this.matrix.rotate(-rotation2 * degToRads);
this.matrix.skewFromAxis(-skew * degToRads, (skewAxis + 90) * degToRads);
this.matrix.translate(position2[0], position2[1], 0);
this._mdf = true;
if (this.opacity !== effectElements[8].p.v) {
this.opacity = effectElements[8].p.v;
this._opMdf = true;
}
}
};
function SVGTransformEffect(_, filterManager) {
this.init(filterManager);
}
extendPrototype([TransformEffect], SVGTransformEffect);
function CVTransformEffect(effectsManager) {
this.init(effectsManager);
}
extendPrototype([TransformEffect], CVTransformEffect);
registerRenderer("canvas", CanvasRenderer);
registerRenderer("html", HybridRenderer);
registerRenderer("svg", SVGRenderer);
ShapeModifiers.registerModifier("tm", TrimModifier);
ShapeModifiers.registerModifier("pb", PuckerAndBloatModifier);
ShapeModifiers.registerModifier("rp", RepeaterModifier);
ShapeModifiers.registerModifier("rd", RoundCornersModifier);
ShapeModifiers.registerModifier("zz", ZigZagModifier);
ShapeModifiers.registerModifier("op", OffsetPathModifier);
setExpressionsPlugin(Expressions);
setExpressionInterfaces(getInterface);
initialize$1();
initialize();
registerEffect$1(20, SVGTintFilter, true);
registerEffect$1(21, SVGFillFilter, true);
registerEffect$1(22, SVGStrokeEffect, false);
registerEffect$1(23, SVGTritoneFilter, true);
registerEffect$1(24, SVGProLevelsFilter, true);
registerEffect$1(25, SVGDropShadowEffect, true);
registerEffect$1(28, SVGMatte3Effect, false);
registerEffect$1(29, SVGGaussianBlurEffect, true);
registerEffect$1(35, SVGTransformEffect, false);
registerEffect(35, CVTransformEffect);
return lottie;
});
}
});
// node_modules/@angular/core/fesm2022/primitives/signals.mjs
function defaultEquals(a, b) {
return Object.is(a, b);
}
var activeConsumer = null;
var inNotificationPhase = false;
var epoch = 1;
var SIGNAL = /* @__PURE__ */ Symbol("SIGNAL");
function setActiveConsumer(consumer) {
const prev = activeConsumer;
activeConsumer = consumer;
return prev;
}
function getActiveConsumer() {
return activeConsumer;
}
var REACTIVE_NODE = {
version: 0,
lastCleanEpoch: 0,
dirty: false,
producerNode: void 0,
producerLastReadVersion: void 0,
producerIndexOfThis: void 0,
nextProducerIndex: 0,
liveConsumerNode: void 0,
liveConsumerIndexOfThis: void 0,
consumerAllowSignalWrites: false,
consumerIsAlwaysLive: false,
producerMustRecompute: () => false,
producerRecomputeValue: () => {
},
consumerMarkedDirty: () => {
},
consumerOnSignalRead: () => {
}
};
function producerAccessed(node) {
if (inNotificationPhase) {
throw new Error(typeof ngDevMode !== "undefined" && ngDevMode ? `Assertion error: signal read during notification phase` : "");
}
if (activeConsumer === null) {
return;
}
activeConsumer.consumerOnSignalRead(node);
const idx = activeConsumer.nextProducerIndex++;
assertConsumerNode(activeConsumer);
if (idx < activeConsumer.producerNode.length && activeConsumer.producerNode[idx] !== node) {
if (consumerIsLive(activeConsumer)) {
const staleProducer = activeConsumer.producerNode[idx];
producerRemoveLiveConsumerAtIndex(staleProducer, activeConsumer.producerIndexOfThis[idx]);
}
}
if (activeConsumer.producerNode[idx] !== node) {
activeConsumer.producerNode[idx] = node;
activeConsumer.producerIndexOfThis[idx] = consumerIsLive(activeConsumer) ? producerAddLiveConsumer(node, activeConsumer, idx) : 0;
}
activeConsumer.producerLastReadVersion[idx] = node.version;
}
function producerIncrementEpoch() {
epoch++;
}
function producerUpdateValueVersion(node) {
if (consumerIsLive(node) && !node.dirty) {
return;
}
if (!node.dirty && node.lastCleanEpoch === epoch) {
return;
}
if (!node.producerMustRecompute(node) && !consumerPollProducersForChange(node)) {
node.dirty = false;
node.lastCleanEpoch = epoch;
return;
}
node.producerRecomputeValue(node);
node.dirty = false;
node.lastCleanEpoch = epoch;
}
function producerNotifyConsumers(node) {
if (node.liveConsumerNode === void 0) {
return;
}
const prev = inNotificationPhase;
inNotificationPhase = true;
try {
for (const consumer of node.liveConsumerNode) {
if (!consumer.dirty) {
consumerMarkDirty(consumer);
}
}
} finally {
inNotificationPhase = prev;
}
}
function producerUpdatesAllowed() {
return activeConsumer?.consumerAllowSignalWrites !== false;
}
function consumerMarkDirty(node) {
node.dirty = true;
producerNotifyConsumers(node);
node.consumerMarkedDirty?.(node);
}
function consumerBeforeComputation(node) {
node && (node.nextProducerIndex = 0);
return setActiveConsumer(node);
}
function consumerAfterComputation(node, prevConsumer) {
setActiveConsumer(prevConsumer);
if (!node || node.producerNode === void 0 || node.producerIndexOfThis === void 0 || node.producerLastReadVersion === void 0) {
return;
}
if (consumerIsLive(node)) {
for (let i = node.nextProducerIndex; i < node.producerNode.length; i++) {
producerRemoveLiveConsumerAtIndex(node.producerNode[i], node.producerIndexOfThis[i]);
}
}
while (node.producerNode.length > node.nextProducerIndex) {
node.producerNode.pop();
node.producerLastReadVersion.pop();
node.producerIndexOfThis.pop();
}
}
function consumerPollProducersForChange(node) {
assertConsumerNode(node);
for (let i = 0; i < node.producerNode.length; i++) {
const producer = node.producerNode[i];
const seenVersion = node.producerLastReadVersion[i];
if (seenVersion !== producer.version) {
return true;
}
producerUpdateValueVersion(producer);
if (seenVersion !== producer.version) {
return true;
}
}
return false;
}
function consumerDestroy(node) {
assertConsumerNode(node);
if (consumerIsLive(node)) {
for (let i = 0; i < node.producerNode.length; i++) {
producerRemoveLiveConsumerAtIndex(node.producerNode[i], node.producerIndexOfThis[i]);
}
}
node.producerNode.length = node.producerLastReadVersion.length = node.producerIndexOfThis.length = 0;
if (node.liveConsumerNode) {
node.liveConsumerNode.length = node.liveConsumerIndexOfThis.length = 0;
}
}
function producerAddLiveConsumer(node, consumer, indexOfThis) {
assertProducerNode(node);
assertConsumerNode(node);
if (node.liveConsumerNode.length === 0) {
for (let i = 0; i < node.producerNode.length; i++) {
node.producerIndexOfThis[i] = producerAddLiveConsumer(node.producerNode[i], node, i);
}
}
node.liveConsumerIndexOfThis.push(indexOfThis);
return node.liveConsumerNode.push(consumer) - 1;
}
function producerRemoveLiveConsumerAtIndex(node, idx) {
assertProducerNode(node);
assertConsumerNode(node);
if (typeof ngDevMode !== "undefined" && ngDevMode && idx >= node.liveConsumerNode.length) {
throw new Error(`Assertion error: active consumer index ${idx} is out of bounds of ${node.liveConsumerNode.length} consumers)`);
}
if (node.liveConsumerNode.length === 1) {
for (let i = 0; i < node.producerNode.length; i++) {
producerRemoveLiveConsumerAtIndex(node.producerNode[i], node.producerIndexOfThis[i]);
}
}
const lastIdx = node.liveConsumerNode.length - 1;
node.liveConsumerNode[idx] = node.liveConsumerNode[lastIdx];
node.liveConsumerIndexOfThis[idx] = node.liveConsumerIndexOfThis[lastIdx];
node.liveConsumerNode.length--;
node.liveConsumerIndexOfThis.length--;
if (idx < node.liveConsumerNode.length) {
const idxProducer = node.liveConsumerIndexOfThis[idx];
const consumer = node.liveConsumerNode[idx];
assertConsumerNode(consumer);
consumer.producerIndexOfThis[idxProducer] = idx;
}
}
function consumerIsLive(node) {
return node.consumerIsAlwaysLive || (node?.liveConsumerNode?.length ?? 0) > 0;
}
function assertConsumerNode(node) {
node.producerNode ??= [];
node.producerIndexOfThis ??= [];
node.producerLastReadVersion ??= [];
}
function assertProducerNode(node) {
node.liveConsumerNode ??= [];
node.liveConsumerIndexOfThis ??= [];
}
function createComputed(computation) {
const node = Object.create(COMPUTED_NODE);
node.computation = computation;
const computed2 = () => {
producerUpdateValueVersion(node);
producerAccessed(node);
if (node.value === ERRORED) {
throw node.error;
}
return node.value;
};
computed2[SIGNAL] = node;
return computed2;
}
var UNSET = /* @__PURE__ */ Symbol("UNSET");
var COMPUTING = /* @__PURE__ */ Symbol("COMPUTING");
var ERRORED = /* @__PURE__ */ Symbol("ERRORED");
var COMPUTED_NODE = /* @__PURE__ */ (() => {
return __spreadProps(__spreadValues({}, REACTIVE_NODE), {
value: UNSET,
dirty: true,
error: null,
equal: defaultEquals,
producerMustRecompute(node) {
return node.value === UNSET || node.value === COMPUTING;
},
producerRecomputeValue(node) {
if (node.value === COMPUTING) {
throw new Error("Detected cycle in computations.");
}
const oldValue = node.value;
node.value = COMPUTING;
const prevConsumer = consumerBeforeComputation(node);
let newValue;
try {
newValue = node.computation();
} catch (err) {
newValue = ERRORED;
node.error = err;
} finally {
consumerAfterComputation(node, prevConsumer);
}
if (oldValue !== UNSET && oldValue !== ERRORED && newValue !== ERRORED && node.equal(oldValue, newValue)) {
node.value = oldValue;
return;
}
node.value = newValue;
node.version++;
}
});
})();
function defaultThrowError() {
throw new Error();
}
var throwInvalidWriteToSignalErrorFn = defaultThrowError;
function throwInvalidWriteToSignalError() {
throwInvalidWriteToSignalErrorFn();
}
function setThrowInvalidWriteToSignalError(fn) {
throwInvalidWriteToSignalErrorFn = fn;
}
var postSignalSetFn = null;
function createSignal(initialValue) {
const node = Object.create(SIGNAL_NODE);
node.value = initialValue;
const getter = () => {
producerAccessed(node);
return node.value;
};
getter[SIGNAL] = node;
return getter;
}
function signalSetFn(node, newValue) {
if (!producerUpdatesAllowed()) {
throwInvalidWriteToSignalError();
}
if (!node.equal(node.value, newValue)) {
node.value = newValue;
signalValueChanged(node);
}
}
function signalUpdateFn(node, updater) {
if (!producerUpdatesAllowed()) {
throwInvalidWriteToSignalError();
}
signalSetFn(node, updater(node.value));
}
var SIGNAL_NODE = /* @__PURE__ */ (() => {
return __spreadProps(__spreadValues({}, REACTIVE_NODE), {
equal: defaultEquals,
value: void 0
});
})();
function signalValueChanged(node) {
node.version++;
producerIncrementEpoch();
producerNotifyConsumers(node);
postSignalSetFn?.();
}
// node_modules/rxjs/dist/esm/internal/util/isFunction.js
function isFunction(value2) {
return typeof value2 === "function";
}
// node_modules/rxjs/dist/esm/internal/util/createErrorClass.js
function createErrorClass(createImpl) {
const _super = (instance) => {
Error.call(instance);
instance.stack = new Error().stack;
};
const ctorFunc = createImpl(_super);
ctorFunc.prototype = Object.create(Error.prototype);
ctorFunc.prototype.constructor = ctorFunc;
return ctorFunc;
}
// node_modules/rxjs/dist/esm/internal/util/UnsubscriptionError.js
var UnsubscriptionError = createErrorClass((_super) => function UnsubscriptionErrorImpl(errors) {
_super(this);
this.message = errors ? `${errors.length} errors occurred during unsubscription:
${errors.map((err, i) => `${i + 1}) ${err.toString()}`).join("\n ")}` : "";
this.name = "UnsubscriptionError";
this.errors = errors;
});
// node_modules/rxjs/dist/esm/internal/util/arrRemove.js
function arrRemove(arr, item) {
if (arr) {
const index2 = arr.indexOf(item);
0 <= index2 && arr.splice(index2, 1);
}
}
// node_modules/rxjs/dist/esm/internal/Subscription.js
var Subscription = class _Subscription {
constructor(initialTeardown) {
this.initialTeardown = initialTeardown;
this.closed = false;
this._parentage = null;
this._finalizers = null;
}
unsubscribe() {
let errors;
if (!this.closed) {
this.closed = true;
const { _parentage } = this;
if (_parentage) {
this._parentage = null;
if (Array.isArray(_parentage)) {
for (const parent2 of _parentage) {
parent2.remove(this);
}
} else {
_parentage.remove(this);
}
}
const { initialTeardown: initialFinalizer } = this;
if (isFunction(initialFinalizer)) {
try {
initialFinalizer();
} catch (e) {
errors = e instanceof UnsubscriptionError ? e.errors : [e];
}
}
const { _finalizers } = this;
if (_finalizers) {
this._finalizers = null;
for (const finalizer of _finalizers) {
try {
execFinalizer(finalizer);
} catch (err) {
errors = errors !== null && errors !== void 0 ? errors : [];
if (err instanceof UnsubscriptionError) {
errors = [...errors, ...err.errors];
} else {
errors.push(err);
}
}
}
}
if (errors) {
throw new UnsubscriptionError(errors);
}
}
}
add(teardown) {
var _a;
if (teardown && teardown !== this) {
if (this.closed) {
execFinalizer(teardown);
} else {
if (teardown instanceof _Subscription) {
if (teardown.closed || teardown._hasParent(this)) {
return;
}
teardown._addParent(this);
}
(this._finalizers = (_a = this._finalizers) !== null && _a !== void 0 ? _a : []).push(teardown);
}
}
}
_hasParent(parent2) {
const { _parentage } = this;
return _parentage === parent2 || Array.isArray(_parentage) && _parentage.includes(parent2);
}
_addParent(parent2) {
const { _parentage } = this;
this._parentage = Array.isArray(_parentage) ? (_parentage.push(parent2), _parentage) : _parentage ? [_parentage, parent2] : parent2;
}
_removeParent(parent2) {
const { _parentage } = this;
if (_parentage === parent2) {
this._parentage = null;
} else if (Array.isArray(_parentage)) {
arrRemove(_parentage, parent2);
}
}
remove(teardown) {
const { _finalizers } = this;
_finalizers && arrRemove(_finalizers, teardown);
if (teardown instanceof _Subscription) {
teardown._removeParent(this);
}
}
};
Subscription.EMPTY = (() => {
const empty = new Subscription();
empty.closed = true;
return empty;
})();
var EMPTY_SUBSCRIPTION = Subscription.EMPTY;
function isSubscription(value2) {
return value2 instanceof Subscription || value2 && "closed" in value2 && isFunction(value2.remove) && isFunction(value2.add) && isFunction(value2.unsubscribe);
}
function execFinalizer(finalizer) {
if (isFunction(finalizer)) {
finalizer();
} else {
finalizer.unsubscribe();
}
}
// node_modules/rxjs/dist/esm/internal/config.js
var config = {
onUnhandledError: null,
onStoppedNotification: null,
Promise: void 0,
useDeprecatedSynchronousErrorHandling: false,
useDeprecatedNextContext: false
};
// node_modules/rxjs/dist/esm/internal/scheduler/timeoutProvider.js
var timeoutProvider = {
setTimeout(handler, timeout, ...args) {
const { delegate } = timeoutProvider;
if (delegate === null || delegate === void 0 ? void 0 : delegate.setTimeout) {
return delegate.setTimeout(handler, timeout, ...args);
}
return setTimeout(handler, timeout, ...args);
},
clearTimeout(handle) {
const { delegate } = timeoutProvider;
return ((delegate === null || delegate === void 0 ? void 0 : delegate.clearTimeout) || clearTimeout)(handle);
},
delegate: void 0
};
// node_modules/rxjs/dist/esm/internal/util/reportUnhandledError.js
function reportUnhandledError(err) {
timeoutProvider.setTimeout(() => {
const { onUnhandledError } = config;
if (onUnhandledError) {
onUnhandledError(err);
} else {
throw err;
}
});
}
// node_modules/rxjs/dist/esm/internal/util/noop.js
function noop() {
}
// node_modules/rxjs/dist/esm/internal/NotificationFactories.js
var COMPLETE_NOTIFICATION = (() => createNotification("C", void 0, void 0))();
function errorNotification(error) {
return createNotification("E", void 0, error);
}
function nextNotification(value2) {
return createNotification("N", value2, void 0);
}
function createNotification(kind, value2, error) {
return {
kind,
value: value2,
error
};
}
// node_modules/rxjs/dist/esm/internal/util/errorContext.js
var context = null;
function errorContext(cb) {
if (config.useDeprecatedSynchronousErrorHandling) {
const isRoot = !context;
if (isRoot) {
context = { errorThrown: false, error: null };
}
cb();
if (isRoot) {
const { errorThrown, error } = context;
context = null;
if (errorThrown) {
throw error;
}
}
} else {
cb();
}
}
function captureError(err) {
if (config.useDeprecatedSynchronousErrorHandling && context) {
context.errorThrown = true;
context.error = err;
}
}
// node_modules/rxjs/dist/esm/internal/Subscriber.js
var Subscriber = class extends Subscription {
constructor(destination) {
super();
this.isStopped = false;
if (destination) {
this.destination = destination;
if (isSubscription(destination)) {
destination.add(this);
}
} else {
this.destination = EMPTY_OBSERVER;
}
}
static create(next, error, complete) {
return new SafeSubscriber(next, error, complete);
}
next(value2) {
if (this.isStopped) {
handleStoppedNotification(nextNotification(value2), this);
} else {
this._next(value2);
}
}
error(err) {
if (this.isStopped) {
handleStoppedNotification(errorNotification(err), this);
} else {
this.isStopped = true;
this._error(err);
}
}
complete() {
if (this.isStopped) {
handleStoppedNotification(COMPLETE_NOTIFICATION, this);
} else {
this.isStopped = true;
this._complete();
}
}
unsubscribe() {
if (!this.closed) {
this.isStopped = true;
super.unsubscribe();
this.destination = null;
}
}
_next(value2) {
this.destination.next(value2);
}
_error(err) {
try {
this.destination.error(err);
} finally {
this.unsubscribe();
}
}
_complete() {
try {
this.destination.complete();
} finally {
this.unsubscribe();
}
}
};
var _bind = Function.prototype.bind;
function bind(fn, thisArg) {
return _bind.call(fn, thisArg);
}
var ConsumerObserver = class {
constructor(partialObserver) {
this.partialObserver = partialObserver;
}
next(value2) {
const { partialObserver } = this;
if (partialObserver.next) {
try {
partialObserver.next(value2);
} catch (error) {
handleUnhandledError(error);
}
}
}
error(err) {
const { partialObserver } = this;
if (partialObserver.error) {
try {
partialObserver.error(err);
} catch (error) {
handleUnhandledError(error);
}
} else {
handleUnhandledError(err);
}
}
complete() {
const { partialObserver } = this;
if (partialObserver.complete) {
try {
partialObserver.complete();
} catch (error) {
handleUnhandledError(error);
}
}
}
};
var SafeSubscriber = class extends Subscriber {
constructor(observerOrNext, error, complete) {
super();
let partialObserver;
if (isFunction(observerOrNext) || !observerOrNext) {
partialObserver = {
next: observerOrNext !== null && observerOrNext !== void 0 ? observerOrNext : void 0,
error: error !== null && error !== void 0 ? error : void 0,
complete: complete !== null && complete !== void 0 ? complete : void 0
};
} else {
let context2;
if (this && config.useDeprecatedNextContext) {
context2 = Object.create(observerOrNext);
context2.unsubscribe = () => this.unsubscribe();
partialObserver = {
next: observerOrNext.next && bind(observerOrNext.next, context2),
error: observerOrNext.error && bind(observerOrNext.error, context2),
complete: observerOrNext.complete && bind(observerOrNext.complete, context2)
};
} else {
partialObserver = observerOrNext;
}
}
this.destination = new ConsumerObserver(partialObserver);
}
};
function handleUnhandledError(error) {
if (config.useDeprecatedSynchronousErrorHandling) {
captureError(error);
} else {
reportUnhandledError(error);
}
}
function defaultErrorHandler(err) {
throw err;
}
function handleStoppedNotification(notification, subscriber) {
const { onStoppedNotification } = config;
onStoppedNotification && timeoutProvider.setTimeout(() => onStoppedNotification(notification, subscriber));
}
var EMPTY_OBSERVER = {
closed: true,
next: noop,
error: defaultErrorHandler,
complete: noop
};
// node_modules/rxjs/dist/esm/internal/symbol/observable.js
var observable = (() => typeof Symbol === "function" && Symbol.observable || "@@observable")();
// node_modules/rxjs/dist/esm/internal/util/identity.js
function identity(x) {
return x;
}
// node_modules/rxjs/dist/esm/internal/util/pipe.js
function pipe(...fns) {
return pipeFromArray(fns);
}
function pipeFromArray(fns) {
if (fns.length === 0) {
return identity;
}
if (fns.length === 1) {
return fns[0];
}
return function piped(input2) {
return fns.reduce((prev, fn) => fn(prev), input2);
};
}
// node_modules/rxjs/dist/esm/internal/Observable.js
var Observable = class _Observable {
constructor(subscribe) {
if (subscribe) {
this._subscribe = subscribe;
}
}
lift(operator) {
const observable2 = new _Observable();
observable2.source = this;
observable2.operator = operator;
return observable2;
}
subscribe(observerOrNext, error, complete) {
const subscriber = isSubscriber(observerOrNext) ? observerOrNext : new SafeSubscriber(observerOrNext, error, complete);
errorContext(() => {
const { operator, source } = this;
subscriber.add(operator ? operator.call(subscriber, source) : source ? this._subscribe(subscriber) : this._trySubscribe(subscriber));
});
return subscriber;
}
_trySubscribe(sink) {
try {
return this._subscribe(sink);
} catch (err) {
sink.error(err);
}
}
forEach(next, promiseCtor) {
promiseCtor = getPromiseCtor(promiseCtor);
return new promiseCtor((resolve, reject) => {
const subscriber = new SafeSubscriber({
next: (value2) => {
try {
next(value2);
} catch (err) {
reject(err);
subscriber.unsubscribe();
}
},
error: reject,
complete: resolve
});
this.subscribe(subscriber);
});
}
_subscribe(subscriber) {
var _a;
return (_a = this.source) === null || _a === void 0 ? void 0 : _a.subscribe(subscriber);
}
[observable]() {
return this;
}
pipe(...operations) {
return pipeFromArray(operations)(this);
}
toPromise(promiseCtor) {
promiseCtor = getPromiseCtor(promiseCtor);
return new promiseCtor((resolve, reject) => {
let value2;
this.subscribe((x) => value2 = x, (err) => reject(err), () => resolve(value2));
});
}
};
Observable.create = (subscribe) => {
return new Observable(subscribe);
};
function getPromiseCtor(promiseCtor) {
var _a;
return (_a = promiseCtor !== null && promiseCtor !== void 0 ? promiseCtor : config.Promise) !== null && _a !== void 0 ? _a : Promise;
}
function isObserver(value2) {
return value2 && isFunction(value2.next) && isFunction(value2.error) && isFunction(value2.complete);
}
function isSubscriber(value2) {
return value2 && value2 instanceof Subscriber || isObserver(value2) && isSubscription(value2);
}
// node_modules/rxjs/dist/esm/internal/util/lift.js
function hasLift(source) {
return isFunction(source === null || source === void 0 ? void 0 : source.lift);
}
function operate(init) {
return (source) => {
if (hasLift(source)) {
return source.lift(function(liftedSource) {
try {
return init(liftedSource, this);
} catch (err) {
this.error(err);
}
});
}
throw new TypeError("Unable to lift unknown Observable type");
};
}
// node_modules/rxjs/dist/esm/internal/operators/OperatorSubscriber.js
function createOperatorSubscriber(destination, onNext, onComplete, onError, onFinalize) {
return new OperatorSubscriber(destination, onNext, onComplete, onError, onFinalize);
}
var OperatorSubscriber = class extends Subscriber {
constructor(destination, onNext, onComplete, onError, onFinalize, shouldUnsubscribe) {
super(destination);
this.onFinalize = onFinalize;
this.shouldUnsubscribe = shouldUnsubscribe;
this._next = onNext ? function(value2) {
try {
onNext(value2);
} catch (err) {
destination.error(err);
}
} : super._next;
this._error = onError ? function(err) {
try {
onError(err);
} catch (err2) {
destination.error(err2);
} finally {
this.unsubscribe();
}
} : super._error;
this._complete = onComplete ? function() {
try {
onComplete();
} catch (err) {
destination.error(err);
} finally {
this.unsubscribe();
}
} : super._complete;
}
unsubscribe() {
var _a;
if (!this.shouldUnsubscribe || this.shouldUnsubscribe()) {
const { closed } = this;
super.unsubscribe();
!closed && ((_a = this.onFinalize) === null || _a === void 0 ? void 0 : _a.call(this));
}
}
};
// node_modules/rxjs/dist/esm/internal/operators/refCount.js
function refCount() {
return operate((source, subscriber) => {
let connection = null;
source._refCount++;
const refCounter = createOperatorSubscriber(subscriber, void 0, void 0, void 0, () => {
if (!source || source._refCount <= 0 || 0 < --source._refCount) {
connection = null;
return;
}
const sharedConnection = source._connection;
const conn = connection;
connection = null;
if (sharedConnection && (!conn || sharedConnection === conn)) {
sharedConnection.unsubscribe();
}
subscriber.unsubscribe();
});
source.subscribe(refCounter);
if (!refCounter.closed) {
connection = source.connect();
}
});
}
// node_modules/rxjs/dist/esm/internal/observable/ConnectableObservable.js
var ConnectableObservable = class extends Observable {
constructor(source, subjectFactory) {
super();
this.source = source;
this.subjectFactory = subjectFactory;
this._subject = null;
this._refCount = 0;
this._connection = null;
if (hasLift(source)) {
this.lift = source.lift;
}
}
_subscribe(subscriber) {
return this.getSubject().subscribe(subscriber);
}
getSubject() {
const subject = this._subject;
if (!subject || subject.isStopped) {
this._subject = this.subjectFactory();
}
return this._subject;
}
_teardown() {
this._refCount = 0;
const { _connection } = this;
this._subject = this._connection = null;
_connection === null || _connection === void 0 ? void 0 : _connection.unsubscribe();
}
connect() {
let connection = this._connection;
if (!connection) {
connection = this._connection = new Subscription();
const subject = this.getSubject();
connection.add(this.source.subscribe(createOperatorSubscriber(subject, void 0, () => {
this._teardown();
subject.complete();
}, (err) => {
this._teardown();
subject.error(err);
}, () => this._teardown())));
if (connection.closed) {
this._connection = null;
connection = Subscription.EMPTY;
}
}
return connection;
}
refCount() {
return refCount()(this);
}
};
// node_modules/rxjs/dist/esm/internal/util/ObjectUnsubscribedError.js
var ObjectUnsubscribedError = createErrorClass((_super) => function ObjectUnsubscribedErrorImpl() {
_super(this);
this.name = "ObjectUnsubscribedError";
this.message = "object unsubscribed";
});
// node_modules/rxjs/dist/esm/internal/Subject.js
var Subject = class extends Observable {
constructor() {
super();
this.closed = false;
this.currentObservers = null;
this.observers = [];
this.isStopped = false;
this.hasError = false;
this.thrownError = null;
}
lift(operator) {
const subject = new AnonymousSubject(this, this);
subject.operator = operator;
return subject;
}
_throwIfClosed() {
if (this.closed) {
throw new ObjectUnsubscribedError();
}
}
next(value2) {
errorContext(() => {
this._throwIfClosed();
if (!this.isStopped) {
if (!this.currentObservers) {
this.currentObservers = Array.from(this.observers);
}
for (const observer of this.currentObservers) {
observer.next(value2);
}
}
});
}
error(err) {
errorContext(() => {
this._throwIfClosed();
if (!this.isStopped) {
this.hasError = this.isStopped = true;
this.thrownError = err;
const { observers } = this;
while (observers.length) {
observers.shift().error(err);
}
}
});
}
complete() {
errorContext(() => {
this._throwIfClosed();
if (!this.isStopped) {
this.isStopped = true;
const { observers } = this;
while (observers.length) {
observers.shift().complete();
}
}
});
}
unsubscribe() {
this.isStopped = this.closed = true;
this.observers = this.currentObservers = null;
}
get observed() {
var _a;
return ((_a = this.observers) === null || _a === void 0 ? void 0 : _a.length) > 0;
}
_trySubscribe(subscriber) {
this._throwIfClosed();
return super._trySubscribe(subscriber);
}
_subscribe(subscriber) {
this._throwIfClosed();
this._checkFinalizedStatuses(subscriber);
return this._innerSubscribe(subscriber);
}
_innerSubscribe(subscriber) {
const { hasError, isStopped, observers } = this;
if (hasError || isStopped) {
return EMPTY_SUBSCRIPTION;
}
this.currentObservers = null;
observers.push(subscriber);
return new Subscription(() => {
this.currentObservers = null;
arrRemove(observers, subscriber);
});
}
_checkFinalizedStatuses(subscriber) {
const { hasError, thrownError, isStopped } = this;
if (hasError) {
subscriber.error(thrownError);
} else if (isStopped) {
subscriber.complete();
}
}
asObservable() {
const observable2 = new Observable();
observable2.source = this;
return observable2;
}
};
Subject.create = (destination, source) => {
return new AnonymousSubject(destination, source);
};
var AnonymousSubject = class extends Subject {
constructor(destination, source) {
super();
this.destination = destination;
this.source = source;
}
next(value2) {
var _a, _b;
(_b = (_a = this.destination) === null || _a === void 0 ? void 0 : _a.next) === null || _b === void 0 ? void 0 : _b.call(_a, value2);
}
error(err) {
var _a, _b;
(_b = (_a = this.destination) === null || _a === void 0 ? void 0 : _a.error) === null || _b === void 0 ? void 0 : _b.call(_a, err);
}
complete() {
var _a, _b;
(_b = (_a = this.destination) === null || _a === void 0 ? void 0 : _a.complete) === null || _b === void 0 ? void 0 : _b.call(_a);
}
_subscribe(subscriber) {
var _a, _b;
return (_b = (_a = this.source) === null || _a === void 0 ? void 0 : _a.subscribe(subscriber)) !== null && _b !== void 0 ? _b : EMPTY_SUBSCRIPTION;
}
};
// node_modules/rxjs/dist/esm/internal/BehaviorSubject.js
var BehaviorSubject = class extends Subject {
constructor(_value) {
super();
this._value = _value;
}
get value() {
return this.getValue();
}
_subscribe(subscriber) {
const subscription = super._subscribe(subscriber);
!subscription.closed && subscriber.next(this._value);
return subscription;
}
getValue() {
const { hasError, thrownError, _value } = this;
if (hasError) {
throw thrownError;
}
this._throwIfClosed();
return _value;
}
next(value2) {
super.next(this._value = value2);
}
};
// node_modules/rxjs/dist/esm/internal/scheduler/dateTimestampProvider.js
var dateTimestampProvider = {
now() {
return (dateTimestampProvider.delegate || Date).now();
},
delegate: void 0
};
// node_modules/rxjs/dist/esm/internal/ReplaySubject.js
var ReplaySubject = class extends Subject {
constructor(_bufferSize = Infinity, _windowTime = Infinity, _timestampProvider = dateTimestampProvider) {
super();
this._bufferSize = _bufferSize;
this._windowTime = _windowTime;
this._timestampProvider = _timestampProvider;
this._buffer = [];
this._infiniteTimeWindow = true;
this._infiniteTimeWindow = _windowTime === Infinity;
this._bufferSize = Math.max(1, _bufferSize);
this._windowTime = Math.max(1, _windowTime);
}
next(value2) {
const { isStopped, _buffer, _infiniteTimeWindow, _timestampProvider, _windowTime } = this;
if (!isStopped) {
_buffer.push(value2);
!_infiniteTimeWindow && _buffer.push(_timestampProvider.now() + _windowTime);
}
this._trimBuffer();
super.next(value2);
}
_subscribe(subscriber) {
this._throwIfClosed();
this._trimBuffer();
const subscription = this._innerSubscribe(subscriber);
const { _infiniteTimeWindow, _buffer } = this;
const copy = _buffer.slice();
for (let i = 0; i < copy.length && !subscriber.closed; i += _infiniteTimeWindow ? 1 : 2) {
subscriber.next(copy[i]);
}
this._checkFinalizedStatuses(subscriber);
return subscription;
}
_trimBuffer() {
const { _bufferSize, _timestampProvider, _buffer, _infiniteTimeWindow } = this;
const adjustedBufferSize = (_infiniteTimeWindow ? 1 : 2) * _bufferSize;
_bufferSize < Infinity && adjustedBufferSize < _buffer.length && _buffer.splice(0, _buffer.length - adjustedBufferSize);
if (!_infiniteTimeWindow) {
const now = _timestampProvider.now();
let last4 = 0;
for (let i = 1; i < _buffer.length && _buffer[i] <= now; i += 2) {
last4 = i;
}
last4 && _buffer.splice(0, last4 + 1);
}
}
};
// node_modules/rxjs/dist/esm/internal/scheduler/Action.js
var Action = class extends Subscription {
constructor(scheduler, work) {
super();
}
schedule(state, delay = 0) {
return this;
}
};
// node_modules/rxjs/dist/esm/internal/scheduler/intervalProvider.js
var intervalProvider = {
setInterval(handler, timeout, ...args) {
const { delegate } = intervalProvider;
if (delegate === null || delegate === void 0 ? void 0 : delegate.setInterval) {
return delegate.setInterval(handler, timeout, ...args);
}
return setInterval(handler, timeout, ...args);
},
clearInterval(handle) {
const { delegate } = intervalProvider;
return ((delegate === null || delegate === void 0 ? void 0 : delegate.clearInterval) || clearInterval)(handle);
},
delegate: void 0
};
// node_modules/rxjs/dist/esm/internal/scheduler/AsyncAction.js
var AsyncAction = class extends Action {
constructor(scheduler, work) {
super(scheduler, work);
this.scheduler = scheduler;
this.work = work;
this.pending = false;
}
schedule(state, delay = 0) {
var _a;
if (this.closed) {
return this;
}
this.state = state;
const id = this.id;
const scheduler = this.scheduler;
if (id != null) {
this.id = this.recycleAsyncId(scheduler, id, delay);
}
this.pending = true;
this.delay = delay;
this.id = (_a = this.id) !== null && _a !== void 0 ? _a : this.requestAsyncId(scheduler, this.id, delay);
return this;
}
requestAsyncId(scheduler, _id, delay = 0) {
return intervalProvider.setInterval(scheduler.flush.bind(scheduler, this), delay);
}
recycleAsyncId(_scheduler, id, delay = 0) {
if (delay != null && this.delay === delay && this.pending === false) {
return id;
}
if (id != null) {
intervalProvider.clearInterval(id);
}
return void 0;
}
execute(state, delay) {
if (this.closed) {
return new Error("executing a cancelled action");
}
this.pending = false;
const error = this._execute(state, delay);
if (error) {
return error;
} else if (this.pending === false && this.id != null) {
this.id = this.recycleAsyncId(this.scheduler, this.id, null);
}
}
_execute(state, _delay) {
let errored = false;
let errorValue;
try {
this.work(state);
} catch (e) {
errored = true;
errorValue = e ? e : new Error("Scheduled action threw falsy error");
}
if (errored) {
this.unsubscribe();
return errorValue;
}
}
unsubscribe() {
if (!this.closed) {
const { id, scheduler } = this;
const { actions } = scheduler;
this.work = this.state = this.scheduler = null;
this.pending = false;
arrRemove(actions, this);
if (id != null) {
this.id = this.recycleAsyncId(scheduler, id, null);
}
this.delay = null;
super.unsubscribe();
}
}
};
// node_modules/rxjs/dist/esm/internal/Scheduler.js
var Scheduler = class _Scheduler {
constructor(schedulerActionCtor, now = _Scheduler.now) {
this.schedulerActionCtor = schedulerActionCtor;
this.now = now;
}
schedule(work, delay = 0, state) {
return new this.schedulerActionCtor(this, work).schedule(state, delay);
}
};
Scheduler.now = dateTimestampProvider.now;
// node_modules/rxjs/dist/esm/internal/scheduler/AsyncScheduler.js
var AsyncScheduler = class extends Scheduler {
constructor(SchedulerAction, now = Scheduler.now) {
super(SchedulerAction, now);
this.actions = [];
this._active = false;
}
flush(action) {
const { actions } = this;
if (this._active) {
actions.push(action);
return;
}
let error;
this._active = true;
do {
if (error = action.execute(action.state, action.delay)) {
break;
}
} while (action = actions.shift());
this._active = false;
if (error) {
while (action = actions.shift()) {
action.unsubscribe();
}
throw error;
}
}
};
// node_modules/rxjs/dist/esm/internal/scheduler/async.js
var asyncScheduler = new AsyncScheduler(AsyncAction);
var async = asyncScheduler;
// node_modules/rxjs/dist/esm/internal/observable/empty.js
var EMPTY = new Observable((subscriber) => subscriber.complete());
// node_modules/rxjs/dist/esm/internal/util/isScheduler.js
function isScheduler(value2) {
return value2 && isFunction(value2.schedule);
}
// node_modules/rxjs/dist/esm/internal/util/args.js
function last(arr) {
return arr[arr.length - 1];
}
function popResultSelector(args) {
return isFunction(last(args)) ? args.pop() : void 0;
}
function popScheduler(args) {
return isScheduler(last(args)) ? args.pop() : void 0;
}
// node_modules/tslib/tslib.es6.mjs
function __awaiter(thisArg, _arguments, P, generator) {
function adopt(value2) {
return value2 instanceof P ? value2 : new P(function(resolve) {
resolve(value2);
});
}
return new (P || (P = Promise))(function(resolve, reject) {
function fulfilled(value2) {
try {
step(generator.next(value2));
} catch (e) {
reject(e);
}
}
function rejected(value2) {
try {
step(generator["throw"](value2));
} 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 __values(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 = void 0;
return { value: o && o[i++], done: !o };
}
};
throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
}
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", awaitReturn), i[Symbol.asyncIterator] = function() {
return this;
}, i;
function awaitReturn(f) {
return function(v) {
return Promise.resolve(v).then(f, reject);
};
}
function verb(n, f) {
if (g[n]) {
i[n] = function(v) {
return new Promise(function(a, b) {
q.push([n, v, a, b]) > 1 || resume(n, v);
});
};
if (f)
i[n] = f(i[n]);
}
}
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(value2) {
resume("next", value2);
}
function reject(value2) {
resume("throw", value2);
}
function settle(f, v) {
if (f(v), q.shift(), q.length)
resume(q[0][0], q[0][1]);
}
}
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 __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);
}
}
// node_modules/rxjs/dist/esm/internal/util/isArrayLike.js
var isArrayLike = (x) => x && typeof x.length === "number" && typeof x !== "function";
// node_modules/rxjs/dist/esm/internal/util/isPromise.js
function isPromise(value2) {
return isFunction(value2 === null || value2 === void 0 ? void 0 : value2.then);
}
// node_modules/rxjs/dist/esm/internal/util/isInteropObservable.js
function isInteropObservable(input2) {
return isFunction(input2[observable]);
}
// node_modules/rxjs/dist/esm/internal/util/isAsyncIterable.js
function isAsyncIterable(obj) {
return Symbol.asyncIterator && isFunction(obj === null || obj === void 0 ? void 0 : obj[Symbol.asyncIterator]);
}
// node_modules/rxjs/dist/esm/internal/util/throwUnobservableError.js
function createInvalidObservableTypeError(input2) {
return new TypeError(`You provided ${input2 !== null && typeof input2 === "object" ? "an invalid object" : `'${input2}'`} where a stream was expected. You can provide an Observable, Promise, ReadableStream, Array, AsyncIterable, or Iterable.`);
}
// node_modules/rxjs/dist/esm/internal/symbol/iterator.js
function getSymbolIterator() {
if (typeof Symbol !== "function" || !Symbol.iterator) {
return "@@iterator";
}
return Symbol.iterator;
}
var iterator = getSymbolIterator();
// node_modules/rxjs/dist/esm/internal/util/isIterable.js
function isIterable(input2) {
return isFunction(input2 === null || input2 === void 0 ? void 0 : input2[iterator]);
}
// node_modules/rxjs/dist/esm/internal/util/isReadableStreamLike.js
function readableStreamLikeToAsyncGenerator(readableStream) {
return __asyncGenerator(this, arguments, function* readableStreamLikeToAsyncGenerator_1() {
const reader = readableStream.getReader();
try {
while (true) {
const { value: value2, done } = yield __await(reader.read());
if (done) {
return yield __await(void 0);
}
yield yield __await(value2);
}
} finally {
reader.releaseLock();
}
});
}
function isReadableStreamLike(obj) {
return isFunction(obj === null || obj === void 0 ? void 0 : obj.getReader);
}
// node_modules/rxjs/dist/esm/internal/observable/innerFrom.js
function innerFrom(input2) {
if (input2 instanceof Observable) {
return input2;
}
if (input2 != null) {
if (isInteropObservable(input2)) {
return fromInteropObservable(input2);
}
if (isArrayLike(input2)) {
return fromArrayLike(input2);
}
if (isPromise(input2)) {
return fromPromise(input2);
}
if (isAsyncIterable(input2)) {
return fromAsyncIterable(input2);
}
if (isIterable(input2)) {
return fromIterable(input2);
}
if (isReadableStreamLike(input2)) {
return fromReadableStreamLike(input2);
}
}
throw createInvalidObservableTypeError(input2);
}
function fromInteropObservable(obj) {
return new Observable((subscriber) => {
const obs = obj[observable]();
if (isFunction(obs.subscribe)) {
return obs.subscribe(subscriber);
}
throw new TypeError("Provided object does not correctly implement Symbol.observable");
});
}
function fromArrayLike(array) {
return new Observable((subscriber) => {
for (let i = 0; i < array.length && !subscriber.closed; i++) {
subscriber.next(array[i]);
}
subscriber.complete();
});
}
function fromPromise(promise) {
return new Observable((subscriber) => {
promise.then((value2) => {
if (!subscriber.closed) {
subscriber.next(value2);
subscriber.complete();
}
}, (err) => subscriber.error(err)).then(null, reportUnhandledError);
});
}
function fromIterable(iterable) {
return new Observable((subscriber) => {
for (const value2 of iterable) {
subscriber.next(value2);
if (subscriber.closed) {
return;
}
}
subscriber.complete();
});
}
function fromAsyncIterable(asyncIterable) {
return new Observable((subscriber) => {
process2(asyncIterable, subscriber).catch((err) => subscriber.error(err));
});
}
function fromReadableStreamLike(readableStream) {
return fromAsyncIterable(readableStreamLikeToAsyncGenerator(readableStream));
}
function process2(asyncIterable, subscriber) {
var asyncIterable_1, asyncIterable_1_1;
var e_1, _a;
return __awaiter(this, void 0, void 0, function* () {
try {
for (asyncIterable_1 = __asyncValues(asyncIterable); asyncIterable_1_1 = yield asyncIterable_1.next(), !asyncIterable_1_1.done; ) {
const value2 = asyncIterable_1_1.value;
subscriber.next(value2);
if (subscriber.closed) {
return;
}
}
} catch (e_1_1) {
e_1 = { error: e_1_1 };
} finally {
try {
if (asyncIterable_1_1 && !asyncIterable_1_1.done && (_a = asyncIterable_1.return))
yield _a.call(asyncIterable_1);
} finally {
if (e_1)
throw e_1.error;
}
}
subscriber.complete();
});
}
// node_modules/rxjs/dist/esm/internal/util/executeSchedule.js
function executeSchedule(parentSubscription, scheduler, work, delay = 0, repeat = false) {
const scheduleSubscription = scheduler.schedule(function() {
work();
if (repeat) {
parentSubscription.add(this.schedule(null, delay));
} else {
this.unsubscribe();
}
}, delay);
parentSubscription.add(scheduleSubscription);
if (!repeat) {
return scheduleSubscription;
}
}
// node_modules/rxjs/dist/esm/internal/operators/observeOn.js
function observeOn(scheduler, delay = 0) {
return operate((source, subscriber) => {
source.subscribe(createOperatorSubscriber(subscriber, (value2) => executeSchedule(subscriber, scheduler, () => subscriber.next(value2), delay), () => executeSchedule(subscriber, scheduler, () => subscriber.complete(), delay), (err) => executeSchedule(subscriber, scheduler, () => subscriber.error(err), delay)));
});
}
// node_modules/rxjs/dist/esm/internal/operators/subscribeOn.js
function subscribeOn(scheduler, delay = 0) {
return operate((source, subscriber) => {
subscriber.add(scheduler.schedule(() => source.subscribe(subscriber), delay));
});
}
// node_modules/rxjs/dist/esm/internal/scheduled/scheduleObservable.js
function scheduleObservable(input2, scheduler) {
return innerFrom(input2).pipe(subscribeOn(scheduler), observeOn(scheduler));
}
// node_modules/rxjs/dist/esm/internal/scheduled/schedulePromise.js
function schedulePromise(input2, scheduler) {
return innerFrom(input2).pipe(subscribeOn(scheduler), observeOn(scheduler));
}
// node_modules/rxjs/dist/esm/internal/scheduled/scheduleArray.js
function scheduleArray(input2, scheduler) {
return new Observable((subscriber) => {
let i = 0;
return scheduler.schedule(function() {
if (i === input2.length) {
subscriber.complete();
} else {
subscriber.next(input2[i++]);
if (!subscriber.closed) {
this.schedule();
}
}
});
});
}
// node_modules/rxjs/dist/esm/internal/scheduled/scheduleIterable.js
function scheduleIterable(input2, scheduler) {
return new Observable((subscriber) => {
let iterator2;
executeSchedule(subscriber, scheduler, () => {
iterator2 = input2[iterator]();
executeSchedule(subscriber, scheduler, () => {
let value2;
let done;
try {
({ value: value2, done } = iterator2.next());
} catch (err) {
subscriber.error(err);
return;
}
if (done) {
subscriber.complete();
} else {
subscriber.next(value2);
}
}, 0, true);
});
return () => isFunction(iterator2 === null || iterator2 === void 0 ? void 0 : iterator2.return) && iterator2.return();
});
}
// node_modules/rxjs/dist/esm/internal/scheduled/scheduleAsyncIterable.js
function scheduleAsyncIterable(input2, scheduler) {
if (!input2) {
throw new Error("Iterable cannot be null");
}
return new Observable((subscriber) => {
executeSchedule(subscriber, scheduler, () => {
const iterator2 = input2[Symbol.asyncIterator]();
executeSchedule(subscriber, scheduler, () => {
iterator2.next().then((result) => {
if (result.done) {
subscriber.complete();
} else {
subscriber.next(result.value);
}
});
}, 0, true);
});
});
}
// node_modules/rxjs/dist/esm/internal/scheduled/scheduleReadableStreamLike.js
function scheduleReadableStreamLike(input2, scheduler) {
return scheduleAsyncIterable(readableStreamLikeToAsyncGenerator(input2), scheduler);
}
// node_modules/rxjs/dist/esm/internal/scheduled/scheduled.js
function scheduled(input2, scheduler) {
if (input2 != null) {
if (isInteropObservable(input2)) {
return scheduleObservable(input2, scheduler);
}
if (isArrayLike(input2)) {
return scheduleArray(input2, scheduler);
}
if (isPromise(input2)) {
return schedulePromise(input2, scheduler);
}
if (isAsyncIterable(input2)) {
return scheduleAsyncIterable(input2, scheduler);
}
if (isIterable(input2)) {
return scheduleIterable(input2, scheduler);
}
if (isReadableStreamLike(input2)) {
return scheduleReadableStreamLike(input2, scheduler);
}
}
throw createInvalidObservableTypeError(input2);
}
// node_modules/rxjs/dist/esm/internal/observable/from.js
function from(input2, scheduler) {
return scheduler ? scheduled(input2, scheduler) : innerFrom(input2);
}
// node_modules/rxjs/dist/esm/internal/observable/of.js
function of(...args) {
const scheduler = popScheduler(args);
return from(args, scheduler);
}
// node_modules/rxjs/dist/esm/internal/observable/throwError.js
function throwError(errorOrErrorFactory, scheduler) {
const errorFactory = isFunction(errorOrErrorFactory) ? errorOrErrorFactory : () => errorOrErrorFactory;
const init = (subscriber) => subscriber.error(errorFactory());
return new Observable(scheduler ? (subscriber) => scheduler.schedule(init, 0, subscriber) : init);
}
// node_modules/rxjs/dist/esm/internal/util/isObservable.js
function isObservable(obj) {
return !!obj && (obj instanceof Observable || isFunction(obj.lift) && isFunction(obj.subscribe));
}
// node_modules/rxjs/dist/esm/internal/util/EmptyError.js
var EmptyError = createErrorClass((_super) => function EmptyErrorImpl() {
_super(this);
this.name = "EmptyError";
this.message = "no elements in sequence";
});
// node_modules/rxjs/dist/esm/internal/util/isDate.js
function isValidDate(value2) {
return value2 instanceof Date && !isNaN(value2);
}
// node_modules/rxjs/dist/esm/internal/operators/map.js
function map(project, thisArg) {
return operate((source, subscriber) => {
let index2 = 0;
source.subscribe(createOperatorSubscriber(subscriber, (value2) => {
subscriber.next(project.call(thisArg, value2, index2++));
}));
});
}
// node_modules/rxjs/dist/esm/internal/util/mapOneOrManyArgs.js
var { isArray } = Array;
function callOrApply(fn, args) {
return isArray(args) ? fn(...args) : fn(args);
}
function mapOneOrManyArgs(fn) {
return map((args) => callOrApply(fn, args));
}
// node_modules/rxjs/dist/esm/internal/util/argsArgArrayOrObject.js
var { isArray: isArray2 } = Array;
var { getPrototypeOf, prototype: objectProto, keys: getKeys } = Object;
function argsArgArrayOrObject(args) {
if (args.length === 1) {
const first2 = args[0];
if (isArray2(first2)) {
return { args: first2, keys: null };
}
if (isPOJO(first2)) {
const keys = getKeys(first2);
return {
args: keys.map((key2) => first2[key2]),
keys
};
}
}
return { args, keys: null };
}
function isPOJO(obj) {
return obj && typeof obj === "object" && getPrototypeOf(obj) === objectProto;
}
// node_modules/rxjs/dist/esm/internal/util/createObject.js
function createObject(keys, values) {
return keys.reduce((result, key2, i) => (result[key2] = values[i], result), {});
}
// node_modules/rxjs/dist/esm/internal/observable/combineLatest.js
function combineLatest(...args) {
const scheduler = popScheduler(args);
const resultSelector = popResultSelector(args);
const { args: observables, keys } = argsArgArrayOrObject(args);
if (observables.length === 0) {
return from([], scheduler);
}
const result = new Observable(combineLatestInit(observables, scheduler, keys ? (values) => createObject(keys, values) : identity));
return resultSelector ? result.pipe(mapOneOrManyArgs(resultSelector)) : result;
}
function combineLatestInit(observables, scheduler, valueTransform = identity) {
return (subscriber) => {
maybeSchedule(scheduler, () => {
const { length: length2 } = observables;
const values = new Array(length2);
let active2 = length2;
let remainingFirstValues = length2;
for (let i = 0; i < length2; i++) {
maybeSchedule(scheduler, () => {
const source = from(observables[i], scheduler);
let hasFirstValue = false;
source.subscribe(createOperatorSubscriber(subscriber, (value2) => {
values[i] = value2;
if (!hasFirstValue) {
hasFirstValue = true;
remainingFirstValues--;
}
if (!remainingFirstValues) {
subscriber.next(valueTransform(values.slice()));
}
}, () => {
if (!--active2) {
subscriber.complete();
}
}));
}, subscriber);
}
}, subscriber);
};
}
function maybeSchedule(scheduler, execute, subscription) {
if (scheduler) {
executeSchedule(subscription, scheduler, execute);
} else {
execute();
}
}
// node_modules/rxjs/dist/esm/internal/operators/mergeInternals.js
function mergeInternals(source, subscriber, project, concurrent, onBeforeNext, expand, innerSubScheduler, additionalFinalizer) {
const buffer = [];
let active2 = 0;
let index2 = 0;
let isComplete = false;
const checkComplete = () => {
if (isComplete && !buffer.length && !active2) {
subscriber.complete();
}
};
const outerNext = (value2) => active2 < concurrent ? doInnerSub(value2) : buffer.push(value2);
const doInnerSub = (value2) => {
expand && subscriber.next(value2);
active2++;
let innerComplete = false;
innerFrom(project(value2, index2++)).subscribe(createOperatorSubscriber(subscriber, (innerValue) => {
onBeforeNext === null || onBeforeNext === void 0 ? void 0 : onBeforeNext(innerValue);
if (expand) {
outerNext(innerValue);
} else {
subscriber.next(innerValue);
}
}, () => {
innerComplete = true;
}, void 0, () => {
if (innerComplete) {
try {
active2--;
while (buffer.length && active2 < concurrent) {
const bufferedValue = buffer.shift();
if (innerSubScheduler) {
executeSchedule(subscriber, innerSubScheduler, () => doInnerSub(bufferedValue));
} else {
doInnerSub(bufferedValue);
}
}
checkComplete();
} catch (err) {
subscriber.error(err);
}
}
}));
};
source.subscribe(createOperatorSubscriber(subscriber, outerNext, () => {
isComplete = true;
checkComplete();
}));
return () => {
additionalFinalizer === null || additionalFinalizer === void 0 ? void 0 : additionalFinalizer();
};
}
// node_modules/rxjs/dist/esm/internal/operators/mergeMap.js
function mergeMap(project, resultSelector, concurrent = Infinity) {
if (isFunction(resultSelector)) {
return mergeMap((a, i) => map((b, ii) => resultSelector(a, b, i, ii))(innerFrom(project(a, i))), concurrent);
} else if (typeof resultSelector === "number") {
concurrent = resultSelector;
}
return operate((source, subscriber) => mergeInternals(source, subscriber, project, concurrent));
}
// node_modules/rxjs/dist/esm/internal/operators/mergeAll.js
function mergeAll(concurrent = Infinity) {
return mergeMap(identity, concurrent);
}
// node_modules/rxjs/dist/esm/internal/operators/concatAll.js
function concatAll() {
return mergeAll(1);
}
// node_modules/rxjs/dist/esm/internal/observable/concat.js
function concat(...args) {
return concatAll()(from(args, popScheduler(args)));
}
// node_modules/rxjs/dist/esm/internal/observable/defer.js
function defer(observableFactory) {
return new Observable((subscriber) => {
innerFrom(observableFactory()).subscribe(subscriber);
});
}
// node_modules/rxjs/dist/esm/internal/observable/forkJoin.js
function forkJoin(...args) {
const resultSelector = popResultSelector(args);
const { args: sources, keys } = argsArgArrayOrObject(args);
const result = new Observable((subscriber) => {
const { length: length2 } = sources;
if (!length2) {
subscriber.complete();
return;
}
const values = new Array(length2);
let remainingCompletions = length2;
let remainingEmissions = length2;
for (let sourceIndex = 0; sourceIndex < length2; sourceIndex++) {
let hasValue = false;
innerFrom(sources[sourceIndex]).subscribe(createOperatorSubscriber(subscriber, (value2) => {
if (!hasValue) {
hasValue = true;
remainingEmissions--;
}
values[sourceIndex] = value2;
}, () => remainingCompletions--, void 0, () => {
if (!remainingCompletions || !hasValue) {
if (!remainingEmissions) {
subscriber.next(keys ? createObject(keys, values) : values);
}
subscriber.complete();
}
}));
}
});
return resultSelector ? result.pipe(mapOneOrManyArgs(resultSelector)) : result;
}
// node_modules/rxjs/dist/esm/internal/observable/timer.js
function timer(dueTime = 0, intervalOrScheduler, scheduler = async) {
let intervalDuration = -1;
if (intervalOrScheduler != null) {
if (isScheduler(intervalOrScheduler)) {
scheduler = intervalOrScheduler;
} else {
intervalDuration = intervalOrScheduler;
}
}
return new Observable((subscriber) => {
let due = isValidDate(dueTime) ? +dueTime - scheduler.now() : dueTime;
if (due < 0) {
due = 0;
}
let n = 0;
return scheduler.schedule(function() {
if (!subscriber.closed) {
subscriber.next(n++);
if (0 <= intervalDuration) {
this.schedule(void 0, intervalDuration);
} else {
subscriber.complete();
}
}
}, due);
});
}
// node_modules/rxjs/dist/esm/internal/observable/interval.js
function interval(period = 0, scheduler = asyncScheduler) {
if (period < 0) {
period = 0;
}
return timer(period, period, scheduler);
}
// node_modules/rxjs/dist/esm/internal/operators/filter.js
function filter(predicate, thisArg) {
return operate((source, subscriber) => {
let index2 = 0;
source.subscribe(createOperatorSubscriber(subscriber, (value2) => predicate.call(thisArg, value2, index2++) && subscriber.next(value2)));
});
}
// node_modules/rxjs/dist/esm/internal/operators/catchError.js
function catchError(selector) {
return operate((source, subscriber) => {
let innerSub = null;
let syncUnsub = false;
let handledResult;
innerSub = source.subscribe(createOperatorSubscriber(subscriber, void 0, void 0, (err) => {
handledResult = innerFrom(selector(err, catchError(selector)(source)));
if (innerSub) {
innerSub.unsubscribe();
innerSub = null;
handledResult.subscribe(subscriber);
} else {
syncUnsub = true;
}
}));
if (syncUnsub) {
innerSub.unsubscribe();
innerSub = null;
handledResult.subscribe(subscriber);
}
});
}
// node_modules/rxjs/dist/esm/internal/operators/scanInternals.js
function scanInternals(accumulator, seed, hasSeed, emitOnNext, emitBeforeComplete) {
return (source, subscriber) => {
let hasState = hasSeed;
let state = seed;
let index2 = 0;
source.subscribe(createOperatorSubscriber(subscriber, (value2) => {
const i = index2++;
state = hasState ? accumulator(state, value2, i) : (hasState = true, value2);
emitOnNext && subscriber.next(state);
}, emitBeforeComplete && (() => {
hasState && subscriber.next(state);
subscriber.complete();
})));
};
}
// node_modules/rxjs/dist/esm/internal/operators/concatMap.js
function concatMap(project, resultSelector) {
return isFunction(resultSelector) ? mergeMap(project, resultSelector, 1) : mergeMap(project, 1);
}
// node_modules/rxjs/dist/esm/internal/operators/defaultIfEmpty.js
function defaultIfEmpty(defaultValue) {
return operate((source, subscriber) => {
let hasValue = false;
source.subscribe(createOperatorSubscriber(subscriber, (value2) => {
hasValue = true;
subscriber.next(value2);
}, () => {
if (!hasValue) {
subscriber.next(defaultValue);
}
subscriber.complete();
}));
});
}
// node_modules/rxjs/dist/esm/internal/operators/take.js
function take(count) {
return count <= 0 ? () => EMPTY : operate((source, subscriber) => {
let seen = 0;
source.subscribe(createOperatorSubscriber(subscriber, (value2) => {
if (++seen <= count) {
subscriber.next(value2);
if (count <= seen) {
subscriber.complete();
}
}
}));
});
}
// node_modules/rxjs/dist/esm/internal/operators/mapTo.js
function mapTo(value2) {
return map(() => value2);
}
// node_modules/rxjs/dist/esm/internal/operators/throwIfEmpty.js
function throwIfEmpty(errorFactory = defaultErrorFactory) {
return operate((source, subscriber) => {
let hasValue = false;
source.subscribe(createOperatorSubscriber(subscriber, (value2) => {
hasValue = true;
subscriber.next(value2);
}, () => hasValue ? subscriber.complete() : subscriber.error(errorFactory())));
});
}
function defaultErrorFactory() {
return new EmptyError();
}
// node_modules/rxjs/dist/esm/internal/operators/finalize.js
function finalize(callback) {
return operate((source, subscriber) => {
try {
source.subscribe(subscriber);
} finally {
subscriber.add(callback);
}
});
}
// node_modules/rxjs/dist/esm/internal/operators/first.js
function first(predicate, defaultValue) {
const hasDefaultValue = arguments.length >= 2;
return (source) => source.pipe(predicate ? filter((v, i) => predicate(v, i, source)) : identity, take(1), hasDefaultValue ? defaultIfEmpty(defaultValue) : throwIfEmpty(() => new EmptyError()));
}
// node_modules/rxjs/dist/esm/internal/operators/takeLast.js
function takeLast(count) {
return count <= 0 ? () => EMPTY : operate((source, subscriber) => {
let buffer = [];
source.subscribe(createOperatorSubscriber(subscriber, (value2) => {
buffer.push(value2);
count < buffer.length && buffer.shift();
}, () => {
for (const value2 of buffer) {
subscriber.next(value2);
}
subscriber.complete();
}, void 0, () => {
buffer = null;
}));
});
}
// node_modules/rxjs/dist/esm/internal/operators/last.js
function last2(predicate, defaultValue) {
const hasDefaultValue = arguments.length >= 2;
return (source) => source.pipe(predicate ? filter((v, i) => predicate(v, i, source)) : identity, takeLast(1), hasDefaultValue ? defaultIfEmpty(defaultValue) : throwIfEmpty(() => new EmptyError()));
}
// node_modules/rxjs/dist/esm/internal/operators/scan.js
function scan(accumulator, seed) {
return operate(scanInternals(accumulator, seed, arguments.length >= 2, true));
}
// node_modules/rxjs/dist/esm/internal/operators/share.js
function share(options = {}) {
const { connector = () => new Subject(), resetOnError = true, resetOnComplete = true, resetOnRefCountZero = true } = options;
return (wrapperSource) => {
let connection;
let resetConnection;
let subject;
let refCount2 = 0;
let hasCompleted = false;
let hasErrored = false;
const cancelReset = () => {
resetConnection === null || resetConnection === void 0 ? void 0 : resetConnection.unsubscribe();
resetConnection = void 0;
};
const reset = () => {
cancelReset();
connection = subject = void 0;
hasCompleted = hasErrored = false;
};
const resetAndUnsubscribe = () => {
const conn = connection;
reset();
conn === null || conn === void 0 ? void 0 : conn.unsubscribe();
};
return operate((source, subscriber) => {
refCount2++;
if (!hasErrored && !hasCompleted) {
cancelReset();
}
const dest = subject = subject !== null && subject !== void 0 ? subject : connector();
subscriber.add(() => {
refCount2--;
if (refCount2 === 0 && !hasErrored && !hasCompleted) {
resetConnection = handleReset(resetAndUnsubscribe, resetOnRefCountZero);
}
});
dest.subscribe(subscriber);
if (!connection && refCount2 > 0) {
connection = new SafeSubscriber({
next: (value2) => dest.next(value2),
error: (err) => {
hasErrored = true;
cancelReset();
resetConnection = handleReset(reset, resetOnError, err);
dest.error(err);
},
complete: () => {
hasCompleted = true;
cancelReset();
resetConnection = handleReset(reset, resetOnComplete);
dest.complete();
}
});
innerFrom(source).subscribe(connection);
}
})(wrapperSource);
};
}
function handleReset(reset, on, ...args) {
if (on === true) {
reset();
return;
}
if (on === false) {
return;
}
const onSubscriber = new SafeSubscriber({
next: () => {
onSubscriber.unsubscribe();
reset();
}
});
return innerFrom(on(...args)).subscribe(onSubscriber);
}
// node_modules/rxjs/dist/esm/internal/operators/shareReplay.js
function shareReplay(configOrBufferSize, windowTime, scheduler) {
let bufferSize;
let refCount2 = false;
if (configOrBufferSize && typeof configOrBufferSize === "object") {
({ bufferSize = Infinity, windowTime = Infinity, refCount: refCount2 = false, scheduler } = configOrBufferSize);
} else {
bufferSize = configOrBufferSize !== null && configOrBufferSize !== void 0 ? configOrBufferSize : Infinity;
}
return share({
connector: () => new ReplaySubject(bufferSize, windowTime, scheduler),
resetOnError: true,
resetOnComplete: false,
resetOnRefCountZero: refCount2
});
}
// node_modules/rxjs/dist/esm/internal/operators/startWith.js
function startWith(...values) {
const scheduler = popScheduler(values);
return operate((source, subscriber) => {
(scheduler ? concat(values, source, scheduler) : concat(values, source)).subscribe(subscriber);
});
}
// node_modules/rxjs/dist/esm/internal/operators/switchMap.js
function switchMap(project, resultSelector) {
return operate((source, subscriber) => {
let innerSubscriber = null;
let index2 = 0;
let isComplete = false;
const checkComplete = () => isComplete && !innerSubscriber && subscriber.complete();
source.subscribe(createOperatorSubscriber(subscriber, (value2) => {
innerSubscriber === null || innerSubscriber === void 0 ? void 0 : innerSubscriber.unsubscribe();
let innerIndex = 0;
const outerIndex = index2++;
innerFrom(project(value2, outerIndex)).subscribe(innerSubscriber = createOperatorSubscriber(subscriber, (innerValue) => subscriber.next(resultSelector ? resultSelector(value2, innerValue, outerIndex, innerIndex++) : innerValue), () => {
innerSubscriber = null;
checkComplete();
}));
}, () => {
isComplete = true;
checkComplete();
}));
});
}
// node_modules/rxjs/dist/esm/internal/operators/takeUntil.js
function takeUntil(notifier) {
return operate((source, subscriber) => {
innerFrom(notifier).subscribe(createOperatorSubscriber(subscriber, () => subscriber.complete(), noop));
!subscriber.closed && source.subscribe(subscriber);
});
}
// node_modules/rxjs/dist/esm/internal/operators/takeWhile.js
function takeWhile(predicate, inclusive = false) {
return operate((source, subscriber) => {
let index2 = 0;
source.subscribe(createOperatorSubscriber(subscriber, (value2) => {
const result = predicate(value2, index2++);
(result || inclusive) && subscriber.next(value2);
!result && subscriber.complete();
}));
});
}
// node_modules/rxjs/dist/esm/internal/operators/tap.js
function tap(observerOrNext, error, complete) {
const tapObserver = isFunction(observerOrNext) || error || complete ? { next: observerOrNext, error, complete } : observerOrNext;
return tapObserver ? operate((source, subscriber) => {
var _a;
(_a = tapObserver.subscribe) === null || _a === void 0 ? void 0 : _a.call(tapObserver);
let isUnsub = true;
source.subscribe(createOperatorSubscriber(subscriber, (value2) => {
var _a2;
(_a2 = tapObserver.next) === null || _a2 === void 0 ? void 0 : _a2.call(tapObserver, value2);
subscriber.next(value2);
}, () => {
var _a2;
isUnsub = false;
(_a2 = tapObserver.complete) === null || _a2 === void 0 ? void 0 : _a2.call(tapObserver);
subscriber.complete();
}, (err) => {
var _a2;
isUnsub = false;
(_a2 = tapObserver.error) === null || _a2 === void 0 ? void 0 : _a2.call(tapObserver, err);
subscriber.error(err);
}, () => {
var _a2, _b;
if (isUnsub) {
(_a2 = tapObserver.unsubscribe) === null || _a2 === void 0 ? void 0 : _a2.call(tapObserver);
}
(_b = tapObserver.finalize) === null || _b === void 0 ? void 0 : _b.call(tapObserver);
}));
}) : identity;
}
// node_modules/@angular/core/fesm2022/core.mjs
var ERROR_DETAILS_PAGE_BASE_URL = "https://angular.io/errors";
var XSS_SECURITY_URL = "https://g.co/ng/security#xss";
var RuntimeError = class extends Error {
constructor(code, message) {
super(formatRuntimeError(code, message));
this.code = code;
}
};
function formatRuntimeError(code, message) {
const fullCode = `NG0${Math.abs(code)}`;
let errorMessage = `${fullCode}${message ? ": " + message : ""}`;
if (ngDevMode && code < 0) {
const addPeriodSeparator = !errorMessage.match(/[.,;!?\n]$/);
const separator = addPeriodSeparator ? "." : "";
errorMessage = `${errorMessage}${separator} Find more at ${ERROR_DETAILS_PAGE_BASE_URL}/${fullCode}`;
}
return errorMessage;
}
var REQUIRED_UNSET_VALUE = /* @__PURE__ */ Symbol("InputSignalNode#UNSET");
var INPUT_SIGNAL_NODE = /* @__PURE__ */ (() => {
return __spreadProps(__spreadValues({}, SIGNAL_NODE), {
transformFn: void 0,
applyValueToInputSignal(node, value2) {
signalSetFn(node, value2);
}
});
})();
function createInputSignal(initialValue, options) {
const node = Object.create(INPUT_SIGNAL_NODE);
node.value = initialValue;
node.transformFn = options?.transform;
function inputValueFn() {
producerAccessed(node);
if (node.value === REQUIRED_UNSET_VALUE) {
throw new RuntimeError(-950, ngDevMode && "Input is required but no value is available yet.");
}
return node.value;
}
inputValueFn[SIGNAL] = node;
if (ngDevMode) {
inputValueFn.toString = () => `[Input Signal: ${inputValueFn()}]`;
}
return inputValueFn;
}
function noSideEffects(fn) {
return { toString: fn }.toString();
}
var ANNOTATIONS = "__annotations__";
var PARAMETERS = "__parameters__";
var PROP_METADATA = "__prop__metadata__";
function makeDecorator(name2, props, parentClass, additionalProcessing, typeFn) {
return noSideEffects(() => {
const metaCtor = makeMetadataCtor(props);
function DecoratorFactory(...args) {
if (this instanceof DecoratorFactory) {
metaCtor.call(this, ...args);
return this;
}
const annotationInstance = new DecoratorFactory(...args);
return function TypeDecorator(cls) {
if (typeFn)
typeFn(cls, ...args);
const annotations = cls.hasOwnProperty(ANNOTATIONS) ? cls[ANNOTATIONS] : Object.defineProperty(cls, ANNOTATIONS, { value: [] })[ANNOTATIONS];
annotations.push(annotationInstance);
if (additionalProcessing)
additionalProcessing(cls);
return cls;
};
}
if (parentClass) {
DecoratorFactory.prototype = Object.create(parentClass.prototype);
}
DecoratorFactory.prototype.ngMetadataName = name2;
DecoratorFactory.annotationCls = DecoratorFactory;
return DecoratorFactory;
});
}
function makeMetadataCtor(props) {
return function ctor(...args) {
if (props) {
const values = props(...args);
for (const propName in values) {
this[propName] = values[propName];
}
}
};
}
function makeParamDecorator(name2, props, parentClass) {
return noSideEffects(() => {
const metaCtor = makeMetadataCtor(props);
function ParamDecoratorFactory(...args) {
if (this instanceof ParamDecoratorFactory) {
metaCtor.apply(this, args);
return this;
}
const annotationInstance = new ParamDecoratorFactory(...args);
ParamDecorator.annotation = annotationInstance;
return ParamDecorator;
function ParamDecorator(cls, unusedKey, index2) {
const parameters = cls.hasOwnProperty(PARAMETERS) ? cls[PARAMETERS] : Object.defineProperty(cls, PARAMETERS, { value: [] })[PARAMETERS];
while (parameters.length <= index2) {
parameters.push(null);
}
(parameters[index2] = parameters[index2] || []).push(annotationInstance);
return cls;
}
}
if (parentClass) {
ParamDecoratorFactory.prototype = Object.create(parentClass.prototype);
}
ParamDecoratorFactory.prototype.ngMetadataName = name2;
ParamDecoratorFactory.annotationCls = ParamDecoratorFactory;
return ParamDecoratorFactory;
});
}
function makePropDecorator(name2, props, parentClass, additionalProcessing) {
return noSideEffects(() => {
const metaCtor = makeMetadataCtor(props);
function PropDecoratorFactory(...args) {
if (this instanceof PropDecoratorFactory) {
metaCtor.apply(this, args);
return this;
}
const decoratorInstance = new PropDecoratorFactory(...args);
function PropDecorator(target, name3) {
if (target === void 0) {
throw new Error("Standard Angular field decorators are not supported in JIT mode.");
}
const constructor = target.constructor;
const meta = constructor.hasOwnProperty(PROP_METADATA) ? constructor[PROP_METADATA] : Object.defineProperty(constructor, PROP_METADATA, { value: {} })[PROP_METADATA];
meta[name3] = meta.hasOwnProperty(name3) && meta[name3] || [];
meta[name3].unshift(decoratorInstance);
if (additionalProcessing)
additionalProcessing(target, name3, ...args);
}
return PropDecorator;
}
if (parentClass) {
PropDecoratorFactory.prototype = Object.create(parentClass.prototype);
}
PropDecoratorFactory.prototype.ngMetadataName = name2;
PropDecoratorFactory.annotationCls = PropDecoratorFactory;
return PropDecoratorFactory;
});
}
var _global = globalThis;
function ngDevModeResetPerfCounters() {
const locationString = typeof location !== "undefined" ? location.toString() : "";
const newCounters = {
namedConstructors: locationString.indexOf("ngDevMode=namedConstructors") != -1,
firstCreatePass: 0,
tNode: 0,
tView: 0,
rendererCreateTextNode: 0,
rendererSetText: 0,
rendererCreateElement: 0,
rendererAddEventListener: 0,
rendererSetAttribute: 0,
rendererRemoveAttribute: 0,
rendererSetProperty: 0,
rendererSetClassName: 0,
rendererAddClass: 0,
rendererRemoveClass: 0,
rendererSetStyle: 0,
rendererRemoveStyle: 0,
rendererDestroy: 0,
rendererDestroyNode: 0,
rendererMoveNode: 0,
rendererRemoveNode: 0,
rendererAppendChild: 0,
rendererInsertBefore: 0,
rendererCreateComment: 0,
hydratedNodes: 0,
hydratedComponents: 0,
dehydratedViewsRemoved: 0,
dehydratedViewsCleanupRuns: 0,
componentsSkippedHydration: 0
};
const allowNgDevModeTrue = locationString.indexOf("ngDevMode=false") === -1;
if (!allowNgDevModeTrue) {
_global["ngDevMode"] = false;
} else {
if (typeof _global["ngDevMode"] !== "object") {
_global["ngDevMode"] = {};
}
Object.assign(_global["ngDevMode"], newCounters);
}
return newCounters;
}
function initNgDevMode() {
if (typeof ngDevMode === "undefined" || ngDevMode) {
if (typeof ngDevMode !== "object" || Object.keys(ngDevMode).length === 0) {
ngDevModeResetPerfCounters();
}
return typeof ngDevMode !== "undefined" && !!ngDevMode;
}
return false;
}
function getClosureSafeProperty(objWithPropertyToExtract) {
for (let key2 in objWithPropertyToExtract) {
if (objWithPropertyToExtract[key2] === getClosureSafeProperty) {
return key2;
}
}
throw Error("Could not find renamed property on target object.");
}
function fillProperties(target, source) {
for (const key2 in source) {
if (source.hasOwnProperty(key2) && !target.hasOwnProperty(key2)) {
target[key2] = source[key2];
}
}
}
function stringify(token) {
if (typeof token === "string") {
return token;
}
if (Array.isArray(token)) {
return "[" + token.map(stringify).join(", ") + "]";
}
if (token == null) {
return "" + token;
}
if (token.overriddenName) {
return `${token.overriddenName}`;
}
if (token.name) {
return `${token.name}`;
}
const res = token.toString();
if (res == null) {
return "" + res;
}
const newLineIndex = res.indexOf("\n");
return newLineIndex === -1 ? res : res.substring(0, newLineIndex);
}
function concatStringsWithSpace(before, after) {
return before == null || before === "" ? after === null ? "" : after : after == null || after === "" ? before : before + " " + after;
}
var __forward_ref__ = getClosureSafeProperty({ __forward_ref__: getClosureSafeProperty });
function forwardRef(forwardRefFn) {
forwardRefFn.__forward_ref__ = forwardRef;
forwardRefFn.toString = function() {
return stringify(this());
};
return forwardRefFn;
}
function resolveForwardRef(type) {
return isForwardRef(type) ? type() : type;
}
function isForwardRef(fn) {
return typeof fn === "function" && fn.hasOwnProperty(__forward_ref__) && fn.__forward_ref__ === forwardRef;
}
function assertNumber(actual, msg) {
if (!(typeof actual === "number")) {
throwError2(msg, typeof actual, "number", "===");
}
}
function assertNumberInRange(actual, minInclusive, maxInclusive) {
assertNumber(actual, "Expected a number");
assertLessThanOrEqual(actual, maxInclusive, "Expected number to be less than or equal to");
assertGreaterThanOrEqual(actual, minInclusive, "Expected number to be greater than or equal to");
}
function assertString(actual, msg) {
if (!(typeof actual === "string")) {
throwError2(msg, actual === null ? "null" : typeof actual, "string", "===");
}
}
function assertFunction(actual, msg) {
if (!(typeof actual === "function")) {
throwError2(msg, actual === null ? "null" : typeof actual, "function", "===");
}
}
function assertEqual(actual, expected, msg) {
if (!(actual == expected)) {
throwError2(msg, actual, expected, "==");
}
}
function assertNotEqual(actual, expected, msg) {
if (!(actual != expected)) {
throwError2(msg, actual, expected, "!=");
}
}
function assertSame(actual, expected, msg) {
if (!(actual === expected)) {
throwError2(msg, actual, expected, "===");
}
}
function assertNotSame(actual, expected, msg) {
if (!(actual !== expected)) {
throwError2(msg, actual, expected, "!==");
}
}
function assertLessThan(actual, expected, msg) {
if (!(actual < expected)) {
throwError2(msg, actual, expected, "<");
}
}
function assertLessThanOrEqual(actual, expected, msg) {
if (!(actual <= expected)) {
throwError2(msg, actual, expected, "<=");
}
}
function assertGreaterThan(actual, expected, msg) {
if (!(actual > expected)) {
throwError2(msg, actual, expected, ">");
}
}
function assertGreaterThanOrEqual(actual, expected, msg) {
if (!(actual >= expected)) {
throwError2(msg, actual, expected, ">=");
}
}
function assertDefined(actual, msg) {
if (actual == null) {
throwError2(msg, actual, null, "!=");
}
}
function throwError2(msg, actual, expected, comparison) {
throw new Error(`ASSERTION ERROR: ${msg}` + (comparison == null ? "" : ` [Expected=> ${expected} ${comparison} ${actual} <=Actual]`));
}
function assertDomNode(node) {
if (!(node instanceof Node)) {
throwError2(`The provided value must be an instance of a DOM Node but got ${stringify(node)}`);
}
}
function assertElement(node) {
if (!(node instanceof Element)) {
throwError2(`The provided value must be an element but got ${stringify(node)}`);
}
}
function assertIndexInRange(arr, index2) {
assertDefined(arr, "Array must be defined.");
const maxLen = arr.length;
if (index2 < 0 || index2 >= maxLen) {
throwError2(`Index expected to be less than ${maxLen} but got ${index2}`);
}
}
function assertOneOf(value2, ...validValues) {
if (validValues.indexOf(value2) !== -1)
return true;
throwError2(`Expected value to be one of ${JSON.stringify(validValues)} but was ${JSON.stringify(value2)}.`);
}
function assertNotReactive(fn) {
if (getActiveConsumer() !== null) {
throwError2(`${fn}() should never be called in a reactive context.`);
}
}
function \u0275\u0275defineInjectable(opts) {
return {
token: opts.token,
providedIn: opts.providedIn || null,
factory: opts.factory,
value: void 0
};
}
function \u0275\u0275defineInjector(options) {
return { providers: options.providers || [], imports: options.imports || [] };
}
function getInjectableDef(type) {
return getOwnDefinition(type, NG_PROV_DEF) || getOwnDefinition(type, NG_INJECTABLE_DEF);
}
function isInjectable(type) {
return getInjectableDef(type) !== null;
}
function getOwnDefinition(type, field) {
return type.hasOwnProperty(field) ? type[field] : null;
}
function getInheritedInjectableDef(type) {
const def = type && (type[NG_PROV_DEF] || type[NG_INJECTABLE_DEF]);
if (def) {
ngDevMode && console.warn(`DEPRECATED: DI is instantiating a token "${type.name}" that inherits its @Injectable decorator but does not provide one itself.
This will become an error in a future version of Angular. Please add @Injectable() to the "${type.name}" class.`);
return def;
} else {
return null;
}
}
function getInjectorDef(type) {
return type && (type.hasOwnProperty(NG_INJ_DEF) || type.hasOwnProperty(NG_INJECTOR_DEF)) ? type[NG_INJ_DEF] : null;
}
var NG_PROV_DEF = getClosureSafeProperty({ \u0275prov: getClosureSafeProperty });
var NG_INJ_DEF = getClosureSafeProperty({ \u0275inj: getClosureSafeProperty });
var NG_INJECTABLE_DEF = getClosureSafeProperty({ ngInjectableDef: getClosureSafeProperty });
var NG_INJECTOR_DEF = getClosureSafeProperty({ ngInjectorDef: getClosureSafeProperty });
var InjectionToken = class {
/**
* @param _desc Description for the token,
* used only for debugging purposes,
* it should but does not need to be unique
* @param options Options for the token's usage, as described above
*/
constructor(_desc, options) {
this._desc = _desc;
this.ngMetadataName = "InjectionToken";
this.\u0275prov = void 0;
if (typeof options == "number") {
(typeof ngDevMode === "undefined" || ngDevMode) && assertLessThan(options, 0, "Only negative numbers are supported here");
this.__NG_ELEMENT_ID__ = options;
} else if (options !== void 0) {
this.\u0275prov = \u0275\u0275defineInjectable({
token: this,
providedIn: options.providedIn || "root",
factory: options.factory
});
}
}
/**
* @internal
*/
get multi() {
return this;
}
toString() {
return `InjectionToken ${this._desc}`;
}
};
var _injectorProfilerContext;
function getInjectorProfilerContext() {
!ngDevMode && throwError2("getInjectorProfilerContext should never be called in production mode");
return _injectorProfilerContext;
}
function setInjectorProfilerContext(context2) {
!ngDevMode && throwError2("setInjectorProfilerContext should never be called in production mode");
const previous = _injectorProfilerContext;
_injectorProfilerContext = context2;
return previous;
}
var injectorProfilerCallback = null;
var setInjectorProfiler = (injectorProfiler2) => {
!ngDevMode && throwError2("setInjectorProfiler should never be called in production mode");
injectorProfilerCallback = injectorProfiler2;
};
function injectorProfiler(event) {
!ngDevMode && throwError2("Injector profiler should never be called in production mode");
if (injectorProfilerCallback != null) {
injectorProfilerCallback(event);
}
}
function emitProviderConfiguredEvent(eventProvider, isViewProvider = false) {
!ngDevMode && throwError2("Injector profiler should never be called in production mode");
let token;
if (typeof eventProvider === "function") {
token = eventProvider;
} else if (eventProvider instanceof InjectionToken) {
token = eventProvider;
} else {
token = resolveForwardRef(eventProvider.provide);
}
let provider = eventProvider;
if (eventProvider instanceof InjectionToken) {
provider = eventProvider.\u0275prov || eventProvider;
}
injectorProfiler({
type: 2,
context: getInjectorProfilerContext(),
providerRecord: { token, provider, isViewProvider }
});
}
function emitInstanceCreatedByInjectorEvent(instance) {
!ngDevMode && throwError2("Injector profiler should never be called in production mode");
injectorProfiler({
type: 1,
context: getInjectorProfilerContext(),
instance: { value: instance }
});
}
function emitInjectEvent(token, value2, flags) {
!ngDevMode && throwError2("Injector profiler should never be called in production mode");
injectorProfiler({
type: 0,
context: getInjectorProfilerContext(),
service: { token, value: value2, flags }
});
}
function runInInjectorProfilerContext(injector, token, callback) {
!ngDevMode && throwError2("runInInjectorProfilerContext should never be called in production mode");
const prevInjectContext = setInjectorProfilerContext({ injector, token });
try {
callback();
} finally {
setInjectorProfilerContext(prevInjectContext);
}
}
function isEnvironmentProviders(value2) {
return value2 && !!value2.\u0275providers;
}
var NG_COMP_DEF = getClosureSafeProperty({ \u0275cmp: getClosureSafeProperty });
var NG_DIR_DEF = getClosureSafeProperty({ \u0275dir: getClosureSafeProperty });
var NG_PIPE_DEF = getClosureSafeProperty({ \u0275pipe: getClosureSafeProperty });
var NG_MOD_DEF = getClosureSafeProperty({ \u0275mod: getClosureSafeProperty });
var NG_FACTORY_DEF = getClosureSafeProperty({ \u0275fac: getClosureSafeProperty });
var NG_ELEMENT_ID = getClosureSafeProperty({ __NG_ELEMENT_ID__: getClosureSafeProperty });
var NG_ENV_ID = getClosureSafeProperty({ __NG_ENV_ID__: getClosureSafeProperty });
function renderStringify(value2) {
if (typeof value2 === "string")
return value2;
if (value2 == null)
return "";
return String(value2);
}
function stringifyForError(value2) {
if (typeof value2 === "function")
return value2.name || value2.toString();
if (typeof value2 === "object" && value2 != null && typeof value2.type === "function") {
return value2.type.name || value2.type.toString();
}
return renderStringify(value2);
}
function throwCyclicDependencyError(token, path) {
const depPath = path ? `. Dependency path: ${path.join(" > ")} > ${token}` : "";
throw new RuntimeError(-200, ngDevMode ? `Circular dependency in DI detected for ${token}${depPath}` : token);
}
function throwMixedMultiProviderError() {
throw new Error(`Cannot mix multi providers and regular providers`);
}
function throwInvalidProviderError(ngModuleType, providers, provider) {
if (ngModuleType && providers) {
const providerDetail = providers.map((v) => v == provider ? "?" + provider + "?" : "...");
throw new Error(`Invalid provider for the NgModule '${stringify(ngModuleType)}' - only instances of Provider and Type are allowed, got: [${providerDetail.join(", ")}]`);
} else if (isEnvironmentProviders(provider)) {
if (provider.\u0275fromNgModule) {
throw new RuntimeError(207, `Invalid providers from 'importProvidersFrom' present in a non-environment injector. 'importProvidersFrom' can't be used for component providers.`);
} else {
throw new RuntimeError(207, `Invalid providers present in a non-environment injector. 'EnvironmentProviders' can't be used for component providers.`);
}
} else {
throw new Error("Invalid provider");
}
}
function throwProviderNotFoundError(token, injectorName) {
const errorMessage = ngDevMode && `No provider for ${stringifyForError(token)} found${injectorName ? ` in ${injectorName}` : ""}`;
throw new RuntimeError(-201, errorMessage);
}
var InjectFlags;
(function(InjectFlags2) {
InjectFlags2[InjectFlags2["Default"] = 0] = "Default";
InjectFlags2[InjectFlags2["Host"] = 1] = "Host";
InjectFlags2[InjectFlags2["Self"] = 2] = "Self";
InjectFlags2[InjectFlags2["SkipSelf"] = 4] = "SkipSelf";
InjectFlags2[InjectFlags2["Optional"] = 8] = "Optional";
})(InjectFlags || (InjectFlags = {}));
var _injectImplementation;
function getInjectImplementation() {
return _injectImplementation;
}
function setInjectImplementation(impl) {
const previous = _injectImplementation;
_injectImplementation = impl;
return previous;
}
function injectRootLimpMode(token, notFoundValue, flags) {
const injectableDef = getInjectableDef(token);
if (injectableDef && injectableDef.providedIn == "root") {
return injectableDef.value === void 0 ? injectableDef.value = injectableDef.factory() : injectableDef.value;
}
if (flags & InjectFlags.Optional)
return null;
if (notFoundValue !== void 0)
return notFoundValue;
throwProviderNotFoundError(token, "Injector");
}
function assertInjectImplementationNotEqual(fn) {
ngDevMode && assertNotEqual(_injectImplementation, fn, "Calling \u0275\u0275inject would cause infinite recursion");
}
var _THROW_IF_NOT_FOUND = {};
var THROW_IF_NOT_FOUND = _THROW_IF_NOT_FOUND;
var DI_DECORATOR_FLAG = "__NG_DI_FLAG__";
var NG_TEMP_TOKEN_PATH = "ngTempTokenPath";
var NG_TOKEN_PATH = "ngTokenPath";
var NEW_LINE = /\n/gm;
var NO_NEW_LINE = "\u0275";
var SOURCE = "__source";
var _currentInjector = void 0;
function getCurrentInjector() {
return _currentInjector;
}
function setCurrentInjector(injector) {
const former = _currentInjector;
_currentInjector = injector;
return former;
}
function injectInjectorOnly(token, flags = InjectFlags.Default) {
if (_currentInjector === void 0) {
throw new RuntimeError(-203, ngDevMode && `inject() must be called from an injection context such as a constructor, a factory function, a field initializer, or a function used with \`runInInjectionContext\`.`);
} else if (_currentInjector === null) {
return injectRootLimpMode(token, void 0, flags);
} else {
const value2 = _currentInjector.get(token, flags & InjectFlags.Optional ? null : void 0, flags);
ngDevMode && emitInjectEvent(token, value2, flags);
return value2;
}
}
function \u0275\u0275inject(token, flags = InjectFlags.Default) {
return (getInjectImplementation() || injectInjectorOnly)(resolveForwardRef(token), flags);
}
function \u0275\u0275invalidFactoryDep(index2) {
throw new RuntimeError(202, ngDevMode && `This constructor is not compatible with Angular Dependency Injection because its dependency at index ${index2} of the parameter list is invalid.
This can happen if the dependency type is a primitive like a string or if an ancestor of this class is missing an Angular decorator.
Please check that 1) the type for the parameter at index ${index2} is correct and 2) the correct Angular decorators are defined for this class and its ancestors.`);
}
function inject(token, flags = InjectFlags.Default) {
return \u0275\u0275inject(token, convertToBitFlags(flags));
}
function convertToBitFlags(flags) {
if (typeof flags === "undefined" || typeof flags === "number") {
return flags;
}
return 0 | // comment to force a line break in the formatter
(flags.optional && 8) | (flags.host && 1) | (flags.self && 2) | (flags.skipSelf && 4);
}
function injectArgs(types) {
const args = [];
for (let i = 0; i < types.length; i++) {
const arg = resolveForwardRef(types[i]);
if (Array.isArray(arg)) {
if (arg.length === 0) {
throw new RuntimeError(900, ngDevMode && "Arguments array must have arguments.");
}
let type = void 0;
let flags = InjectFlags.Default;
for (let j = 0; j < arg.length; j++) {
const meta = arg[j];
const flag = getInjectFlag(meta);
if (typeof flag === "number") {
if (flag === -1) {
type = meta.token;
} else {
flags |= flag;
}
} else {
type = meta;
}
}
args.push(\u0275\u0275inject(type, flags));
} else {
args.push(\u0275\u0275inject(arg));
}
}
return args;
}
function attachInjectFlag(decorator, flag) {
decorator[DI_DECORATOR_FLAG] = flag;
decorator.prototype[DI_DECORATOR_FLAG] = flag;
return decorator;
}
function getInjectFlag(token) {
return token[DI_DECORATOR_FLAG];
}
function catchInjectorError(e, token, injectorErrorName, source) {
const tokenPath = e[NG_TEMP_TOKEN_PATH];
if (token[SOURCE]) {
tokenPath.unshift(token[SOURCE]);
}
e.message = formatError("\n" + e.message, tokenPath, injectorErrorName, source);
e[NG_TOKEN_PATH] = tokenPath;
e[NG_TEMP_TOKEN_PATH] = null;
throw e;
}
function formatError(text2, obj, injectorErrorName, source = null) {
text2 = text2 && text2.charAt(0) === "\n" && text2.charAt(1) == NO_NEW_LINE ? text2.slice(2) : text2;
let context2 = stringify(obj);
if (Array.isArray(obj)) {
context2 = obj.map(stringify).join(" -> ");
} else if (typeof obj === "object") {
let parts = [];
for (let key2 in obj) {
if (obj.hasOwnProperty(key2)) {
let value2 = obj[key2];
parts.push(key2 + ":" + (typeof value2 === "string" ? JSON.stringify(value2) : stringify(value2)));
}
}
context2 = `{${parts.join(", ")}}`;
}
return `${injectorErrorName}${source ? "(" + source + ")" : ""}[${context2}]: ${text2.replace(NEW_LINE, "\n ")}`;
}
var Inject = attachInjectFlag(
// Disable tslint because `DecoratorFlags` is a const enum which gets inlined.
// tslint:disable-next-line: no-toplevel-property-access
makeParamDecorator("Inject", (token) => ({ token })),
-1
/* DecoratorFlags.Inject */
);
var Optional = (
// Disable tslint because `InternalInjectFlags` is a const enum which gets inlined.
// tslint:disable-next-line: no-toplevel-property-access
attachInjectFlag(
makeParamDecorator("Optional"),
8
/* InternalInjectFlags.Optional */
)
);
var Self = (
// Disable tslint because `InternalInjectFlags` is a const enum which gets inlined.
// tslint:disable-next-line: no-toplevel-property-access
attachInjectFlag(
makeParamDecorator("Self"),
2
/* InternalInjectFlags.Self */
)
);
var SkipSelf = (
// Disable tslint because `InternalInjectFlags` is a const enum which gets inlined.
// tslint:disable-next-line: no-toplevel-property-access
attachInjectFlag(
makeParamDecorator("SkipSelf"),
4
/* InternalInjectFlags.SkipSelf */
)
);
var Host = (
// Disable tslint because `InternalInjectFlags` is a const enum which gets inlined.
// tslint:disable-next-line: no-toplevel-property-access
attachInjectFlag(
makeParamDecorator("Host"),
1
/* InternalInjectFlags.Host */
)
);
function getFactoryDef(type, throwNotFound) {
const hasFactoryDef = type.hasOwnProperty(NG_FACTORY_DEF);
if (!hasFactoryDef && throwNotFound === true && ngDevMode) {
throw new Error(`Type ${stringify(type)} does not have '\u0275fac' property.`);
}
return hasFactoryDef ? type[NG_FACTORY_DEF] : null;
}
function arrayEquals(a, b, identityAccessor) {
if (a.length !== b.length)
return false;
for (let i = 0; i < a.length; i++) {
let valueA = a[i];
let valueB = b[i];
if (identityAccessor) {
valueA = identityAccessor(valueA);
valueB = identityAccessor(valueB);
}
if (valueB !== valueA) {
return false;
}
}
return true;
}
function flatten(list) {
return list.flat(Number.POSITIVE_INFINITY);
}
function deepForEach(input2, fn) {
input2.forEach((value2) => Array.isArray(value2) ? deepForEach(value2, fn) : fn(value2));
}
function addToArray(arr, index2, value2) {
if (index2 >= arr.length) {
arr.push(value2);
} else {
arr.splice(index2, 0, value2);
}
}
function removeFromArray(arr, index2) {
if (index2 >= arr.length - 1) {
return arr.pop();
} else {
return arr.splice(index2, 1)[0];
}
}
function newArray(size, value2) {
const list = [];
for (let i = 0; i < size; i++) {
list.push(value2);
}
return list;
}
function arraySplice(array, index2, count) {
const length2 = array.length - count;
while (index2 < length2) {
array[index2] = array[index2 + count];
index2++;
}
while (count--) {
array.pop();
}
}
function arrayInsert2(array, index2, value1, value2) {
ngDevMode && assertLessThanOrEqual(index2, array.length, "Can't insert past array end.");
let end = array.length;
if (end == index2) {
array.push(value1, value2);
} else if (end === 1) {
array.push(value2, array[0]);
array[0] = value1;
} else {
end--;
array.push(array[end - 1], array[end]);
while (end > index2) {
const previousEnd = end - 2;
array[end] = array[previousEnd];
end--;
}
array[index2] = value1;
array[index2 + 1] = value2;
}
}
function keyValueArraySet(keyValueArray, key2, value2) {
let index2 = keyValueArrayIndexOf(keyValueArray, key2);
if (index2 >= 0) {
keyValueArray[index2 | 1] = value2;
} else {
index2 = ~index2;
arrayInsert2(keyValueArray, index2, key2, value2);
}
return index2;
}
function keyValueArrayGet(keyValueArray, key2) {
const index2 = keyValueArrayIndexOf(keyValueArray, key2);
if (index2 >= 0) {
return keyValueArray[index2 | 1];
}
return void 0;
}
function keyValueArrayIndexOf(keyValueArray, key2) {
return _arrayIndexOfSorted(keyValueArray, key2, 1);
}
function _arrayIndexOfSorted(array, value2, shift) {
ngDevMode && assertEqual(Array.isArray(array), true, "Expecting an array");
let start = 0;
let end = array.length >> shift;
while (end !== start) {
const middle = start + (end - start >> 1);
const current = array[middle << shift];
if (value2 === current) {
return middle << shift;
} else if (current > value2) {
end = middle;
} else {
start = middle + 1;
}
}
return ~(end << shift);
}
var EMPTY_OBJ = {};
var EMPTY_ARRAY = [];
if ((typeof ngDevMode === "undefined" || ngDevMode) && initNgDevMode()) {
Object.freeze(EMPTY_OBJ);
Object.freeze(EMPTY_ARRAY);
}
var ENVIRONMENT_INITIALIZER = new InjectionToken(ngDevMode ? "ENVIRONMENT_INITIALIZER" : "");
var INJECTOR$1 = new InjectionToken(
ngDevMode ? "INJECTOR" : "",
// Disable tslint because this is const enum which gets inlined not top level prop access.
// tslint:disable-next-line: no-toplevel-property-access
-1
/* InjectorMarkers.Injector */
);
var INJECTOR_DEF_TYPES = new InjectionToken(ngDevMode ? "INJECTOR_DEF_TYPES" : "");
var NullInjector = class {
get(token, notFoundValue = THROW_IF_NOT_FOUND) {
if (notFoundValue === THROW_IF_NOT_FOUND) {
const error = new Error(`NullInjectorError: No provider for ${stringify(token)}!`);
error.name = "NullInjectorError";
throw error;
}
return notFoundValue;
}
};
var ChangeDetectionStrategy;
(function(ChangeDetectionStrategy2) {
ChangeDetectionStrategy2[ChangeDetectionStrategy2["OnPush"] = 0] = "OnPush";
ChangeDetectionStrategy2[ChangeDetectionStrategy2["Default"] = 1] = "Default";
})(ChangeDetectionStrategy || (ChangeDetectionStrategy = {}));
var ViewEncapsulation$1;
(function(ViewEncapsulation2) {
ViewEncapsulation2[ViewEncapsulation2["Emulated"] = 0] = "Emulated";
ViewEncapsulation2[ViewEncapsulation2["None"] = 2] = "None";
ViewEncapsulation2[ViewEncapsulation2["ShadowDom"] = 3] = "ShadowDom";
})(ViewEncapsulation$1 || (ViewEncapsulation$1 = {}));
var InputFlags;
(function(InputFlags2) {
InputFlags2[InputFlags2["None"] = 0] = "None";
InputFlags2[InputFlags2["SignalBased"] = 1] = "SignalBased";
InputFlags2[InputFlags2["HasDecoratorInputTransform"] = 2] = "HasDecoratorInputTransform";
})(InputFlags || (InputFlags = {}));
function classIndexOf(className, classToSearch, startingIndex) {
ngDevMode && assertNotEqual(classToSearch, "", 'can not look for "" string.');
let end = className.length;
while (true) {
const foundIndex = className.indexOf(classToSearch, startingIndex);
if (foundIndex === -1)
return foundIndex;
if (foundIndex === 0 || className.charCodeAt(foundIndex - 1) <= 32) {
const length2 = classToSearch.length;
if (foundIndex + length2 === end || className.charCodeAt(foundIndex + length2) <= 32) {
return foundIndex;
}
}
startingIndex = foundIndex + 1;
}
}
function setUpAttributes(renderer2, native, attrs) {
let i = 0;
while (i < attrs.length) {
const value2 = attrs[i];
if (typeof value2 === "number") {
if (value2 !== 0) {
break;
}
i++;
const namespaceURI = attrs[i++];
const attrName = attrs[i++];
const attrVal = attrs[i++];
ngDevMode && ngDevMode.rendererSetAttribute++;
renderer2.setAttribute(native, attrName, attrVal, namespaceURI);
} else {
const attrName = value2;
const attrVal = attrs[++i];
ngDevMode && ngDevMode.rendererSetAttribute++;
if (isAnimationProp(attrName)) {
renderer2.setProperty(native, attrName, attrVal);
} else {
renderer2.setAttribute(native, attrName, attrVal);
}
i++;
}
}
return i;
}
function isNameOnlyAttributeMarker(marker) {
return marker === 3 || marker === 4 || marker === 6;
}
function isAnimationProp(name2) {
return name2.charCodeAt(0) === 64;
}
function mergeHostAttrs(dst, src) {
if (src === null || src.length === 0) {
} else if (dst === null || dst.length === 0) {
dst = src.slice();
} else {
let srcMarker = -1;
for (let i = 0; i < src.length; i++) {
const item = src[i];
if (typeof item === "number") {
srcMarker = item;
} else {
if (srcMarker === 0) {
} else if (srcMarker === -1 || srcMarker === 2) {
mergeHostAttribute(dst, srcMarker, item, null, src[++i]);
} else {
mergeHostAttribute(dst, srcMarker, item, null, null);
}
}
}
}
return dst;
}
function mergeHostAttribute(dst, marker, key1, key2, value2) {
let i = 0;
let markerInsertPosition = dst.length;
if (marker === -1) {
markerInsertPosition = -1;
} else {
while (i < dst.length) {
const dstValue = dst[i++];
if (typeof dstValue === "number") {
if (dstValue === marker) {
markerInsertPosition = -1;
break;
} else if (dstValue > marker) {
markerInsertPosition = i - 1;
break;
}
}
}
}
while (i < dst.length) {
const item = dst[i];
if (typeof item === "number") {
break;
} else if (item === key1) {
if (key2 === null) {
if (value2 !== null) {
dst[i + 1] = value2;
}
return;
} else if (key2 === dst[i + 1]) {
dst[i + 2] = value2;
return;
}
}
i++;
if (key2 !== null)
i++;
if (value2 !== null)
i++;
}
if (markerInsertPosition !== -1) {
dst.splice(markerInsertPosition, 0, marker);
i = markerInsertPosition + 1;
}
dst.splice(i++, 0, key1);
if (key2 !== null) {
dst.splice(i++, 0, key2);
}
if (value2 !== null) {
dst.splice(i++, 0, value2);
}
}
var NG_TEMPLATE_SELECTOR = "ng-template";
function isCssClassMatching(tNode, attrs, cssClassToMatch, isProjectionMode) {
ngDevMode && assertEqual(cssClassToMatch, cssClassToMatch.toLowerCase(), "Class name expected to be lowercase.");
let i = 0;
if (isProjectionMode) {
for (; i < attrs.length && typeof attrs[i] === "string"; i += 2) {
if (attrs[i] === "class" && classIndexOf(attrs[i + 1].toLowerCase(), cssClassToMatch, 0) !== -1) {
return true;
}
}
} else if (isInlineTemplate(tNode)) {
return false;
}
i = attrs.indexOf(1, i);
if (i > -1) {
let item;
while (++i < attrs.length && typeof (item = attrs[i]) === "string") {
if (item.toLowerCase() === cssClassToMatch) {
return true;
}
}
}
return false;
}
function isInlineTemplate(tNode) {
return tNode.type === 4 && tNode.value !== NG_TEMPLATE_SELECTOR;
}
function hasTagAndTypeMatch(tNode, currentSelector, isProjectionMode) {
const tagNameToCompare = tNode.type === 4 && !isProjectionMode ? NG_TEMPLATE_SELECTOR : tNode.value;
return currentSelector === tagNameToCompare;
}
function isNodeMatchingSelector(tNode, selector, isProjectionMode) {
ngDevMode && assertDefined(selector[0], "Selector should have a tag name");
let mode = 4;
const nodeAttrs = tNode.attrs;
const nameOnlyMarkerIdx = nodeAttrs !== null ? getNameOnlyMarkerIndex(nodeAttrs) : 0;
let skipToNextSelector = false;
for (let i = 0; i < selector.length; i++) {
const current = selector[i];
if (typeof current === "number") {
if (!skipToNextSelector && !isPositive(mode) && !isPositive(current)) {
return false;
}
if (skipToNextSelector && isPositive(current))
continue;
skipToNextSelector = false;
mode = current | mode & 1;
continue;
}
if (skipToNextSelector)
continue;
if (mode & 4) {
mode = 2 | mode & 1;
if (current !== "" && !hasTagAndTypeMatch(tNode, current, isProjectionMode) || current === "" && selector.length === 1) {
if (isPositive(mode))
return false;
skipToNextSelector = true;
}
} else if (mode & 8) {
if (nodeAttrs === null || !isCssClassMatching(tNode, nodeAttrs, current, isProjectionMode)) {
if (isPositive(mode))
return false;
skipToNextSelector = true;
}
} else {
const selectorAttrValue = selector[++i];
const attrIndexInNode = findAttrIndexInNode(current, nodeAttrs, isInlineTemplate(tNode), isProjectionMode);
if (attrIndexInNode === -1) {
if (isPositive(mode))
return false;
skipToNextSelector = true;
continue;
}
if (selectorAttrValue !== "") {
let nodeAttrValue;
if (attrIndexInNode > nameOnlyMarkerIdx) {
nodeAttrValue = "";
} else {
ngDevMode && assertNotEqual(nodeAttrs[attrIndexInNode], 0, "We do not match directives on namespaced attributes");
nodeAttrValue = nodeAttrs[attrIndexInNode + 1].toLowerCase();
}
if (mode & 2 && selectorAttrValue !== nodeAttrValue) {
if (isPositive(mode))
return false;
skipToNextSelector = true;
}
}
}
}
return isPositive(mode) || skipToNextSelector;
}
function isPositive(mode) {
return (mode & 1) === 0;
}
function findAttrIndexInNode(name2, attrs, isInlineTemplate2, isProjectionMode) {
if (attrs === null)
return -1;
let i = 0;
if (isProjectionMode || !isInlineTemplate2) {
let bindingsMode = false;
while (i < attrs.length) {
const maybeAttrName = attrs[i];
if (maybeAttrName === name2) {
return i;
} else if (maybeAttrName === 3 || maybeAttrName === 6) {
bindingsMode = true;
} else if (maybeAttrName === 1 || maybeAttrName === 2) {
let value2 = attrs[++i];
while (typeof value2 === "string") {
value2 = attrs[++i];
}
continue;
} else if (maybeAttrName === 4) {
break;
} else if (maybeAttrName === 0) {
i += 4;
continue;
}
i += bindingsMode ? 1 : 2;
}
return -1;
} else {
return matchTemplateAttribute(attrs, name2);
}
}
function isNodeMatchingSelectorList(tNode, selector, isProjectionMode = false) {
for (let i = 0; i < selector.length; i++) {
if (isNodeMatchingSelector(tNode, selector[i], isProjectionMode)) {
return true;
}
}
return false;
}
function getProjectAsAttrValue(tNode) {
const nodeAttrs = tNode.attrs;
if (nodeAttrs != null) {
const ngProjectAsAttrIdx = nodeAttrs.indexOf(
5
/* AttributeMarker.ProjectAs */
);
if ((ngProjectAsAttrIdx & 1) === 0) {
return nodeAttrs[ngProjectAsAttrIdx + 1];
}
}
return null;
}
function getNameOnlyMarkerIndex(nodeAttrs) {
for (let i = 0; i < nodeAttrs.length; i++) {
const nodeAttr = nodeAttrs[i];
if (isNameOnlyAttributeMarker(nodeAttr)) {
return i;
}
}
return nodeAttrs.length;
}
function matchTemplateAttribute(attrs, name2) {
let i = attrs.indexOf(
4
/* AttributeMarker.Template */
);
if (i > -1) {
i++;
while (i < attrs.length) {
const attr = attrs[i];
if (typeof attr === "number")
return -1;
if (attr === name2)
return i;
i++;
}
}
return -1;
}
function isSelectorInSelectorList(selector, list) {
selectorListLoop:
for (let i = 0; i < list.length; i++) {
const currentSelectorInList = list[i];
if (selector.length !== currentSelectorInList.length) {
continue;
}
for (let j = 0; j < selector.length; j++) {
if (selector[j] !== currentSelectorInList[j]) {
continue selectorListLoop;
}
}
return true;
}
return false;
}
function maybeWrapInNotSelector(isNegativeMode, chunk) {
return isNegativeMode ? ":not(" + chunk.trim() + ")" : chunk;
}
function stringifyCSSSelector(selector) {
let result = selector[0];
let i = 1;
let mode = 2;
let currentChunk = "";
let isNegativeMode = false;
while (i < selector.length) {
let valueOrMarker = selector[i];
if (typeof valueOrMarker === "string") {
if (mode & 2) {
const attrValue = selector[++i];
currentChunk += "[" + valueOrMarker + (attrValue.length > 0 ? '="' + attrValue + '"' : "") + "]";
} else if (mode & 8) {
currentChunk += "." + valueOrMarker;
} else if (mode & 4) {
currentChunk += " " + valueOrMarker;
}
} else {
if (currentChunk !== "" && !isPositive(valueOrMarker)) {
result += maybeWrapInNotSelector(isNegativeMode, currentChunk);
currentChunk = "";
}
mode = valueOrMarker;
isNegativeMode = isNegativeMode || !isPositive(mode);
}
i++;
}
if (currentChunk !== "") {
result += maybeWrapInNotSelector(isNegativeMode, currentChunk);
}
return result;
}
function stringifyCSSSelectorList(selectorList) {
return selectorList.map(stringifyCSSSelector).join(",");
}
function extractAttrsAndClassesFromSelector(selector) {
const attrs = [];
const classes = [];
let i = 1;
let mode = 2;
while (i < selector.length) {
let valueOrMarker = selector[i];
if (typeof valueOrMarker === "string") {
if (mode === 2) {
if (valueOrMarker !== "") {
attrs.push(valueOrMarker, selector[++i]);
}
} else if (mode === 8) {
classes.push(valueOrMarker);
}
} else {
if (!isPositive(mode))
break;
mode = valueOrMarker;
}
i++;
}
return { attrs, classes };
}
function \u0275\u0275defineComponent(componentDefinition) {
return noSideEffects(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && initNgDevMode();
const baseDef = getNgDirectiveDef(componentDefinition);
const def = __spreadProps(__spreadValues({}, baseDef), {
decls: componentDefinition.decls,
vars: componentDefinition.vars,
template: componentDefinition.template,
consts: componentDefinition.consts || null,
ngContentSelectors: componentDefinition.ngContentSelectors,
onPush: componentDefinition.changeDetection === ChangeDetectionStrategy.OnPush,
directiveDefs: null,
// assigned in noSideEffects
pipeDefs: null,
// assigned in noSideEffects
dependencies: baseDef.standalone && componentDefinition.dependencies || null,
getStandaloneInjector: null,
signals: componentDefinition.signals ?? false,
data: componentDefinition.data || {},
encapsulation: componentDefinition.encapsulation || ViewEncapsulation$1.Emulated,
styles: componentDefinition.styles || EMPTY_ARRAY,
_: null,
schemas: componentDefinition.schemas || null,
tView: null,
id: ""
});
initFeatures(def);
const dependencies = componentDefinition.dependencies;
def.directiveDefs = extractDefListOrFactory(
dependencies,
/* pipeDef */
false
);
def.pipeDefs = extractDefListOrFactory(
dependencies,
/* pipeDef */
true
);
def.id = getComponentId(def);
return def;
});
}
function extractDirectiveDef(type) {
return getComponentDef(type) || getDirectiveDef(type);
}
function nonNull(value2) {
return value2 !== null;
}
function \u0275\u0275defineNgModule(def) {
return noSideEffects(() => {
const res = {
type: def.type,
bootstrap: def.bootstrap || EMPTY_ARRAY,
declarations: def.declarations || EMPTY_ARRAY,
imports: def.imports || EMPTY_ARRAY,
exports: def.exports || EMPTY_ARRAY,
transitiveCompileScopes: null,
schemas: def.schemas || null,
id: def.id || null
};
return res;
});
}
function parseAndConvertBindingsForDefinition(obj, declaredInputs) {
if (obj == null)
return EMPTY_OBJ;
const newLookup = {};
for (const minifiedKey in obj) {
if (obj.hasOwnProperty(minifiedKey)) {
const value2 = obj[minifiedKey];
let publicName;
let declaredName;
let inputFlags = InputFlags.None;
if (Array.isArray(value2)) {
inputFlags = value2[0];
publicName = value2[1];
declaredName = value2[2] ?? publicName;
} else {
publicName = value2;
declaredName = value2;
}
if (declaredInputs) {
newLookup[publicName] = inputFlags !== InputFlags.None ? [minifiedKey, inputFlags] : minifiedKey;
declaredInputs[publicName] = declaredName;
} else {
newLookup[publicName] = minifiedKey;
}
}
}
return newLookup;
}
function \u0275\u0275defineDirective(directiveDefinition) {
return noSideEffects(() => {
const def = getNgDirectiveDef(directiveDefinition);
initFeatures(def);
return def;
});
}
function \u0275\u0275definePipe(pipeDef) {
return {
type: pipeDef.type,
name: pipeDef.name,
factory: null,
pure: pipeDef.pure !== false,
standalone: pipeDef.standalone === true,
onDestroy: pipeDef.type.prototype.ngOnDestroy || null
};
}
function getComponentDef(type) {
return type[NG_COMP_DEF] || null;
}
function getDirectiveDef(type) {
return type[NG_DIR_DEF] || null;
}
function getPipeDef$1(type) {
return type[NG_PIPE_DEF] || null;
}
function isStandalone(type) {
const def = getComponentDef(type) || getDirectiveDef(type) || getPipeDef$1(type);
return def !== null ? def.standalone : false;
}
function getNgModuleDef(type, throwNotFound) {
const ngModuleDef = type[NG_MOD_DEF] || null;
if (!ngModuleDef && throwNotFound === true) {
throw new Error(`Type ${stringify(type)} does not have '\u0275mod' property.`);
}
return ngModuleDef;
}
function getNgDirectiveDef(directiveDefinition) {
const declaredInputs = {};
return {
type: directiveDefinition.type,
providersResolver: null,
factory: null,
hostBindings: directiveDefinition.hostBindings || null,
hostVars: directiveDefinition.hostVars || 0,
hostAttrs: directiveDefinition.hostAttrs || null,
contentQueries: directiveDefinition.contentQueries || null,
declaredInputs,
inputTransforms: null,
inputConfig: directiveDefinition.inputs || EMPTY_OBJ,
exportAs: directiveDefinition.exportAs || null,
standalone: directiveDefinition.standalone === true,
signals: directiveDefinition.signals === true,
selectors: directiveDefinition.selectors || EMPTY_ARRAY,
viewQuery: directiveDefinition.viewQuery || null,
features: directiveDefinition.features || null,
setInput: null,
findHostDirectiveDefs: null,
hostDirectives: null,
inputs: parseAndConvertBindingsForDefinition(directiveDefinition.inputs, declaredInputs),
outputs: parseAndConvertBindingsForDefinition(directiveDefinition.outputs),
debugInfo: null
};
}
function initFeatures(definition) {
definition.features?.forEach((fn) => fn(definition));
}
function extractDefListOrFactory(dependencies, pipeDef) {
if (!dependencies) {
return null;
}
const defExtractor = pipeDef ? getPipeDef$1 : extractDirectiveDef;
return () => (typeof dependencies === "function" ? dependencies() : dependencies).map((dep) => defExtractor(dep)).filter(nonNull);
}
var GENERATED_COMP_IDS = /* @__PURE__ */ new Map();
function getComponentId(componentDef) {
let hash = 0;
const hashSelectors = [
componentDef.selectors,
componentDef.ngContentSelectors,
componentDef.hostVars,
componentDef.hostAttrs,
componentDef.consts,
componentDef.vars,
componentDef.decls,
componentDef.encapsulation,
componentDef.standalone,
componentDef.signals,
componentDef.exportAs,
JSON.stringify(componentDef.inputs),
JSON.stringify(componentDef.outputs),
// We cannot use 'componentDef.type.name' as the name of the symbol will change and will not
// match in the server and browser bundles.
Object.getOwnPropertyNames(componentDef.type.prototype),
!!componentDef.contentQueries,
!!componentDef.viewQuery
].join("|");
for (const char of hashSelectors) {
hash = Math.imul(31, hash) + char.charCodeAt(0) << 0;
}
hash += 2147483647 + 1;
const compId = "c" + hash;
if (typeof ngDevMode === "undefined" || ngDevMode) {
if (GENERATED_COMP_IDS.has(compId)) {
const previousCompDefType = GENERATED_COMP_IDS.get(compId);
if (previousCompDefType !== componentDef.type) {
console.warn(formatRuntimeError(-912, `Component ID generation collision detected. Components '${previousCompDefType.name}' and '${componentDef.type.name}' with selector '${stringifyCSSSelectorList(componentDef.selectors)}' generated the same component ID. To fix this, you can change the selector of one of those components or add an extra host attribute to force a different ID.`));
}
} else {
GENERATED_COMP_IDS.set(compId, componentDef.type);
}
}
return compId;
}
function makeEnvironmentProviders(providers) {
return {
\u0275providers: providers
};
}
function importProvidersFrom(...sources) {
return {
\u0275providers: internalImportProvidersFrom(true, sources),
\u0275fromNgModule: true
};
}
function internalImportProvidersFrom(checkForStandaloneCmp, ...sources) {
const providersOut = [];
const dedup = /* @__PURE__ */ new Set();
let injectorTypesWithProviders;
const collectProviders = (provider) => {
providersOut.push(provider);
};
deepForEach(sources, (source) => {
if ((typeof ngDevMode === "undefined" || ngDevMode) && checkForStandaloneCmp) {
const cmpDef = getComponentDef(source);
if (cmpDef?.standalone) {
throw new RuntimeError(800, `Importing providers supports NgModule or ModuleWithProviders but got a standalone component "${stringifyForError(source)}"`);
}
}
const internalSource = source;
if (walkProviderTree(internalSource, collectProviders, [], dedup)) {
injectorTypesWithProviders ||= [];
injectorTypesWithProviders.push(internalSource);
}
});
if (injectorTypesWithProviders !== void 0) {
processInjectorTypesWithProviders(injectorTypesWithProviders, collectProviders);
}
return providersOut;
}
function processInjectorTypesWithProviders(typesWithProviders, visitor) {
for (let i = 0; i < typesWithProviders.length; i++) {
const { ngModule, providers } = typesWithProviders[i];
deepForEachProvider(providers, (provider) => {
ngDevMode && validateProvider(provider, providers || EMPTY_ARRAY, ngModule);
visitor(provider, ngModule);
});
}
}
function walkProviderTree(container, visitor, parents, dedup) {
container = resolveForwardRef(container);
if (!container)
return false;
let defType = null;
let injDef = getInjectorDef(container);
const cmpDef = !injDef && getComponentDef(container);
if (!injDef && !cmpDef) {
const ngModule = container.ngModule;
injDef = getInjectorDef(ngModule);
if (injDef) {
defType = ngModule;
} else {
return false;
}
} else if (cmpDef && !cmpDef.standalone) {
return false;
} else {
defType = container;
}
if (ngDevMode && parents.indexOf(defType) !== -1) {
const defName = stringify(defType);
const path = parents.map(stringify);
throwCyclicDependencyError(defName, path);
}
const isDuplicate = dedup.has(defType);
if (cmpDef) {
if (isDuplicate) {
return false;
}
dedup.add(defType);
if (cmpDef.dependencies) {
const deps = typeof cmpDef.dependencies === "function" ? cmpDef.dependencies() : cmpDef.dependencies;
for (const dep of deps) {
walkProviderTree(dep, visitor, parents, dedup);
}
}
} else if (injDef) {
if (injDef.imports != null && !isDuplicate) {
ngDevMode && parents.push(defType);
dedup.add(defType);
let importTypesWithProviders;
try {
deepForEach(injDef.imports, (imported) => {
if (walkProviderTree(imported, visitor, parents, dedup)) {
importTypesWithProviders ||= [];
importTypesWithProviders.push(imported);
}
});
} finally {
ngDevMode && parents.pop();
}
if (importTypesWithProviders !== void 0) {
processInjectorTypesWithProviders(importTypesWithProviders, visitor);
}
}
if (!isDuplicate) {
const factory = getFactoryDef(defType) || (() => new defType());
visitor({ provide: defType, useFactory: factory, deps: EMPTY_ARRAY }, defType);
visitor({ provide: INJECTOR_DEF_TYPES, useValue: defType, multi: true }, defType);
visitor({ provide: ENVIRONMENT_INITIALIZER, useValue: () => \u0275\u0275inject(defType), multi: true }, defType);
}
const defProviders = injDef.providers;
if (defProviders != null && !isDuplicate) {
const injectorType = container;
deepForEachProvider(defProviders, (provider) => {
ngDevMode && validateProvider(provider, defProviders, injectorType);
visitor(provider, injectorType);
});
}
} else {
return false;
}
return defType !== container && container.providers !== void 0;
}
function validateProvider(provider, providers, containerType) {
if (isTypeProvider(provider) || isValueProvider(provider) || isFactoryProvider(provider) || isExistingProvider(provider)) {
return;
}
const classRef = resolveForwardRef(provider && (provider.useClass || provider.provide));
if (!classRef) {
throwInvalidProviderError(containerType, providers, provider);
}
}
function deepForEachProvider(providers, fn) {
for (let provider of providers) {
if (isEnvironmentProviders(provider)) {
provider = provider.\u0275providers;
}
if (Array.isArray(provider)) {
deepForEachProvider(provider, fn);
} else {
fn(provider);
}
}
}
var USE_VALUE$1 = getClosureSafeProperty({ provide: String, useValue: getClosureSafeProperty });
function isValueProvider(value2) {
return value2 !== null && typeof value2 == "object" && USE_VALUE$1 in value2;
}
function isExistingProvider(value2) {
return !!(value2 && value2.useExisting);
}
function isFactoryProvider(value2) {
return !!(value2 && value2.useFactory);
}
function isTypeProvider(value2) {
return typeof value2 === "function";
}
function isClassProvider(value2) {
return !!value2.useClass;
}
var INJECTOR_SCOPE = new InjectionToken(ngDevMode ? "Set Injector scope." : "");
var NOT_YET = {};
var CIRCULAR = {};
var NULL_INJECTOR = void 0;
function getNullInjector() {
if (NULL_INJECTOR === void 0) {
NULL_INJECTOR = new NullInjector();
}
return NULL_INJECTOR;
}
var EnvironmentInjector = class {
};
var R3Injector = class extends EnvironmentInjector {
/**
* Flag indicating that this injector was previously destroyed.
*/
get destroyed() {
return this._destroyed;
}
constructor(providers, parent2, source, scopes) {
super();
this.parent = parent2;
this.source = source;
this.scopes = scopes;
this.records = /* @__PURE__ */ new Map();
this._ngOnDestroyHooks = /* @__PURE__ */ new Set();
this._onDestroyHooks = [];
this._destroyed = false;
forEachSingleProvider(providers, (provider) => this.processProvider(provider));
this.records.set(INJECTOR$1, makeRecord(void 0, this));
if (scopes.has("environment")) {
this.records.set(EnvironmentInjector, makeRecord(void 0, this));
}
const record = this.records.get(INJECTOR_SCOPE);
if (record != null && typeof record.value === "string") {
this.scopes.add(record.value);
}
this.injectorDefTypes = new Set(this.get(INJECTOR_DEF_TYPES, EMPTY_ARRAY, InjectFlags.Self));
}
/**
* Destroy the injector and release references to every instance or provider associated with it.
*
* Also calls the `OnDestroy` lifecycle hooks of every instance that was created for which a
* hook was found.
*/
destroy() {
this.assertNotDestroyed();
this._destroyed = true;
const prevConsumer = setActiveConsumer(null);
try {
for (const service of this._ngOnDestroyHooks) {
service.ngOnDestroy();
}
const onDestroyHooks = this._onDestroyHooks;
this._onDestroyHooks = [];
for (const hook of onDestroyHooks) {
hook();
}
} finally {
this.records.clear();
this._ngOnDestroyHooks.clear();
this.injectorDefTypes.clear();
setActiveConsumer(prevConsumer);
}
}
onDestroy(callback) {
this.assertNotDestroyed();
this._onDestroyHooks.push(callback);
return () => this.removeOnDestroy(callback);
}
runInContext(fn) {
this.assertNotDestroyed();
const previousInjector = setCurrentInjector(this);
const previousInjectImplementation = setInjectImplementation(void 0);
let prevInjectContext;
if (ngDevMode) {
prevInjectContext = setInjectorProfilerContext({ injector: this, token: null });
}
try {
return fn();
} finally {
setCurrentInjector(previousInjector);
setInjectImplementation(previousInjectImplementation);
ngDevMode && setInjectorProfilerContext(prevInjectContext);
}
}
get(token, notFoundValue = THROW_IF_NOT_FOUND, flags = InjectFlags.Default) {
this.assertNotDestroyed();
if (token.hasOwnProperty(NG_ENV_ID)) {
return token[NG_ENV_ID](this);
}
flags = convertToBitFlags(flags);
let prevInjectContext;
if (ngDevMode) {
prevInjectContext = setInjectorProfilerContext({ injector: this, token });
}
const previousInjector = setCurrentInjector(this);
const previousInjectImplementation = setInjectImplementation(void 0);
try {
if (!(flags & InjectFlags.SkipSelf)) {
let record = this.records.get(token);
if (record === void 0) {
const def = couldBeInjectableType(token) && getInjectableDef(token);
if (def && this.injectableDefInScope(def)) {
if (ngDevMode) {
runInInjectorProfilerContext(this, token, () => {
emitProviderConfiguredEvent(token);
});
}
record = makeRecord(injectableDefOrInjectorDefFactory(token), NOT_YET);
} else {
record = null;
}
this.records.set(token, record);
}
if (record != null) {
return this.hydrate(token, record);
}
}
const nextInjector = !(flags & InjectFlags.Self) ? this.parent : getNullInjector();
notFoundValue = flags & InjectFlags.Optional && notFoundValue === THROW_IF_NOT_FOUND ? null : notFoundValue;
return nextInjector.get(token, notFoundValue);
} catch (e) {
if (e.name === "NullInjectorError") {
const path = e[NG_TEMP_TOKEN_PATH] = e[NG_TEMP_TOKEN_PATH] || [];
path.unshift(stringify(token));
if (previousInjector) {
throw e;
} else {
return catchInjectorError(e, token, "R3InjectorError", this.source);
}
} else {
throw e;
}
} finally {
setInjectImplementation(previousInjectImplementation);
setCurrentInjector(previousInjector);
ngDevMode && setInjectorProfilerContext(prevInjectContext);
}
}
/** @internal */
resolveInjectorInitializers() {
const prevConsumer = setActiveConsumer(null);
const previousInjector = setCurrentInjector(this);
const previousInjectImplementation = setInjectImplementation(void 0);
let prevInjectContext;
if (ngDevMode) {
prevInjectContext = setInjectorProfilerContext({ injector: this, token: null });
}
try {
const initializers = this.get(ENVIRONMENT_INITIALIZER, EMPTY_ARRAY, InjectFlags.Self);
if (ngDevMode && !Array.isArray(initializers)) {
throw new RuntimeError(-209, `Unexpected type of the \`ENVIRONMENT_INITIALIZER\` token value (expected an array, but got ${typeof initializers}). Please check that the \`ENVIRONMENT_INITIALIZER\` token is configured as a \`multi: true\` provider.`);
}
for (const initializer of initializers) {
initializer();
}
} finally {
setCurrentInjector(previousInjector);
setInjectImplementation(previousInjectImplementation);
ngDevMode && setInjectorProfilerContext(prevInjectContext);
setActiveConsumer(prevConsumer);
}
}
toString() {
const tokens = [];
const records = this.records;
for (const token of records.keys()) {
tokens.push(stringify(token));
}
return `R3Injector[${tokens.join(", ")}]`;
}
assertNotDestroyed() {
if (this._destroyed) {
throw new RuntimeError(205, ngDevMode && "Injector has already been destroyed.");
}
}
/**
* Process a `SingleProvider` and add it.
*/
processProvider(provider) {
provider = resolveForwardRef(provider);
let token = isTypeProvider(provider) ? provider : resolveForwardRef(provider && provider.provide);
const record = providerToRecord(provider);
if (ngDevMode) {
runInInjectorProfilerContext(this, token, () => {
if (isValueProvider(provider)) {
emitInstanceCreatedByInjectorEvent(provider.useValue);
}
emitProviderConfiguredEvent(provider);
});
}
if (!isTypeProvider(provider) && provider.multi === true) {
let multiRecord = this.records.get(token);
if (multiRecord) {
if (ngDevMode && multiRecord.multi === void 0) {
throwMixedMultiProviderError();
}
} else {
multiRecord = makeRecord(void 0, NOT_YET, true);
multiRecord.factory = () => injectArgs(multiRecord.multi);
this.records.set(token, multiRecord);
}
token = provider;
multiRecord.multi.push(provider);
} else {
if (ngDevMode) {
const existing = this.records.get(token);
if (existing && existing.multi !== void 0) {
throwMixedMultiProviderError();
}
}
}
this.records.set(token, record);
}
hydrate(token, record) {
const prevConsumer = setActiveConsumer(null);
try {
if (ngDevMode && record.value === CIRCULAR) {
throwCyclicDependencyError(stringify(token));
} else if (record.value === NOT_YET) {
record.value = CIRCULAR;
if (ngDevMode) {
runInInjectorProfilerContext(this, token, () => {
record.value = record.factory();
emitInstanceCreatedByInjectorEvent(record.value);
});
} else {
record.value = record.factory();
}
}
if (typeof record.value === "object" && record.value && hasOnDestroy(record.value)) {
this._ngOnDestroyHooks.add(record.value);
}
return record.value;
} finally {
setActiveConsumer(prevConsumer);
}
}
injectableDefInScope(def) {
if (!def.providedIn) {
return false;
}
const providedIn = resolveForwardRef(def.providedIn);
if (typeof providedIn === "string") {
return providedIn === "any" || this.scopes.has(providedIn);
} else {
return this.injectorDefTypes.has(providedIn);
}
}
removeOnDestroy(callback) {
const destroyCBIdx = this._onDestroyHooks.indexOf(callback);
if (destroyCBIdx !== -1) {
this._onDestroyHooks.splice(destroyCBIdx, 1);
}
}
};
function injectableDefOrInjectorDefFactory(token) {
const injectableDef = getInjectableDef(token);
const factory = injectableDef !== null ? injectableDef.factory : getFactoryDef(token);
if (factory !== null) {
return factory;
}
if (token instanceof InjectionToken) {
throw new RuntimeError(204, ngDevMode && `Token ${stringify(token)} is missing a \u0275prov definition.`);
}
if (token instanceof Function) {
return getUndecoratedInjectableFactory(token);
}
throw new RuntimeError(204, ngDevMode && "unreachable");
}
function getUndecoratedInjectableFactory(token) {
const paramLength = token.length;
if (paramLength > 0) {
throw new RuntimeError(204, ngDevMode && `Can't resolve all parameters for ${stringify(token)}: (${newArray(paramLength, "?").join(", ")}).`);
}
const inheritedInjectableDef = getInheritedInjectableDef(token);
if (inheritedInjectableDef !== null) {
return () => inheritedInjectableDef.factory(token);
} else {
return () => new token();
}
}
function providerToRecord(provider) {
if (isValueProvider(provider)) {
return makeRecord(void 0, provider.useValue);
} else {
const factory = providerToFactory(provider);
return makeRecord(factory, NOT_YET);
}
}
function providerToFactory(provider, ngModuleType, providers) {
let factory = void 0;
if (ngDevMode && isEnvironmentProviders(provider)) {
throwInvalidProviderError(void 0, providers, provider);
}
if (isTypeProvider(provider)) {
const unwrappedProvider = resolveForwardRef(provider);
return getFactoryDef(unwrappedProvider) || injectableDefOrInjectorDefFactory(unwrappedProvider);
} else {
if (isValueProvider(provider)) {
factory = () => resolveForwardRef(provider.useValue);
} else if (isFactoryProvider(provider)) {
factory = () => provider.useFactory(...injectArgs(provider.deps || []));
} else if (isExistingProvider(provider)) {
factory = () => \u0275\u0275inject(resolveForwardRef(provider.useExisting));
} else {
const classRef = resolveForwardRef(provider && (provider.useClass || provider.provide));
if (ngDevMode && !classRef) {
throwInvalidProviderError(ngModuleType, providers, provider);
}
if (hasDeps(provider)) {
factory = () => new classRef(...injectArgs(provider.deps));
} else {
return getFactoryDef(classRef) || injectableDefOrInjectorDefFactory(classRef);
}
}
}
return factory;
}
function makeRecord(factory, value2, multi = false) {
return {
factory,
value: value2,
multi: multi ? [] : void 0
};
}
function hasDeps(value2) {
return !!value2.deps;
}
function hasOnDestroy(value2) {
return value2 !== null && typeof value2 === "object" && typeof value2.ngOnDestroy === "function";
}
function couldBeInjectableType(value2) {
return typeof value2 === "function" || typeof value2 === "object" && value2 instanceof InjectionToken;
}
function forEachSingleProvider(providers, fn) {
for (const provider of providers) {
if (Array.isArray(provider)) {
forEachSingleProvider(provider, fn);
} else if (provider && isEnvironmentProviders(provider)) {
forEachSingleProvider(provider.\u0275providers, fn);
} else {
fn(provider);
}
}
}
function runInInjectionContext(injector, fn) {
if (injector instanceof R3Injector) {
injector.assertNotDestroyed();
}
let prevInjectorProfilerContext;
if (ngDevMode) {
prevInjectorProfilerContext = setInjectorProfilerContext({ injector, token: null });
}
const prevInjector = setCurrentInjector(injector);
const previousInjectImplementation = setInjectImplementation(void 0);
try {
return fn();
} finally {
setCurrentInjector(prevInjector);
ngDevMode && setInjectorProfilerContext(prevInjectorProfilerContext);
setInjectImplementation(previousInjectImplementation);
}
}
function isInInjectionContext() {
return getInjectImplementation() !== void 0 || getCurrentInjector() != null;
}
function assertInInjectionContext(debugFn) {
if (!isInInjectionContext()) {
throw new RuntimeError(-203, ngDevMode && debugFn.name + "() can only be used within an injection context such as a constructor, a factory function, a field initializer, or a function used with `runInInjectionContext`");
}
}
var FactoryTarget;
(function(FactoryTarget2) {
FactoryTarget2[FactoryTarget2["Directive"] = 0] = "Directive";
FactoryTarget2[FactoryTarget2["Component"] = 1] = "Component";
FactoryTarget2[FactoryTarget2["Injectable"] = 2] = "Injectable";
FactoryTarget2[FactoryTarget2["Pipe"] = 3] = "Pipe";
FactoryTarget2[FactoryTarget2["NgModule"] = 4] = "NgModule";
})(FactoryTarget || (FactoryTarget = {}));
var R3TemplateDependencyKind;
(function(R3TemplateDependencyKind2) {
R3TemplateDependencyKind2[R3TemplateDependencyKind2["Directive"] = 0] = "Directive";
R3TemplateDependencyKind2[R3TemplateDependencyKind2["Pipe"] = 1] = "Pipe";
R3TemplateDependencyKind2[R3TemplateDependencyKind2["NgModule"] = 2] = "NgModule";
})(R3TemplateDependencyKind || (R3TemplateDependencyKind = {}));
var ViewEncapsulation;
(function(ViewEncapsulation2) {
ViewEncapsulation2[ViewEncapsulation2["Emulated"] = 0] = "Emulated";
ViewEncapsulation2[ViewEncapsulation2["None"] = 2] = "None";
ViewEncapsulation2[ViewEncapsulation2["ShadowDom"] = 3] = "ShadowDom";
})(ViewEncapsulation || (ViewEncapsulation = {}));
function getCompilerFacade(request) {
const globalNg = _global["ng"];
if (globalNg && globalNg.\u0275compilerFacade) {
return globalNg.\u0275compilerFacade;
}
if (typeof ngDevMode === "undefined" || ngDevMode) {
console.error(`JIT compilation failed for ${request.kind}`, request.type);
let message = `The ${request.kind} '${request.type.name}' needs to be compiled using the JIT compiler, but '@angular/compiler' is not available.
`;
if (request.usage === 1) {
message += `The ${request.kind} is part of a library that has been partially compiled.
`;
message += `However, the Angular Linker has not processed the library such that JIT compilation is used as fallback.
`;
message += "\n";
message += `Ideally, the library is processed using the Angular Linker to become fully AOT compiled.
`;
} else {
message += `JIT compilation is discouraged for production use-cases! Consider using AOT mode instead.
`;
}
message += `Alternatively, the JIT compiler should be loaded by bootstrapping using '@angular/platform-browser-dynamic' or '@angular/platform-server',
`;
message += `or manually provide the compiler with 'import "@angular/compiler";' before bootstrapping.`;
throw new Error(message);
} else {
throw new Error("JIT compiler unavailable");
}
}
var angularCoreDiEnv = {
"\u0275\u0275defineInjectable": \u0275\u0275defineInjectable,
"\u0275\u0275defineInjector": \u0275\u0275defineInjector,
"\u0275\u0275inject": \u0275\u0275inject,
"\u0275\u0275invalidFactoryDep": \u0275\u0275invalidFactoryDep,
"resolveForwardRef": resolveForwardRef
};
var Type = Function;
function isType(v) {
return typeof v === "function";
}
var ES5_DELEGATE_CTOR = /^function\s+\S+\(\)\s*{[\s\S]+\.apply\(this,\s*(arguments|(?:[^()]+\(\[\],)?[^()]+\(arguments\).*)\)/;
var ES2015_INHERITED_CLASS = /^class\s+[A-Za-z\d$_]*\s*extends\s+[^{]+{/;
var ES2015_INHERITED_CLASS_WITH_CTOR = /^class\s+[A-Za-z\d$_]*\s*extends\s+[^{]+{[\s\S]*constructor\s*\(/;
var ES2015_INHERITED_CLASS_WITH_DELEGATE_CTOR = /^class\s+[A-Za-z\d$_]*\s*extends\s+[^{]+{[\s\S]*constructor\s*\(\)\s*{[^}]*super\(\.\.\.arguments\)/;
function isDelegateCtor(typeStr) {
return ES5_DELEGATE_CTOR.test(typeStr) || ES2015_INHERITED_CLASS_WITH_DELEGATE_CTOR.test(typeStr) || ES2015_INHERITED_CLASS.test(typeStr) && !ES2015_INHERITED_CLASS_WITH_CTOR.test(typeStr);
}
var ReflectionCapabilities = class {
constructor(reflect) {
this._reflect = reflect || _global["Reflect"];
}
factory(t) {
return (...args) => new t(...args);
}
/** @internal */
_zipTypesAndAnnotations(paramTypes, paramAnnotations) {
let result;
if (typeof paramTypes === "undefined") {
result = newArray(paramAnnotations.length);
} else {
result = newArray(paramTypes.length);
}
for (let i = 0; i < result.length; i++) {
if (typeof paramTypes === "undefined") {
result[i] = [];
} else if (paramTypes[i] && paramTypes[i] != Object) {
result[i] = [paramTypes[i]];
} else {
result[i] = [];
}
if (paramAnnotations && paramAnnotations[i] != null) {
result[i] = result[i].concat(paramAnnotations[i]);
}
}
return result;
}
_ownParameters(type, parentCtor) {
const typeStr = type.toString();
if (isDelegateCtor(typeStr)) {
return null;
}
if (type.parameters && type.parameters !== parentCtor.parameters) {
return type.parameters;
}
const tsickleCtorParams = type.ctorParameters;
if (tsickleCtorParams && tsickleCtorParams !== parentCtor.ctorParameters) {
const ctorParameters = typeof tsickleCtorParams === "function" ? tsickleCtorParams() : tsickleCtorParams;
const paramTypes2 = ctorParameters.map((ctorParam) => ctorParam && ctorParam.type);
const paramAnnotations2 = ctorParameters.map((ctorParam) => ctorParam && convertTsickleDecoratorIntoMetadata(ctorParam.decorators));
return this._zipTypesAndAnnotations(paramTypes2, paramAnnotations2);
}
const paramAnnotations = type.hasOwnProperty(PARAMETERS) && type[PARAMETERS];
const paramTypes = this._reflect && this._reflect.getOwnMetadata && this._reflect.getOwnMetadata("design:paramtypes", type);
if (paramTypes || paramAnnotations) {
return this._zipTypesAndAnnotations(paramTypes, paramAnnotations);
}
return newArray(type.length);
}
parameters(type) {
if (!isType(type)) {
return [];
}
const parentCtor = getParentCtor(type);
let parameters = this._ownParameters(type, parentCtor);
if (!parameters && parentCtor !== Object) {
parameters = this.parameters(parentCtor);
}
return parameters || [];
}
_ownAnnotations(typeOrFunc, parentCtor) {
if (typeOrFunc.annotations && typeOrFunc.annotations !== parentCtor.annotations) {
let annotations = typeOrFunc.annotations;
if (typeof annotations === "function" && annotations.annotations) {
annotations = annotations.annotations;
}
return annotations;
}
if (typeOrFunc.decorators && typeOrFunc.decorators !== parentCtor.decorators) {
return convertTsickleDecoratorIntoMetadata(typeOrFunc.decorators);
}
if (typeOrFunc.hasOwnProperty(ANNOTATIONS)) {
return typeOrFunc[ANNOTATIONS];
}
return null;
}
annotations(typeOrFunc) {
if (!isType(typeOrFunc)) {
return [];
}
const parentCtor = getParentCtor(typeOrFunc);
const ownAnnotations = this._ownAnnotations(typeOrFunc, parentCtor) || [];
const parentAnnotations = parentCtor !== Object ? this.annotations(parentCtor) : [];
return parentAnnotations.concat(ownAnnotations);
}
_ownPropMetadata(typeOrFunc, parentCtor) {
if (typeOrFunc.propMetadata && typeOrFunc.propMetadata !== parentCtor.propMetadata) {
let propMetadata = typeOrFunc.propMetadata;
if (typeof propMetadata === "function" && propMetadata.propMetadata) {
propMetadata = propMetadata.propMetadata;
}
return propMetadata;
}
if (typeOrFunc.propDecorators && typeOrFunc.propDecorators !== parentCtor.propDecorators) {
const propDecorators = typeOrFunc.propDecorators;
const propMetadata = {};
Object.keys(propDecorators).forEach((prop) => {
propMetadata[prop] = convertTsickleDecoratorIntoMetadata(propDecorators[prop]);
});
return propMetadata;
}
if (typeOrFunc.hasOwnProperty(PROP_METADATA)) {
return typeOrFunc[PROP_METADATA];
}
return null;
}
propMetadata(typeOrFunc) {
if (!isType(typeOrFunc)) {
return {};
}
const parentCtor = getParentCtor(typeOrFunc);
const propMetadata = {};
if (parentCtor !== Object) {
const parentPropMetadata = this.propMetadata(parentCtor);
Object.keys(parentPropMetadata).forEach((propName) => {
propMetadata[propName] = parentPropMetadata[propName];
});
}
const ownPropMetadata = this._ownPropMetadata(typeOrFunc, parentCtor);
if (ownPropMetadata) {
Object.keys(ownPropMetadata).forEach((propName) => {
const decorators = [];
if (propMetadata.hasOwnProperty(propName)) {
decorators.push(...propMetadata[propName]);
}
decorators.push(...ownPropMetadata[propName]);
propMetadata[propName] = decorators;
});
}
return propMetadata;
}
ownPropMetadata(typeOrFunc) {
if (!isType(typeOrFunc)) {
return {};
}
return this._ownPropMetadata(typeOrFunc, getParentCtor(typeOrFunc)) || {};
}
hasLifecycleHook(type, lcProperty) {
return type instanceof Type && lcProperty in type.prototype;
}
};
function convertTsickleDecoratorIntoMetadata(decoratorInvocations) {
if (!decoratorInvocations) {
return [];
}
return decoratorInvocations.map((decoratorInvocation) => {
const decoratorType = decoratorInvocation.type;
const annotationCls = decoratorType.annotationCls;
const annotationArgs = decoratorInvocation.args ? decoratorInvocation.args : [];
return new annotationCls(...annotationArgs);
});
}
function getParentCtor(ctor) {
const parentProto = ctor.prototype ? Object.getPrototypeOf(ctor.prototype) : null;
const parentCtor = parentProto ? parentProto.constructor : null;
return parentCtor || Object;
}
var HOST = 0;
var TVIEW = 1;
var FLAGS = 2;
var PARENT = 3;
var NEXT = 4;
var T_HOST = 5;
var HYDRATION = 6;
var CLEANUP = 7;
var CONTEXT = 8;
var INJECTOR = 9;
var ENVIRONMENT = 10;
var RENDERER = 11;
var CHILD_HEAD = 12;
var CHILD_TAIL = 13;
var DECLARATION_VIEW = 14;
var DECLARATION_COMPONENT_VIEW = 15;
var DECLARATION_LCONTAINER = 16;
var PREORDER_HOOK_FLAGS = 17;
var QUERIES = 18;
var ID = 19;
var EMBEDDED_VIEW_INJECTOR = 20;
var ON_DESTROY_HOOKS = 21;
var EFFECTS_TO_SCHEDULE = 22;
var REACTIVE_TEMPLATE_CONSUMER = 23;
var HEADER_OFFSET = 25;
var TYPE = 1;
var NATIVE = 7;
var VIEW_REFS = 8;
var MOVED_VIEWS = 9;
var CONTAINER_HEADER_OFFSET = 10;
var LContainerFlags;
(function(LContainerFlags2) {
LContainerFlags2[LContainerFlags2["None"] = 0] = "None";
LContainerFlags2[LContainerFlags2["HasTransplantedViews"] = 2] = "HasTransplantedViews";
})(LContainerFlags || (LContainerFlags = {}));
function isLView(value2) {
return Array.isArray(value2) && typeof value2[TYPE] === "object";
}
function isLContainer(value2) {
return Array.isArray(value2) && value2[TYPE] === true;
}
function isContentQueryHost(tNode) {
return (tNode.flags & 4) !== 0;
}
function isComponentHost(tNode) {
return tNode.componentOffset > -1;
}
function isDirectiveHost(tNode) {
return (tNode.flags & 1) === 1;
}
function isComponentDef(def) {
return !!def.template;
}
function isRootView(target) {
return (target[FLAGS] & 512) !== 0;
}
function isDestroyed(lView) {
return (lView[FLAGS] & 256) === 256;
}
function assertTNodeForLView(tNode, lView) {
assertTNodeForTView(tNode, lView[TVIEW]);
}
function assertTNodeForTView(tNode, tView) {
assertTNode(tNode);
const tData = tView.data;
for (let i = HEADER_OFFSET; i < tData.length; i++) {
if (tData[i] === tNode) {
return;
}
}
throwError2("This TNode does not belong to this TView.");
}
function assertTNode(tNode) {
assertDefined(tNode, "TNode must be defined");
if (!(tNode && typeof tNode === "object" && tNode.hasOwnProperty("directiveStylingLast"))) {
throwError2("Not of type TNode, got: " + tNode);
}
}
function assertTIcu(tIcu) {
assertDefined(tIcu, "Expected TIcu to be defined");
if (!(typeof tIcu.currentCaseLViewIndex === "number")) {
throwError2("Object is not of TIcu type.");
}
}
function assertComponentType(actual, msg = "Type passed in is not ComponentType, it does not have '\u0275cmp' property.") {
if (!getComponentDef(actual)) {
throwError2(msg);
}
}
function assertNgModuleType(actual, msg = "Type passed in is not NgModuleType, it does not have '\u0275mod' property.") {
if (!getNgModuleDef(actual)) {
throwError2(msg);
}
}
function assertHasParent(tNode) {
assertDefined(tNode, "currentTNode should exist!");
assertDefined(tNode.parent, "currentTNode should have a parent");
}
function assertLContainer(value2) {
assertDefined(value2, "LContainer must be defined");
assertEqual(isLContainer(value2), true, "Expecting LContainer");
}
function assertLViewOrUndefined(value2) {
value2 && assertEqual(isLView(value2), true, "Expecting LView or undefined or null");
}
function assertLView(value2) {
assertDefined(value2, "LView must be defined");
assertEqual(isLView(value2), true, "Expecting LView");
}
function assertFirstCreatePass(tView, errMessage) {
assertEqual(tView.firstCreatePass, true, errMessage || "Should only be called in first create pass.");
}
function assertFirstUpdatePass(tView, errMessage) {
assertEqual(tView.firstUpdatePass, true, errMessage || "Should only be called in first update pass.");
}
function assertDirectiveDef(obj) {
if (obj.type === void 0 || obj.selectors == void 0 || obj.inputs === void 0) {
throwError2(`Expected a DirectiveDef/ComponentDef and this object does not seem to have the expected shape.`);
}
}
function assertIndexInDeclRange(tView, index2) {
assertBetween(HEADER_OFFSET, tView.bindingStartIndex, index2);
}
function assertIndexInExpandoRange(lView, index2) {
const tView = lView[1];
assertBetween(tView.expandoStartIndex, lView.length, index2);
}
function assertBetween(lower, upper, index2) {
if (!(lower <= index2 && index2 < upper)) {
throwError2(`Index out of range (expecting ${lower} <= ${index2} < ${upper})`);
}
}
function assertProjectionSlots(lView, errMessage) {
assertDefined(lView[DECLARATION_COMPONENT_VIEW], "Component views should exist.");
assertDefined(lView[DECLARATION_COMPONENT_VIEW][T_HOST].projection, errMessage || "Components with projection nodes (<ng-content>) must have projection slots defined.");
}
function assertParentView(lView, errMessage) {
assertDefined(lView, errMessage || "Component views should always have a parent view (component's host view)");
}
function assertNoDuplicateDirectives(directives) {
if (directives.length < 2) {
return;
}
const seenDirectives = /* @__PURE__ */ new Set();
for (const current of directives) {
if (seenDirectives.has(current)) {
throw new RuntimeError(309, `Directive ${current.type.name} matches multiple times on the same element. Directives can only match an element once.`);
}
seenDirectives.add(current);
}
}
function assertNodeInjector(lView, injectorIndex) {
assertIndexInExpandoRange(lView, injectorIndex);
assertIndexInExpandoRange(
lView,
injectorIndex + 8
/* NodeInjectorOffset.PARENT */
);
assertNumber(lView[injectorIndex + 0], "injectorIndex should point to a bloom filter");
assertNumber(lView[injectorIndex + 1], "injectorIndex should point to a bloom filter");
assertNumber(lView[injectorIndex + 2], "injectorIndex should point to a bloom filter");
assertNumber(lView[injectorIndex + 3], "injectorIndex should point to a bloom filter");
assertNumber(lView[injectorIndex + 4], "injectorIndex should point to a bloom filter");
assertNumber(lView[injectorIndex + 5], "injectorIndex should point to a bloom filter");
assertNumber(lView[injectorIndex + 6], "injectorIndex should point to a bloom filter");
assertNumber(lView[injectorIndex + 7], "injectorIndex should point to a bloom filter");
assertNumber(lView[
injectorIndex + 8
/* NodeInjectorOffset.PARENT */
], "injectorIndex should point to parent injector");
}
var SimpleChange = class {
constructor(previousValue, currentValue, firstChange) {
this.previousValue = previousValue;
this.currentValue = currentValue;
this.firstChange = firstChange;
}
/**
* Check whether the new value is the first value assigned.
*/
isFirstChange() {
return this.firstChange;
}
};
function applyValueToInputField(instance, inputSignalNode, privateName, value2) {
if (inputSignalNode !== null) {
inputSignalNode.applyValueToInputSignal(inputSignalNode, value2);
} else {
instance[privateName] = value2;
}
}
function \u0275\u0275NgOnChangesFeature() {
return NgOnChangesFeatureImpl;
}
function NgOnChangesFeatureImpl(definition) {
if (definition.type.prototype.ngOnChanges) {
definition.setInput = ngOnChangesSetInput;
}
return rememberChangeHistoryAndInvokeOnChangesHook;
}
\u0275\u0275NgOnChangesFeature.ngInherit = true;
function rememberChangeHistoryAndInvokeOnChangesHook() {
const simpleChangesStore = getSimpleChangesStore(this);
const current = simpleChangesStore?.current;
if (current) {
const previous = simpleChangesStore.previous;
if (previous === EMPTY_OBJ) {
simpleChangesStore.previous = current;
} else {
for (let key2 in current) {
previous[key2] = current[key2];
}
}
simpleChangesStore.current = null;
this.ngOnChanges(current);
}
}
function ngOnChangesSetInput(instance, inputSignalNode, value2, publicName, privateName) {
const declaredName = this.declaredInputs[publicName];
ngDevMode && assertString(declaredName, "Name of input in ngOnChanges has to be a string");
const simpleChangesStore = getSimpleChangesStore(instance) || setSimpleChangesStore(instance, { previous: EMPTY_OBJ, current: null });
const current = simpleChangesStore.current || (simpleChangesStore.current = {});
const previous = simpleChangesStore.previous;
const previousChange = previous[declaredName];
current[declaredName] = new SimpleChange(previousChange && previousChange.currentValue, value2, previous === EMPTY_OBJ);
applyValueToInputField(instance, inputSignalNode, privateName, value2);
}
var SIMPLE_CHANGES_STORE = "__ngSimpleChanges__";
function getSimpleChangesStore(instance) {
return instance[SIMPLE_CHANGES_STORE] || null;
}
function setSimpleChangesStore(instance, store2) {
return instance[SIMPLE_CHANGES_STORE] = store2;
}
var profilerCallback = null;
var setProfiler = (profiler2) => {
profilerCallback = profiler2;
};
var profiler = function(event, instance, hookOrListener) {
if (profilerCallback != null) {
profilerCallback(event, instance, hookOrListener);
}
};
var SVG_NAMESPACE = "svg";
var MATH_ML_NAMESPACE = "math";
var _ensureDirtyViewsAreAlwaysReachable = false;
function getEnsureDirtyViewsAreAlwaysReachable() {
return _ensureDirtyViewsAreAlwaysReachable;
}
function unwrapRNode(value2) {
while (Array.isArray(value2)) {
value2 = value2[HOST];
}
return value2;
}
function unwrapLView(value2) {
while (Array.isArray(value2)) {
if (typeof value2[TYPE] === "object")
return value2;
value2 = value2[HOST];
}
return null;
}
function getNativeByIndex(index2, lView) {
ngDevMode && assertIndexInRange(lView, index2);
ngDevMode && assertGreaterThanOrEqual(index2, HEADER_OFFSET, "Expected to be past HEADER_OFFSET");
return unwrapRNode(lView[index2]);
}
function getNativeByTNode(tNode, lView) {
ngDevMode && assertTNodeForLView(tNode, lView);
ngDevMode && assertIndexInRange(lView, tNode.index);
const node = unwrapRNode(lView[tNode.index]);
return node;
}
function getTNode(tView, index2) {
ngDevMode && assertGreaterThan(index2, -1, "wrong index for TNode");
ngDevMode && assertLessThan(index2, tView.data.length, "wrong index for TNode");
const tNode = tView.data[index2];
ngDevMode && tNode !== null && assertTNode(tNode);
return tNode;
}
function load(view, index2) {
ngDevMode && assertIndexInRange(view, index2);
return view[index2];
}
function getComponentLViewByIndex(nodeIndex, hostView) {
ngDevMode && assertIndexInRange(hostView, nodeIndex);
const slotValue = hostView[nodeIndex];
const lView = isLView(slotValue) ? slotValue : slotValue[HOST];
return lView;
}
function isCreationMode(view) {
return (view[FLAGS] & 4) === 4;
}
function viewAttachedToChangeDetector(view) {
return (view[FLAGS] & 128) === 128;
}
function viewAttachedToContainer(view) {
return isLContainer(view[PARENT]);
}
function getConstant(consts, index2) {
if (index2 === null || index2 === void 0)
return null;
ngDevMode && assertIndexInRange(consts, index2);
return consts[index2];
}
function resetPreOrderHookFlags(lView) {
lView[PREORDER_HOOK_FLAGS] = 0;
}
function markViewForRefresh(lView) {
if (lView[FLAGS] & 1024) {
return;
}
lView[FLAGS] |= 1024;
if (viewAttachedToChangeDetector(lView)) {
markAncestorsForTraversal(lView);
}
}
function walkUpViews(nestingLevel, currentView) {
while (nestingLevel > 0) {
ngDevMode && assertDefined(currentView[DECLARATION_VIEW], "Declaration view should be defined if nesting level is greater than 0.");
currentView = currentView[DECLARATION_VIEW];
nestingLevel--;
}
return currentView;
}
function requiresRefreshOrTraversal(lView) {
return !!(lView[FLAGS] & (1024 | 8192) || lView[REACTIVE_TEMPLATE_CONSUMER]?.dirty);
}
function updateAncestorTraversalFlagsOnAttach(lView) {
lView[ENVIRONMENT].changeDetectionScheduler?.notify(
1
/* NotificationType.AfterRenderHooks */
);
if (requiresRefreshOrTraversal(lView)) {
markAncestorsForTraversal(lView);
} else if (lView[FLAGS] & 64) {
if (getEnsureDirtyViewsAreAlwaysReachable()) {
lView[FLAGS] |= 1024;
markAncestorsForTraversal(lView);
} else {
lView[ENVIRONMENT].changeDetectionScheduler?.notify();
}
}
}
function markAncestorsForTraversal(lView) {
lView[ENVIRONMENT].changeDetectionScheduler?.notify();
let parent2 = getLViewParent(lView);
while (parent2 !== null) {
if (parent2[FLAGS] & 8192) {
break;
}
parent2[FLAGS] |= 8192;
if (!viewAttachedToChangeDetector(parent2)) {
break;
}
parent2 = getLViewParent(parent2);
}
}
function storeLViewOnDestroy(lView, onDestroyCallback) {
if ((lView[FLAGS] & 256) === 256) {
throw new RuntimeError(911, ngDevMode && "View has already been destroyed.");
}
if (lView[ON_DESTROY_HOOKS] === null) {
lView[ON_DESTROY_HOOKS] = [];
}
lView[ON_DESTROY_HOOKS].push(onDestroyCallback);
}
function removeLViewOnDestroy(lView, onDestroyCallback) {
if (lView[ON_DESTROY_HOOKS] === null)
return;
const destroyCBIdx = lView[ON_DESTROY_HOOKS].indexOf(onDestroyCallback);
if (destroyCBIdx !== -1) {
lView[ON_DESTROY_HOOKS].splice(destroyCBIdx, 1);
}
}
function getLViewParent(lView) {
ngDevMode && assertLView(lView);
const parent2 = lView[PARENT];
return isLContainer(parent2) ? parent2[PARENT] : parent2;
}
var instructionState = {
lFrame: createLFrame(null),
bindingsEnabled: true,
skipHydrationRootTNode: null
};
var _isInCheckNoChangesMode = false;
function getElementDepthCount() {
return instructionState.lFrame.elementDepthCount;
}
function increaseElementDepthCount() {
instructionState.lFrame.elementDepthCount++;
}
function decreaseElementDepthCount() {
instructionState.lFrame.elementDepthCount--;
}
function getBindingsEnabled() {
return instructionState.bindingsEnabled;
}
function isInSkipHydrationBlock$1() {
return instructionState.skipHydrationRootTNode !== null;
}
function isSkipHydrationRootTNode(tNode) {
return instructionState.skipHydrationRootTNode === tNode;
}
function \u0275\u0275enableBindings() {
instructionState.bindingsEnabled = true;
}
function \u0275\u0275disableBindings() {
instructionState.bindingsEnabled = false;
}
function leaveSkipHydrationBlock() {
instructionState.skipHydrationRootTNode = null;
}
function getLView() {
return instructionState.lFrame.lView;
}
function getTView() {
return instructionState.lFrame.tView;
}
function \u0275\u0275restoreView(viewToRestore) {
instructionState.lFrame.contextLView = viewToRestore;
return viewToRestore[CONTEXT];
}
function \u0275\u0275resetView(value2) {
instructionState.lFrame.contextLView = null;
return value2;
}
function getCurrentTNode() {
let currentTNode = getCurrentTNodePlaceholderOk();
while (currentTNode !== null && currentTNode.type === 64) {
currentTNode = currentTNode.parent;
}
return currentTNode;
}
function getCurrentTNodePlaceholderOk() {
return instructionState.lFrame.currentTNode;
}
function getCurrentParentTNode() {
const lFrame = instructionState.lFrame;
const currentTNode = lFrame.currentTNode;
return lFrame.isParent ? currentTNode : currentTNode.parent;
}
function setCurrentTNode(tNode, isParent) {
ngDevMode && tNode && assertTNodeForTView(tNode, instructionState.lFrame.tView);
const lFrame = instructionState.lFrame;
lFrame.currentTNode = tNode;
lFrame.isParent = isParent;
}
function isCurrentTNodeParent() {
return instructionState.lFrame.isParent;
}
function setCurrentTNodeAsNotParent() {
instructionState.lFrame.isParent = false;
}
function getContextLView() {
const contextLView = instructionState.lFrame.contextLView;
ngDevMode && assertDefined(contextLView, "contextLView must be defined.");
return contextLView;
}
function isInCheckNoChangesMode() {
!ngDevMode && throwError2("Must never be called in production mode");
return _isInCheckNoChangesMode;
}
function setIsInCheckNoChangesMode(mode) {
!ngDevMode && throwError2("Must never be called in production mode");
_isInCheckNoChangesMode = mode;
}
function getBindingRoot() {
const lFrame = instructionState.lFrame;
let index2 = lFrame.bindingRootIndex;
if (index2 === -1) {
index2 = lFrame.bindingRootIndex = lFrame.tView.bindingStartIndex;
}
return index2;
}
function getBindingIndex() {
return instructionState.lFrame.bindingIndex;
}
function setBindingIndex(value2) {
return instructionState.lFrame.bindingIndex = value2;
}
function nextBindingIndex() {
return instructionState.lFrame.bindingIndex++;
}
function incrementBindingIndex(count) {
const lFrame = instructionState.lFrame;
const index2 = lFrame.bindingIndex;
lFrame.bindingIndex = lFrame.bindingIndex + count;
return index2;
}
function isInI18nBlock() {
return instructionState.lFrame.inI18n;
}
function setInI18nBlock(isInI18nBlock2) {
instructionState.lFrame.inI18n = isInI18nBlock2;
}
function setBindingRootForHostBindings(bindingRootIndex, currentDirectiveIndex) {
const lFrame = instructionState.lFrame;
lFrame.bindingIndex = lFrame.bindingRootIndex = bindingRootIndex;
setCurrentDirectiveIndex(currentDirectiveIndex);
}
function getCurrentDirectiveIndex() {
return instructionState.lFrame.currentDirectiveIndex;
}
function setCurrentDirectiveIndex(currentDirectiveIndex) {
instructionState.lFrame.currentDirectiveIndex = currentDirectiveIndex;
}
function getCurrentDirectiveDef(tData) {
const currentDirectiveIndex = instructionState.lFrame.currentDirectiveIndex;
return currentDirectiveIndex === -1 ? null : tData[currentDirectiveIndex];
}
function getCurrentQueryIndex() {
return instructionState.lFrame.currentQueryIndex;
}
function setCurrentQueryIndex(value2) {
instructionState.lFrame.currentQueryIndex = value2;
}
function getDeclarationTNode(lView) {
const tView = lView[TVIEW];
if (tView.type === 2) {
ngDevMode && assertDefined(tView.declTNode, "Embedded TNodes should have declaration parents.");
return tView.declTNode;
}
if (tView.type === 1) {
return lView[T_HOST];
}
return null;
}
function enterDI(lView, tNode, flags) {
ngDevMode && assertLViewOrUndefined(lView);
if (flags & InjectFlags.SkipSelf) {
ngDevMode && assertTNodeForTView(tNode, lView[TVIEW]);
let parentTNode = tNode;
let parentLView = lView;
while (true) {
ngDevMode && assertDefined(parentTNode, "Parent TNode should be defined");
parentTNode = parentTNode.parent;
if (parentTNode === null && !(flags & InjectFlags.Host)) {
parentTNode = getDeclarationTNode(parentLView);
if (parentTNode === null)
break;
ngDevMode && assertDefined(parentLView, "Parent LView should be defined");
parentLView = parentLView[DECLARATION_VIEW];
if (parentTNode.type & (2 | 8)) {
break;
}
} else {
break;
}
}
if (parentTNode === null) {
return false;
} else {
tNode = parentTNode;
lView = parentLView;
}
}
ngDevMode && assertTNodeForLView(tNode, lView);
const lFrame = instructionState.lFrame = allocLFrame();
lFrame.currentTNode = tNode;
lFrame.lView = lView;
return true;
}
function enterView(newView) {
ngDevMode && assertNotEqual(newView[0], newView[1], "????");
ngDevMode && assertLViewOrUndefined(newView);
const newLFrame = allocLFrame();
if (ngDevMode) {
assertEqual(newLFrame.isParent, true, "Expected clean LFrame");
assertEqual(newLFrame.lView, null, "Expected clean LFrame");
assertEqual(newLFrame.tView, null, "Expected clean LFrame");
assertEqual(newLFrame.selectedIndex, -1, "Expected clean LFrame");
assertEqual(newLFrame.elementDepthCount, 0, "Expected clean LFrame");
assertEqual(newLFrame.currentDirectiveIndex, -1, "Expected clean LFrame");
assertEqual(newLFrame.currentNamespace, null, "Expected clean LFrame");
assertEqual(newLFrame.bindingRootIndex, -1, "Expected clean LFrame");
assertEqual(newLFrame.currentQueryIndex, 0, "Expected clean LFrame");
}
const tView = newView[TVIEW];
instructionState.lFrame = newLFrame;
ngDevMode && tView.firstChild && assertTNodeForTView(tView.firstChild, tView);
newLFrame.currentTNode = tView.firstChild;
newLFrame.lView = newView;
newLFrame.tView = tView;
newLFrame.contextLView = newView;
newLFrame.bindingIndex = tView.bindingStartIndex;
newLFrame.inI18n = false;
}
function allocLFrame() {
const currentLFrame = instructionState.lFrame;
const childLFrame = currentLFrame === null ? null : currentLFrame.child;
const newLFrame = childLFrame === null ? createLFrame(currentLFrame) : childLFrame;
return newLFrame;
}
function createLFrame(parent2) {
const lFrame = {
currentTNode: null,
isParent: true,
lView: null,
tView: null,
selectedIndex: -1,
contextLView: null,
elementDepthCount: 0,
currentNamespace: null,
currentDirectiveIndex: -1,
bindingRootIndex: -1,
bindingIndex: -1,
currentQueryIndex: 0,
parent: parent2,
child: null,
inI18n: false
};
parent2 !== null && (parent2.child = lFrame);
return lFrame;
}
function leaveViewLight() {
const oldLFrame = instructionState.lFrame;
instructionState.lFrame = oldLFrame.parent;
oldLFrame.currentTNode = null;
oldLFrame.lView = null;
return oldLFrame;
}
var leaveDI = leaveViewLight;
function leaveView() {
const oldLFrame = leaveViewLight();
oldLFrame.isParent = true;
oldLFrame.tView = null;
oldLFrame.selectedIndex = -1;
oldLFrame.contextLView = null;
oldLFrame.elementDepthCount = 0;
oldLFrame.currentDirectiveIndex = -1;
oldLFrame.currentNamespace = null;
oldLFrame.bindingRootIndex = -1;
oldLFrame.bindingIndex = -1;
oldLFrame.currentQueryIndex = 0;
}
function nextContextImpl(level) {
const contextLView = instructionState.lFrame.contextLView = walkUpViews(level, instructionState.lFrame.contextLView);
return contextLView[CONTEXT];
}
function getSelectedIndex() {
return instructionState.lFrame.selectedIndex;
}
function setSelectedIndex(index2) {
ngDevMode && index2 !== -1 && assertGreaterThanOrEqual(index2, HEADER_OFFSET, "Index must be past HEADER_OFFSET (or -1).");
ngDevMode && assertLessThan(index2, instructionState.lFrame.lView.length, "Can't set index passed end of LView");
instructionState.lFrame.selectedIndex = index2;
}
function getSelectedTNode() {
const lFrame = instructionState.lFrame;
return getTNode(lFrame.tView, lFrame.selectedIndex);
}
function \u0275\u0275namespaceSVG() {
instructionState.lFrame.currentNamespace = SVG_NAMESPACE;
}
function \u0275\u0275namespaceMathML() {
instructionState.lFrame.currentNamespace = MATH_ML_NAMESPACE;
}
function \u0275\u0275namespaceHTML() {
namespaceHTMLInternal();
}
function namespaceHTMLInternal() {
instructionState.lFrame.currentNamespace = null;
}
function getNamespace$1() {
return instructionState.lFrame.currentNamespace;
}
var _wasLastNodeCreated = true;
function wasLastNodeCreated() {
return _wasLastNodeCreated;
}
function lastNodeWasCreated(flag) {
_wasLastNodeCreated = flag;
}
function registerPreOrderHooks(directiveIndex, directiveDef, tView) {
ngDevMode && assertFirstCreatePass(tView);
const { ngOnChanges, ngOnInit, ngDoCheck } = directiveDef.type.prototype;
if (ngOnChanges) {
const wrappedOnChanges = NgOnChangesFeatureImpl(directiveDef);
(tView.preOrderHooks ??= []).push(directiveIndex, wrappedOnChanges);
(tView.preOrderCheckHooks ??= []).push(directiveIndex, wrappedOnChanges);
}
if (ngOnInit) {
(tView.preOrderHooks ??= []).push(0 - directiveIndex, ngOnInit);
}
if (ngDoCheck) {
(tView.preOrderHooks ??= []).push(directiveIndex, ngDoCheck);
(tView.preOrderCheckHooks ??= []).push(directiveIndex, ngDoCheck);
}
}
function registerPostOrderHooks(tView, tNode) {
ngDevMode && assertFirstCreatePass(tView);
for (let i = tNode.directiveStart, end = tNode.directiveEnd; i < end; i++) {
const directiveDef = tView.data[i];
ngDevMode && assertDefined(directiveDef, "Expecting DirectiveDef");
const lifecycleHooks = directiveDef.type.prototype;
const { ngAfterContentInit, ngAfterContentChecked, ngAfterViewInit, ngAfterViewChecked, ngOnDestroy } = lifecycleHooks;
if (ngAfterContentInit) {
(tView.contentHooks ??= []).push(-i, ngAfterContentInit);
}
if (ngAfterContentChecked) {
(tView.contentHooks ??= []).push(i, ngAfterContentChecked);
(tView.contentCheckHooks ??= []).push(i, ngAfterContentChecked);
}
if (ngAfterViewInit) {
(tView.viewHooks ??= []).push(-i, ngAfterViewInit);
}
if (ngAfterViewChecked) {
(tView.viewHooks ??= []).push(i, ngAfterViewChecked);
(tView.viewCheckHooks ??= []).push(i, ngAfterViewChecked);
}
if (ngOnDestroy != null) {
(tView.destroyHooks ??= []).push(i, ngOnDestroy);
}
}
}
function executeCheckHooks(lView, hooks, nodeIndex) {
callHooks(lView, hooks, 3, nodeIndex);
}
function executeInitAndCheckHooks(lView, hooks, initPhase, nodeIndex) {
ngDevMode && assertNotEqual(initPhase, 3, "Init pre-order hooks should not be called more than once");
if ((lView[FLAGS] & 3) === initPhase) {
callHooks(lView, hooks, initPhase, nodeIndex);
}
}
function incrementInitPhaseFlags(lView, initPhase) {
ngDevMode && assertNotEqual(initPhase, 3, "Init hooks phase should not be incremented after all init hooks have been run.");
let flags = lView[FLAGS];
if ((flags & 3) === initPhase) {
flags &= 16383;
flags += 1;
lView[FLAGS] = flags;
}
}
function callHooks(currentView, arr, initPhase, currentNodeIndex) {
ngDevMode && assertEqual(isInCheckNoChangesMode(), false, "Hooks should never be run when in check no changes mode.");
const startIndex = currentNodeIndex !== void 0 ? currentView[PREORDER_HOOK_FLAGS] & 65535 : 0;
const nodeIndexLimit = currentNodeIndex != null ? currentNodeIndex : -1;
const max = arr.length - 1;
let lastNodeIndexFound = 0;
for (let i = startIndex; i < max; i++) {
const hook = arr[i + 1];
if (typeof hook === "number") {
lastNodeIndexFound = arr[i];
if (currentNodeIndex != null && lastNodeIndexFound >= currentNodeIndex) {
break;
}
} else {
const isInitHook = arr[i] < 0;
if (isInitHook) {
currentView[PREORDER_HOOK_FLAGS] += 65536;
}
if (lastNodeIndexFound < nodeIndexLimit || nodeIndexLimit == -1) {
callHook(currentView, initPhase, arr, i);
currentView[PREORDER_HOOK_FLAGS] = (currentView[PREORDER_HOOK_FLAGS] & 4294901760) + i + 2;
}
i++;
}
}
}
function callHookInternal(directive, hook) {
profiler(4, directive, hook);
const prevConsumer = setActiveConsumer(null);
try {
hook.call(directive);
} finally {
setActiveConsumer(prevConsumer);
profiler(5, directive, hook);
}
}
function callHook(currentView, initPhase, arr, i) {
const isInitHook = arr[i] < 0;
const hook = arr[i + 1];
const directiveIndex = isInitHook ? -arr[i] : arr[i];
const directive = currentView[directiveIndex];
if (isInitHook) {
const indexWithintInitPhase = currentView[FLAGS] >> 14;
if (indexWithintInitPhase < currentView[PREORDER_HOOK_FLAGS] >> 16 && (currentView[FLAGS] & 3) === initPhase) {
currentView[FLAGS] += 16384;
callHookInternal(directive, hook);
}
} else {
callHookInternal(directive, hook);
}
}
var NO_PARENT_INJECTOR = -1;
var NodeInjectorFactory = class {
constructor(factory, isViewProvider, injectImplementation) {
this.factory = factory;
this.resolving = false;
ngDevMode && assertDefined(factory, "Factory not specified");
ngDevMode && assertEqual(typeof factory, "function", "Expected factory function.");
this.canSeeViewProviders = isViewProvider;
this.injectImpl = injectImplementation;
}
};
function isFactory(obj) {
return obj instanceof NodeInjectorFactory;
}
function toTNodeTypeAsString(tNodeType) {
let text2 = "";
tNodeType & 1 && (text2 += "|Text");
tNodeType & 2 && (text2 += "|Element");
tNodeType & 4 && (text2 += "|Container");
tNodeType & 8 && (text2 += "|ElementContainer");
tNodeType & 16 && (text2 += "|Projection");
tNodeType & 32 && (text2 += "|IcuContainer");
tNodeType & 64 && (text2 += "|Placeholder");
return text2.length > 0 ? text2.substring(1) : text2;
}
function hasClassInput(tNode) {
return (tNode.flags & 8) !== 0;
}
function hasStyleInput(tNode) {
return (tNode.flags & 16) !== 0;
}
function assertTNodeType(tNode, expectedTypes, message) {
assertDefined(tNode, "should be called with a TNode");
if ((tNode.type & expectedTypes) === 0) {
throwError2(message || `Expected [${toTNodeTypeAsString(expectedTypes)}] but got ${toTNodeTypeAsString(tNode.type)}.`);
}
}
function assertPureTNodeType(type) {
if (!(type === 2 || //
type === 1 || //
type === 4 || //
type === 8 || //
type === 32 || //
type === 16 || //
type === 64)) {
throwError2(`Expected TNodeType to have only a single type selected, but got ${toTNodeTypeAsString(type)}.`);
}
}
function hasParentInjector(parentLocation) {
return parentLocation !== NO_PARENT_INJECTOR;
}
function getParentInjectorIndex(parentLocation) {
if (ngDevMode) {
assertNumber(parentLocation, "Number expected");
assertNotEqual(parentLocation, -1, "Not a valid state.");
const parentInjectorIndex = parentLocation & 32767;
assertGreaterThan(parentInjectorIndex, HEADER_OFFSET, "Parent injector must be pointing past HEADER_OFFSET.");
}
return parentLocation & 32767;
}
function getParentInjectorViewOffset(parentLocation) {
return parentLocation >> 16;
}
function getParentInjectorView(location2, startView) {
let viewOffset = getParentInjectorViewOffset(location2);
let parentView = startView;
while (viewOffset > 0) {
parentView = parentView[DECLARATION_VIEW];
viewOffset--;
}
return parentView;
}
var includeViewProviders = true;
function setIncludeViewProviders(v) {
const oldValue = includeViewProviders;
includeViewProviders = v;
return oldValue;
}
var BLOOM_SIZE = 256;
var BLOOM_MASK = BLOOM_SIZE - 1;
var BLOOM_BUCKET_BITS = 5;
var nextNgElementId = 0;
var NOT_FOUND = {};
function bloomAdd(injectorIndex, tView, type) {
ngDevMode && assertEqual(tView.firstCreatePass, true, "expected firstCreatePass to be true");
let id;
if (typeof type === "string") {
id = type.charCodeAt(0) || 0;
} else if (type.hasOwnProperty(NG_ELEMENT_ID)) {
id = type[NG_ELEMENT_ID];
}
if (id == null) {
id = type[NG_ELEMENT_ID] = nextNgElementId++;
}
const bloomHash = id & BLOOM_MASK;
const mask2 = 1 << bloomHash;
tView.data[injectorIndex + (bloomHash >> BLOOM_BUCKET_BITS)] |= mask2;
}
function getOrCreateNodeInjectorForNode(tNode, lView) {
const existingInjectorIndex = getInjectorIndex(tNode, lView);
if (existingInjectorIndex !== -1) {
return existingInjectorIndex;
}
const tView = lView[TVIEW];
if (tView.firstCreatePass) {
tNode.injectorIndex = lView.length;
insertBloom(tView.data, tNode);
insertBloom(lView, null);
insertBloom(tView.blueprint, null);
}
const parentLoc = getParentInjectorLocation(tNode, lView);
const injectorIndex = tNode.injectorIndex;
if (hasParentInjector(parentLoc)) {
const parentIndex = getParentInjectorIndex(parentLoc);
const parentLView = getParentInjectorView(parentLoc, lView);
const parentData = parentLView[TVIEW].data;
for (let i = 0; i < 8; i++) {
lView[injectorIndex + i] = parentLView[parentIndex + i] | parentData[parentIndex + i];
}
}
lView[
injectorIndex + 8
/* NodeInjectorOffset.PARENT */
] = parentLoc;
return injectorIndex;
}
function insertBloom(arr, footer) {
arr.push(0, 0, 0, 0, 0, 0, 0, 0, footer);
}
function getInjectorIndex(tNode, lView) {
if (tNode.injectorIndex === -1 || // If the injector index is the same as its parent's injector index, then the index has been
// copied down from the parent node. No injector has been created yet on this node.
tNode.parent && tNode.parent.injectorIndex === tNode.injectorIndex || // After the first template pass, the injector index might exist but the parent values
// might not have been calculated yet for this instance
lView[
tNode.injectorIndex + 8
/* NodeInjectorOffset.PARENT */
] === null) {
return -1;
} else {
ngDevMode && assertIndexInRange(lView, tNode.injectorIndex);
return tNode.injectorIndex;
}
}
function getParentInjectorLocation(tNode, lView) {
if (tNode.parent && tNode.parent.injectorIndex !== -1) {
return tNode.parent.injectorIndex;
}
let declarationViewOffset = 0;
let parentTNode = null;
let lViewCursor = lView;
while (lViewCursor !== null) {
parentTNode = getTNodeFromLView(lViewCursor);
if (parentTNode === null) {
return NO_PARENT_INJECTOR;
}
ngDevMode && parentTNode && assertTNodeForLView(parentTNode, lViewCursor[DECLARATION_VIEW]);
declarationViewOffset++;
lViewCursor = lViewCursor[DECLARATION_VIEW];
if (parentTNode.injectorIndex !== -1) {
return parentTNode.injectorIndex | declarationViewOffset << 16;
}
}
return NO_PARENT_INJECTOR;
}
function diPublicInInjector(injectorIndex, tView, token) {
bloomAdd(injectorIndex, tView, token);
}
function injectAttributeImpl(tNode, attrNameToInject) {
ngDevMode && assertTNodeType(
tNode,
12 | 3
/* TNodeType.AnyRNode */
);
ngDevMode && assertDefined(tNode, "expecting tNode");
if (attrNameToInject === "class") {
return tNode.classes;
}
if (attrNameToInject === "style") {
return tNode.styles;
}
const attrs = tNode.attrs;
if (attrs) {
const attrsLength = attrs.length;
let i = 0;
while (i < attrsLength) {
const value2 = attrs[i];
if (isNameOnlyAttributeMarker(value2))
break;
if (value2 === 0) {
i = i + 2;
} else if (typeof value2 === "number") {
i++;
while (i < attrsLength && typeof attrs[i] === "string") {
i++;
}
} else if (value2 === attrNameToInject) {
return attrs[i + 1];
} else {
i = i + 2;
}
}
}
return null;
}
function notFoundValueOrThrow(notFoundValue, token, flags) {
if (flags & InjectFlags.Optional || notFoundValue !== void 0) {
return notFoundValue;
} else {
throwProviderNotFoundError(token, "NodeInjector");
}
}
function lookupTokenUsingModuleInjector(lView, token, flags, notFoundValue) {
if (flags & InjectFlags.Optional && notFoundValue === void 0) {
notFoundValue = null;
}
if ((flags & (InjectFlags.Self | InjectFlags.Host)) === 0) {
const moduleInjector = lView[INJECTOR];
const previousInjectImplementation = setInjectImplementation(void 0);
try {
if (moduleInjector) {
return moduleInjector.get(token, notFoundValue, flags & InjectFlags.Optional);
} else {
return injectRootLimpMode(token, notFoundValue, flags & InjectFlags.Optional);
}
} finally {
setInjectImplementation(previousInjectImplementation);
}
}
return notFoundValueOrThrow(notFoundValue, token, flags);
}
function getOrCreateInjectable(tNode, lView, token, flags = InjectFlags.Default, notFoundValue) {
if (tNode !== null) {
if (lView[FLAGS] & 2048 && // The token must be present on the current node injector when the `Self`
// flag is set, so the lookup on embedded view injector(s) can be skipped.
!(flags & InjectFlags.Self)) {
const embeddedInjectorValue = lookupTokenUsingEmbeddedInjector(tNode, lView, token, flags, NOT_FOUND);
if (embeddedInjectorValue !== NOT_FOUND) {
return embeddedInjectorValue;
}
}
const value2 = lookupTokenUsingNodeInjector(tNode, lView, token, flags, NOT_FOUND);
if (value2 !== NOT_FOUND) {
return value2;
}
}
return lookupTokenUsingModuleInjector(lView, token, flags, notFoundValue);
}
function lookupTokenUsingNodeInjector(tNode, lView, token, flags, notFoundValue) {
const bloomHash = bloomHashBitOrFactory(token);
if (typeof bloomHash === "function") {
if (!enterDI(lView, tNode, flags)) {
return flags & InjectFlags.Host ? notFoundValueOrThrow(notFoundValue, token, flags) : lookupTokenUsingModuleInjector(lView, token, flags, notFoundValue);
}
try {
let value2;
if (ngDevMode) {
runInInjectorProfilerContext(new NodeInjector(getCurrentTNode(), getLView()), token, () => {
value2 = bloomHash(flags);
if (value2 != null) {
emitInstanceCreatedByInjectorEvent(value2);
}
});
} else {
value2 = bloomHash(flags);
}
if (value2 == null && !(flags & InjectFlags.Optional)) {
throwProviderNotFoundError(token);
} else {
return value2;
}
} finally {
leaveDI();
}
} else if (typeof bloomHash === "number") {
let previousTView = null;
let injectorIndex = getInjectorIndex(tNode, lView);
let parentLocation = NO_PARENT_INJECTOR;
let hostTElementNode = flags & InjectFlags.Host ? lView[DECLARATION_COMPONENT_VIEW][T_HOST] : null;
if (injectorIndex === -1 || flags & InjectFlags.SkipSelf) {
parentLocation = injectorIndex === -1 ? getParentInjectorLocation(tNode, lView) : lView[
injectorIndex + 8
/* NodeInjectorOffset.PARENT */
];
if (parentLocation === NO_PARENT_INJECTOR || !shouldSearchParent(flags, false)) {
injectorIndex = -1;
} else {
previousTView = lView[TVIEW];
injectorIndex = getParentInjectorIndex(parentLocation);
lView = getParentInjectorView(parentLocation, lView);
}
}
while (injectorIndex !== -1) {
ngDevMode && assertNodeInjector(lView, injectorIndex);
const tView = lView[TVIEW];
ngDevMode && assertTNodeForLView(tView.data[
injectorIndex + 8
/* NodeInjectorOffset.TNODE */
], lView);
if (bloomHasToken(bloomHash, injectorIndex, tView.data)) {
const instance = searchTokensOnInjector(injectorIndex, lView, token, previousTView, flags, hostTElementNode);
if (instance !== NOT_FOUND) {
return instance;
}
}
parentLocation = lView[
injectorIndex + 8
/* NodeInjectorOffset.PARENT */
];
if (parentLocation !== NO_PARENT_INJECTOR && shouldSearchParent(flags, lView[TVIEW].data[
injectorIndex + 8
/* NodeInjectorOffset.TNODE */
] === hostTElementNode) && bloomHasToken(bloomHash, injectorIndex, lView)) {
previousTView = tView;
injectorIndex = getParentInjectorIndex(parentLocation);
lView = getParentInjectorView(parentLocation, lView);
} else {
injectorIndex = -1;
}
}
}
return notFoundValue;
}
function searchTokensOnInjector(injectorIndex, lView, token, previousTView, flags, hostTElementNode) {
const currentTView = lView[TVIEW];
const tNode = currentTView.data[
injectorIndex + 8
/* NodeInjectorOffset.TNODE */
];
const canAccessViewProviders = previousTView == null ? (
// 1) This is the first invocation `previousTView == null` which means that we are at the
// `TNode` of where injector is starting to look. In such a case the only time we are allowed
// to look into the ViewProviders is if:
// - we are on a component
// - AND the injector set `includeViewProviders` to true (implying that the token can see
// ViewProviders because it is the Component or a Service which itself was declared in
// ViewProviders)
isComponentHost(tNode) && includeViewProviders
) : (
// 2) `previousTView != null` which means that we are now walking across the parent nodes.
// In such a case we are only allowed to look into the ViewProviders if:
// - We just crossed from child View to Parent View `previousTView != currentTView`
// - AND the parent TNode is an Element.
// This means that we just came from the Component's View and therefore are allowed to see
// into the ViewProviders.
previousTView != currentTView && (tNode.type & 3) !== 0
);
const isHostSpecialCase = flags & InjectFlags.Host && hostTElementNode === tNode;
const injectableIdx = locateDirectiveOrProvider(tNode, currentTView, token, canAccessViewProviders, isHostSpecialCase);
if (injectableIdx !== null) {
return getNodeInjectable(lView, currentTView, injectableIdx, tNode);
} else {
return NOT_FOUND;
}
}
function locateDirectiveOrProvider(tNode, tView, token, canAccessViewProviders, isHostSpecialCase) {
const nodeProviderIndexes = tNode.providerIndexes;
const tInjectables = tView.data;
const injectablesStart = nodeProviderIndexes & 1048575;
const directivesStart = tNode.directiveStart;
const directiveEnd = tNode.directiveEnd;
const cptViewProvidersCount = nodeProviderIndexes >> 20;
const startingIndex = canAccessViewProviders ? injectablesStart : injectablesStart + cptViewProvidersCount;
const endIndex = isHostSpecialCase ? injectablesStart + cptViewProvidersCount : directiveEnd;
for (let i = startingIndex; i < endIndex; i++) {
const providerTokenOrDef = tInjectables[i];
if (i < directivesStart && token === providerTokenOrDef || i >= directivesStart && providerTokenOrDef.type === token) {
return i;
}
}
if (isHostSpecialCase) {
const dirDef = tInjectables[directivesStart];
if (dirDef && isComponentDef(dirDef) && dirDef.type === token) {
return directivesStart;
}
}
return null;
}
function getNodeInjectable(lView, tView, index2, tNode) {
let value2 = lView[index2];
const tData = tView.data;
if (isFactory(value2)) {
const factory = value2;
if (factory.resolving) {
throwCyclicDependencyError(stringifyForError(tData[index2]));
}
const previousIncludeViewProviders = setIncludeViewProviders(factory.canSeeViewProviders);
factory.resolving = true;
let prevInjectContext;
if (ngDevMode) {
const token = tData[index2].type || tData[index2];
const injector = new NodeInjector(tNode, lView);
prevInjectContext = setInjectorProfilerContext({ injector, token });
}
const previousInjectImplementation = factory.injectImpl ? setInjectImplementation(factory.injectImpl) : null;
const success = enterDI(lView, tNode, InjectFlags.Default);
ngDevMode && assertEqual(success, true, "Because flags do not contain `SkipSelf' we expect this to always succeed.");
try {
value2 = lView[index2] = factory.factory(void 0, tData, lView, tNode);
ngDevMode && emitInstanceCreatedByInjectorEvent(value2);
if (tView.firstCreatePass && index2 >= tNode.directiveStart) {
ngDevMode && assertDirectiveDef(tData[index2]);
registerPreOrderHooks(index2, tData[index2], tView);
}
} finally {
ngDevMode && setInjectorProfilerContext(prevInjectContext);
previousInjectImplementation !== null && setInjectImplementation(previousInjectImplementation);
setIncludeViewProviders(previousIncludeViewProviders);
factory.resolving = false;
leaveDI();
}
}
return value2;
}
function bloomHashBitOrFactory(token) {
ngDevMode && assertDefined(token, "token must be defined");
if (typeof token === "string") {
return token.charCodeAt(0) || 0;
}
const tokenId = (
// First check with `hasOwnProperty` so we don't get an inherited ID.
token.hasOwnProperty(NG_ELEMENT_ID) ? token[NG_ELEMENT_ID] : void 0
);
if (typeof tokenId === "number") {
if (tokenId >= 0) {
return tokenId & BLOOM_MASK;
} else {
ngDevMode && assertEqual(tokenId, -1, "Expecting to get Special Injector Id");
return createNodeInjector;
}
} else {
return tokenId;
}
}
function bloomHasToken(bloomHash, injectorIndex, injectorView) {
const mask2 = 1 << bloomHash;
const value2 = injectorView[injectorIndex + (bloomHash >> BLOOM_BUCKET_BITS)];
return !!(value2 & mask2);
}
function shouldSearchParent(flags, isFirstHostTNode) {
return !(flags & InjectFlags.Self) && !(flags & InjectFlags.Host && isFirstHostTNode);
}
function getNodeInjectorLView(nodeInjector) {
return nodeInjector._lView;
}
function getNodeInjectorTNode(nodeInjector) {
return nodeInjector._tNode;
}
var NodeInjector = class {
constructor(_tNode, _lView) {
this._tNode = _tNode;
this._lView = _lView;
}
get(token, notFoundValue, flags) {
return getOrCreateInjectable(this._tNode, this._lView, token, convertToBitFlags(flags), notFoundValue);
}
};
function createNodeInjector() {
return new NodeInjector(getCurrentTNode(), getLView());
}
function \u0275\u0275getInheritedFactory(type) {
return noSideEffects(() => {
const ownConstructor = type.prototype.constructor;
const ownFactory = ownConstructor[NG_FACTORY_DEF] || getFactoryOf(ownConstructor);
const objectPrototype = Object.prototype;
let parent2 = Object.getPrototypeOf(type.prototype).constructor;
while (parent2 && parent2 !== objectPrototype) {
const factory = parent2[NG_FACTORY_DEF] || getFactoryOf(parent2);
if (factory && factory !== ownFactory) {
return factory;
}
parent2 = Object.getPrototypeOf(parent2);
}
return (t) => new t();
});
}
function getFactoryOf(type) {
if (isForwardRef(type)) {
return () => {
const factory = getFactoryOf(resolveForwardRef(type));
return factory && factory();
};
}
return getFactoryDef(type);
}
function lookupTokenUsingEmbeddedInjector(tNode, lView, token, flags, notFoundValue) {
let currentTNode = tNode;
let currentLView = lView;
while (currentTNode !== null && currentLView !== null && currentLView[FLAGS] & 2048 && !(currentLView[FLAGS] & 512)) {
ngDevMode && assertTNodeForLView(currentTNode, currentLView);
const nodeInjectorValue = lookupTokenUsingNodeInjector(currentTNode, currentLView, token, flags | InjectFlags.Self, NOT_FOUND);
if (nodeInjectorValue !== NOT_FOUND) {
return nodeInjectorValue;
}
let parentTNode = currentTNode.parent;
if (!parentTNode) {
const embeddedViewInjector = currentLView[EMBEDDED_VIEW_INJECTOR];
if (embeddedViewInjector) {
const embeddedViewInjectorValue = embeddedViewInjector.get(token, NOT_FOUND, flags);
if (embeddedViewInjectorValue !== NOT_FOUND) {
return embeddedViewInjectorValue;
}
}
parentTNode = getTNodeFromLView(currentLView);
currentLView = currentLView[DECLARATION_VIEW];
}
currentTNode = parentTNode;
}
return notFoundValue;
}
function getTNodeFromLView(lView) {
const tView = lView[TVIEW];
const tViewType = tView.type;
if (tViewType === 2) {
ngDevMode && assertDefined(tView.declTNode, "Embedded TNodes should have declaration parents.");
return tView.declTNode;
} else if (tViewType === 1) {
return lView[T_HOST];
}
return null;
}
function \u0275\u0275injectAttribute(attrNameToInject) {
return injectAttributeImpl(getCurrentTNode(), attrNameToInject);
}
var Attribute = makeParamDecorator("Attribute", (attributeName) => ({ attributeName, __NG_ELEMENT_ID__: () => \u0275\u0275injectAttribute(attributeName) }));
var _reflect = null;
function getReflect() {
return _reflect = _reflect || new ReflectionCapabilities();
}
function reflectDependencies(type) {
return convertDependencies(getReflect().parameters(type));
}
function convertDependencies(deps) {
return deps.map((dep) => reflectDependency(dep));
}
function reflectDependency(dep) {
const meta = {
token: null,
attribute: null,
host: false,
optional: false,
self: false,
skipSelf: false
};
if (Array.isArray(dep) && dep.length > 0) {
for (let j = 0; j < dep.length; j++) {
const param = dep[j];
if (param === void 0) {
continue;
}
const proto = Object.getPrototypeOf(param);
if (param instanceof Optional || proto.ngMetadataName === "Optional") {
meta.optional = true;
} else if (param instanceof SkipSelf || proto.ngMetadataName === "SkipSelf") {
meta.skipSelf = true;
} else if (param instanceof Self || proto.ngMetadataName === "Self") {
meta.self = true;
} else if (param instanceof Host || proto.ngMetadataName === "Host") {
meta.host = true;
} else if (param instanceof Inject) {
meta.token = param.token;
} else if (param instanceof Attribute) {
if (param.attributeName === void 0) {
throw new RuntimeError(204, ngDevMode && `Attribute name must be defined.`);
}
meta.attribute = param.attributeName;
} else {
meta.token = param;
}
}
} else if (dep === void 0 || Array.isArray(dep) && dep.length === 0) {
meta.token = null;
} else {
meta.token = dep;
}
return meta;
}
function compileInjectable(type, meta) {
let ngInjectableDef = null;
let ngFactoryDef = null;
if (!type.hasOwnProperty(NG_PROV_DEF)) {
Object.defineProperty(type, NG_PROV_DEF, {
get: () => {
if (ngInjectableDef === null) {
const compiler = getCompilerFacade({ usage: 0, kind: "injectable", type });
ngInjectableDef = compiler.compileInjectable(angularCoreDiEnv, `ng:///${type.name}/\u0275prov.js`, getInjectableMetadata(type, meta));
}
return ngInjectableDef;
}
});
}
if (!type.hasOwnProperty(NG_FACTORY_DEF)) {
Object.defineProperty(type, NG_FACTORY_DEF, {
get: () => {
if (ngFactoryDef === null) {
const compiler = getCompilerFacade({ usage: 0, kind: "injectable", type });
ngFactoryDef = compiler.compileFactory(angularCoreDiEnv, `ng:///${type.name}/\u0275fac.js`, {
name: type.name,
type,
typeArgumentCount: 0,
// In JIT mode types are not available nor used.
deps: reflectDependencies(type),
target: compiler.FactoryTarget.Injectable
});
}
return ngFactoryDef;
},
// Leave this configurable so that the factories from directives or pipes can take precedence.
configurable: true
});
}
}
var USE_VALUE = getClosureSafeProperty({ provide: String, useValue: getClosureSafeProperty });
function isUseClassProvider(meta) {
return meta.useClass !== void 0;
}
function isUseValueProvider(meta) {
return USE_VALUE in meta;
}
function isUseFactoryProvider(meta) {
return meta.useFactory !== void 0;
}
function isUseExistingProvider(meta) {
return meta.useExisting !== void 0;
}
function getInjectableMetadata(type, srcMeta) {
const meta = srcMeta || { providedIn: null };
const compilerMeta = {
name: type.name,
type,
typeArgumentCount: 0,
providedIn: meta.providedIn
};
if ((isUseClassProvider(meta) || isUseFactoryProvider(meta)) && meta.deps !== void 0) {
compilerMeta.deps = convertDependencies(meta.deps);
}
if (isUseClassProvider(meta)) {
compilerMeta.useClass = meta.useClass;
} else if (isUseValueProvider(meta)) {
compilerMeta.useValue = meta.useValue;
} else if (isUseFactoryProvider(meta)) {
compilerMeta.useFactory = meta.useFactory;
} else if (isUseExistingProvider(meta)) {
compilerMeta.useExisting = meta.useExisting;
}
return compilerMeta;
}
var Injectable = makeDecorator("Injectable", void 0, void 0, void 0, (type, meta) => compileInjectable(type, meta));
function createInjector(defType, parent2 = null, additionalProviders = null, name2) {
const injector = createInjectorWithoutInjectorInstances(defType, parent2, additionalProviders, name2);
injector.resolveInjectorInitializers();
return injector;
}
function createInjectorWithoutInjectorInstances(defType, parent2 = null, additionalProviders = null, name2, scopes = /* @__PURE__ */ new Set()) {
const providers = [
additionalProviders || EMPTY_ARRAY,
importProvidersFrom(defType)
];
name2 = name2 || (typeof defType === "object" ? void 0 : stringify(defType));
return new R3Injector(providers, parent2 || getNullInjector(), name2 || null, scopes);
}
var _Injector = class _Injector {
static create(options, parent2) {
if (Array.isArray(options)) {
return createInjector({ name: "" }, parent2, options, "");
} else {
const name2 = options.name ?? "";
return createInjector({ name: name2 }, options.parent, options.providers, name2);
}
}
};
_Injector.THROW_IF_NOT_FOUND = THROW_IF_NOT_FOUND;
_Injector.NULL = /* @__PURE__ */ new NullInjector();
_Injector.\u0275prov = \u0275\u0275defineInjectable({
token: _Injector,
providedIn: "any",
factory: () => \u0275\u0275inject(INJECTOR$1)
});
_Injector.__NG_ELEMENT_ID__ = -1;
var Injector = _Injector;
var ERROR_ORIGINAL_ERROR = "ngOriginalError";
function getOriginalError(error) {
return error[ERROR_ORIGINAL_ERROR];
}
var ErrorHandler = class {
constructor() {
this._console = console;
}
handleError(error) {
const originalError = this._findOriginalError(error);
this._console.error("ERROR", error);
if (originalError) {
this._console.error("ORIGINAL ERROR", originalError);
}
}
/** @internal */
_findOriginalError(error) {
let e = error && getOriginalError(error);
while (e && getOriginalError(e)) {
e = getOriginalError(e);
}
return e || null;
}
};
var INTERNAL_APPLICATION_ERROR_HANDLER = new InjectionToken(typeof ngDevMode === "undefined" || ngDevMode ? "internal error handler" : "", {
providedIn: "root",
factory: () => {
const userErrorHandler = inject(ErrorHandler);
return userErrorHandler.handleError.bind(void 0);
}
});
var _DestroyRef = class _DestroyRef {
};
_DestroyRef.__NG_ELEMENT_ID__ = injectDestroyRef;
_DestroyRef.__NG_ENV_ID__ = (injector) => injector;
var DestroyRef = _DestroyRef;
var NodeInjectorDestroyRef = class extends DestroyRef {
constructor(_lView) {
super();
this._lView = _lView;
}
onDestroy(callback) {
storeLViewOnDestroy(this._lView, callback);
return () => removeLViewOnDestroy(this._lView, callback);
}
};
function injectDestroyRef() {
return new NodeInjectorDestroyRef(getLView());
}
var OutputEmitterRef = class {
constructor() {
this.destroyed = false;
this.listeners = null;
this.errorHandler = inject(ErrorHandler, { optional: true });
this.destroyRef = inject(DestroyRef);
this.destroyRef.onDestroy(() => {
this.destroyed = true;
this.listeners = null;
});
}
subscribe(callback) {
if (this.destroyed) {
throw new RuntimeError(953, ngDevMode && "Unexpected subscription to destroyed `OutputRef`. The owning directive/component is destroyed.");
}
(this.listeners ??= []).push(callback);
return {
unsubscribe: () => {
const idx = this.listeners?.indexOf(callback);
if (idx !== void 0 && idx !== -1) {
this.listeners?.splice(idx, 1);
}
}
};
}
/** Emits a new value to the output. */
emit(value2) {
if (this.destroyed) {
throw new RuntimeError(953, ngDevMode && "Unexpected emit for destroyed `OutputRef`. The owning directive/component is destroyed.");
}
if (this.listeners === null) {
return;
}
const previousConsumer = setActiveConsumer(null);
try {
for (const listenerFn of this.listeners) {
try {
listenerFn(value2);
} catch (err) {
this.errorHandler?.handleError(err);
}
}
} finally {
setActiveConsumer(previousConsumer);
}
}
};
function inputFunction(initialValue, opts) {
ngDevMode && assertInInjectionContext(input);
return createInputSignal(initialValue, opts);
}
function inputRequiredFunction(opts) {
ngDevMode && assertInInjectionContext(input);
return createInputSignal(REQUIRED_UNSET_VALUE, opts);
}
var input = (() => {
inputFunction.required = inputRequiredFunction;
return inputFunction;
})();
function injectElementRef() {
return createElementRef(getCurrentTNode(), getLView());
}
function createElementRef(tNode, lView) {
return new ElementRef(getNativeByTNode(tNode, lView));
}
var _ElementRef = class _ElementRef {
constructor(nativeElement) {
this.nativeElement = nativeElement;
}
};
_ElementRef.__NG_ELEMENT_ID__ = injectElementRef;
var ElementRef = _ElementRef;
function unwrapElementRef(value2) {
return value2 instanceof ElementRef ? value2.nativeElement : value2;
}
var EventEmitter_ = class extends Subject {
constructor(isAsync = false) {
super();
this.destroyRef = void 0;
this.__isAsync = isAsync;
if (isInInjectionContext()) {
this.destroyRef = inject(DestroyRef, { optional: true }) ?? void 0;
}
}
emit(value2) {
const prevConsumer = setActiveConsumer(null);
try {
super.next(value2);
} finally {
setActiveConsumer(prevConsumer);
}
}
subscribe(observerOrNext, error, complete) {
let nextFn = observerOrNext;
let errorFn = error || (() => null);
let completeFn = complete;
if (observerOrNext && typeof observerOrNext === "object") {
const observer = observerOrNext;
nextFn = observer.next?.bind(observer);
errorFn = observer.error?.bind(observer);
completeFn = observer.complete?.bind(observer);
}
if (this.__isAsync) {
errorFn = _wrapInTimeout(errorFn);
if (nextFn) {
nextFn = _wrapInTimeout(nextFn);
}
if (completeFn) {
completeFn = _wrapInTimeout(completeFn);
}
}
const sink = super.subscribe({ next: nextFn, error: errorFn, complete: completeFn });
if (observerOrNext instanceof Subscription) {
observerOrNext.add(sink);
}
return sink;
}
};
function _wrapInTimeout(fn) {
return (value2) => {
setTimeout(fn, void 0, value2);
};
}
var EventEmitter = EventEmitter_;
function symbolIterator() {
return this._results[Symbol.iterator]();
}
var _QueryList = class _QueryList {
/**
* Returns `Observable` of `QueryList` notifying the subscriber of changes.
*/
get changes() {
return this._changes ??= new EventEmitter();
}
/**
* @param emitDistinctChangesOnly Whether `QueryList.changes` should fire only when actual change
* has occurred. Or if it should fire when query is recomputed. (recomputing could resolve in
* the same result)
*/
constructor(_emitDistinctChangesOnly = false) {
this._emitDistinctChangesOnly = _emitDistinctChangesOnly;
this.dirty = true;
this._onDirty = void 0;
this._results = [];
this._changesDetected = false;
this._changes = void 0;
this.length = 0;
this.first = void 0;
this.last = void 0;
const proto = _QueryList.prototype;
if (!proto[Symbol.iterator])
proto[Symbol.iterator] = symbolIterator;
}
/**
* Returns the QueryList entry at `index`.
*/
get(index2) {
return this._results[index2];
}
/**
* See
* [Array.map](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map)
*/
map(fn) {
return this._results.map(fn);
}
filter(fn) {
return this._results.filter(fn);
}
/**
* See
* [Array.find](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/find)
*/
find(fn) {
return this._results.find(fn);
}
/**
* See
* [Array.reduce](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce)
*/
reduce(fn, init) {
return this._results.reduce(fn, init);
}
/**
* See
* [Array.forEach](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach)
*/
forEach(fn) {
this._results.forEach(fn);
}
/**
* See
* [Array.some](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/some)
*/
some(fn) {
return this._results.some(fn);
}
/**
* Returns a copy of the internal results list as an Array.
*/
toArray() {
return this._results.slice();
}
toString() {
return this._results.toString();
}
/**
* Updates the stored data of the query list, and resets the `dirty` flag to `false`, so that
* on change detection, it will not notify of changes to the queries, unless a new change
* occurs.
*
* @param resultsTree The query results to store
* @param identityAccessor Optional function for extracting stable object identity from a value
* in the array. This function is executed for each element of the query result list while
* comparing current query list with the new one (provided as a first argument of the `reset`
* function) to detect if the lists are different. If the function is not provided, elements
* are compared as is (without any pre-processing).
*/
reset(resultsTree, identityAccessor) {
this.dirty = false;
const newResultFlat = flatten(resultsTree);
if (this._changesDetected = !arrayEquals(this._results, newResultFlat, identityAccessor)) {
this._results = newResultFlat;
this.length = newResultFlat.length;
this.last = newResultFlat[this.length - 1];
this.first = newResultFlat[0];
}
}
/**
* Triggers a change event by emitting on the `changes` {@link EventEmitter}.
*/
notifyOnChanges() {
if (this._changes !== void 0 && (this._changesDetected || !this._emitDistinctChangesOnly))
this._changes.emit(this);
}
/** @internal */
onDirty(cb) {
this._onDirty = cb;
}
/** internal */
setDirty() {
this.dirty = true;
this._onDirty?.();
}
/** internal */
destroy() {
if (this._changes !== void 0) {
this._changes.complete();
this._changes.unsubscribe();
}
}
};
Symbol.iterator;
var QueryList = _QueryList;
function hasInSkipHydrationBlockFlag(tNode) {
return (tNode.flags & 128) === 128;
}
var TRACKED_LVIEWS = /* @__PURE__ */ new Map();
var uniqueIdCounter = 0;
function getUniqueLViewId() {
return uniqueIdCounter++;
}
function registerLView(lView) {
ngDevMode && assertNumber(lView[ID], "LView must have an ID in order to be registered");
TRACKED_LVIEWS.set(lView[ID], lView);
}
function getLViewById(id) {
ngDevMode && assertNumber(id, "ID used for LView lookup must be a number");
return TRACKED_LVIEWS.get(id) || null;
}
function unregisterLView(lView) {
ngDevMode && assertNumber(lView[ID], "Cannot stop tracking an LView that does not have an ID");
TRACKED_LVIEWS.delete(lView[ID]);
}
var LContext = class {
/** Component's parent view data. */
get lView() {
return getLViewById(this.lViewId);
}
constructor(lViewId, nodeIndex, native) {
this.lViewId = lViewId;
this.nodeIndex = nodeIndex;
this.native = native;
}
};
function getLContext(target) {
let mpValue = readPatchedData(target);
if (mpValue) {
if (isLView(mpValue)) {
const lView = mpValue;
let nodeIndex;
let component = void 0;
let directives = void 0;
if (isComponentInstance(target)) {
nodeIndex = findViaComponent(lView, target);
if (nodeIndex == -1) {
throw new Error("The provided component was not found in the application");
}
component = target;
} else if (isDirectiveInstance(target)) {
nodeIndex = findViaDirective(lView, target);
if (nodeIndex == -1) {
throw new Error("The provided directive was not found in the application");
}
directives = getDirectivesAtNodeIndex(nodeIndex, lView);
} else {
nodeIndex = findViaNativeElement(lView, target);
if (nodeIndex == -1) {
return null;
}
}
const native = unwrapRNode(lView[nodeIndex]);
const existingCtx = readPatchedData(native);
const context2 = existingCtx && !Array.isArray(existingCtx) ? existingCtx : createLContext(lView, nodeIndex, native);
if (component && context2.component === void 0) {
context2.component = component;
attachPatchData(context2.component, context2);
}
if (directives && context2.directives === void 0) {
context2.directives = directives;
for (let i = 0; i < directives.length; i++) {
attachPatchData(directives[i], context2);
}
}
attachPatchData(context2.native, context2);
mpValue = context2;
}
} else {
const rElement = target;
ngDevMode && assertDomNode(rElement);
let parent2 = rElement;
while (parent2 = parent2.parentNode) {
const parentContext = readPatchedData(parent2);
if (parentContext) {
const lView = Array.isArray(parentContext) ? parentContext : parentContext.lView;
if (!lView) {
return null;
}
const index2 = findViaNativeElement(lView, rElement);
if (index2 >= 0) {
const native = unwrapRNode(lView[index2]);
const context2 = createLContext(lView, index2, native);
attachPatchData(native, context2);
mpValue = context2;
break;
}
}
}
}
return mpValue || null;
}
function createLContext(lView, nodeIndex, native) {
return new LContext(lView[ID], nodeIndex, native);
}
function getComponentViewByInstance(componentInstance) {
let patchedData = readPatchedData(componentInstance);
let lView;
if (isLView(patchedData)) {
const contextLView = patchedData;
const nodeIndex = findViaComponent(contextLView, componentInstance);
lView = getComponentLViewByIndex(nodeIndex, contextLView);
const context2 = createLContext(contextLView, nodeIndex, lView[HOST]);
context2.component = componentInstance;
attachPatchData(componentInstance, context2);
attachPatchData(context2.native, context2);
} else {
const context2 = patchedData;
const contextLView = context2.lView;
ngDevMode && assertLView(contextLView);
lView = getComponentLViewByIndex(context2.nodeIndex, contextLView);
}
return lView;
}
var MONKEY_PATCH_KEY_NAME = "__ngContext__";
function attachPatchData(target, data2) {
ngDevMode && assertDefined(target, "Target expected");
if (isLView(data2)) {
target[MONKEY_PATCH_KEY_NAME] = data2[ID];
registerLView(data2);
} else {
target[MONKEY_PATCH_KEY_NAME] = data2;
}
}
function readPatchedData(target) {
ngDevMode && assertDefined(target, "Target expected");
const data2 = target[MONKEY_PATCH_KEY_NAME];
return typeof data2 === "number" ? getLViewById(data2) : data2 || null;
}
function readPatchedLView(target) {
const value2 = readPatchedData(target);
if (value2) {
return isLView(value2) ? value2 : value2.lView;
}
return null;
}
function isComponentInstance(instance) {
return instance && instance.constructor && instance.constructor.\u0275cmp;
}
function isDirectiveInstance(instance) {
return instance && instance.constructor && instance.constructor.\u0275dir;
}
function findViaNativeElement(lView, target) {
const tView = lView[TVIEW];
for (let i = HEADER_OFFSET; i < tView.bindingStartIndex; i++) {
if (unwrapRNode(lView[i]) === target) {
return i;
}
}
return -1;
}
function traverseNextElement(tNode) {
if (tNode.child) {
return tNode.child;
} else if (tNode.next) {
return tNode.next;
} else {
while (tNode.parent && !tNode.parent.next) {
tNode = tNode.parent;
}
return tNode.parent && tNode.parent.next;
}
}
function findViaComponent(lView, componentInstance) {
const componentIndices = lView[TVIEW].components;
if (componentIndices) {
for (let i = 0; i < componentIndices.length; i++) {
const elementComponentIndex = componentIndices[i];
const componentView = getComponentLViewByIndex(elementComponentIndex, lView);
if (componentView[CONTEXT] === componentInstance) {
return elementComponentIndex;
}
}
} else {
const rootComponentView = getComponentLViewByIndex(HEADER_OFFSET, lView);
const rootComponent = rootComponentView[CONTEXT];
if (rootComponent === componentInstance) {
return HEADER_OFFSET;
}
}
return -1;
}
function findViaDirective(lView, directiveInstance) {
let tNode = lView[TVIEW].firstChild;
while (tNode) {
const directiveIndexStart = tNode.directiveStart;
const directiveIndexEnd = tNode.directiveEnd;
for (let i = directiveIndexStart; i < directiveIndexEnd; i++) {
if (lView[i] === directiveInstance) {
return tNode.index;
}
}
tNode = traverseNextElement(tNode);
}
return -1;
}
function getDirectivesAtNodeIndex(nodeIndex, lView) {
const tNode = lView[TVIEW].data[nodeIndex];
if (tNode.directiveStart === 0)
return EMPTY_ARRAY;
const results = [];
for (let i = tNode.directiveStart; i < tNode.directiveEnd; i++) {
const directiveInstance = lView[i];
if (!isComponentInstance(directiveInstance)) {
results.push(directiveInstance);
}
}
return results;
}
function getComponentAtNodeIndex(nodeIndex, lView) {
const tNode = lView[TVIEW].data[nodeIndex];
const { directiveStart, componentOffset } = tNode;
return componentOffset > -1 ? lView[directiveStart + componentOffset] : null;
}
function getRootView(componentOrLView) {
ngDevMode && assertDefined(componentOrLView, "component");
let lView = isLView(componentOrLView) ? componentOrLView : readPatchedLView(componentOrLView);
while (lView && !(lView[FLAGS] & 512)) {
lView = getLViewParent(lView);
}
ngDevMode && assertLView(lView);
return lView;
}
function getRootContext(viewOrComponent) {
const rootView = getRootView(viewOrComponent);
ngDevMode && assertDefined(rootView[CONTEXT], "Root view has no context. Perhaps it is disconnected?");
return rootView[CONTEXT];
}
function getFirstLContainer(lView) {
return getNearestLContainer(lView[CHILD_HEAD]);
}
function getNextLContainer(container) {
return getNearestLContainer(container[NEXT]);
}
function getNearestLContainer(viewOrContainer) {
while (viewOrContainer !== null && !isLContainer(viewOrContainer)) {
viewOrContainer = viewOrContainer[NEXT];
}
return viewOrContainer;
}
function getComponent$1(element) {
ngDevMode && assertDomElement(element);
const context2 = getLContext(element);
if (context2 === null)
return null;
if (context2.component === void 0) {
const lView = context2.lView;
if (lView === null) {
return null;
}
context2.component = getComponentAtNodeIndex(context2.nodeIndex, lView);
}
return context2.component;
}
function getContext(element) {
assertDomElement(element);
const context2 = getLContext(element);
const lView = context2 ? context2.lView : null;
return lView === null ? null : lView[CONTEXT];
}
function getOwningComponent(elementOrDir) {
const context2 = getLContext(elementOrDir);
let lView = context2 ? context2.lView : null;
if (lView === null)
return null;
let parent2;
while (lView[TVIEW].type === 2 && (parent2 = getLViewParent(lView))) {
lView = parent2;
}
return lView[FLAGS] & 512 ? null : lView[CONTEXT];
}
function getRootComponents(elementOrDir) {
const lView = readPatchedLView(elementOrDir);
return lView !== null ? [getRootContext(lView)] : [];
}
function getInjector(elementOrDir) {
const context2 = getLContext(elementOrDir);
const lView = context2 ? context2.lView : null;
if (lView === null)
return Injector.NULL;
const tNode = lView[TVIEW].data[context2.nodeIndex];
return new NodeInjector(tNode, lView);
}
function getDirectives(node) {
if (node instanceof Text) {
return [];
}
const context2 = getLContext(node);
const lView = context2 ? context2.lView : null;
if (lView === null) {
return [];
}
const tView = lView[TVIEW];
const nodeIndex = context2.nodeIndex;
if (!tView?.data[nodeIndex]) {
return [];
}
if (context2.directives === void 0) {
context2.directives = getDirectivesAtNodeIndex(nodeIndex, lView);
}
return context2.directives === null ? [] : [...context2.directives];
}
function getDirectiveMetadata$1(directiveOrComponentInstance) {
const { constructor } = directiveOrComponentInstance;
if (!constructor) {
throw new Error("Unable to find the instance constructor");
}
const componentDef = getComponentDef(constructor);
if (componentDef) {
const inputs = extractInputDebugMetadata(componentDef.inputs);
return {
inputs,
outputs: componentDef.outputs,
encapsulation: componentDef.encapsulation,
changeDetection: componentDef.onPush ? ChangeDetectionStrategy.OnPush : ChangeDetectionStrategy.Default
};
}
const directiveDef = getDirectiveDef(constructor);
if (directiveDef) {
const inputs = extractInputDebugMetadata(directiveDef.inputs);
return { inputs, outputs: directiveDef.outputs };
}
return null;
}
function getHostElement(componentOrDirective) {
return getLContext(componentOrDirective).native;
}
function getListeners(element) {
ngDevMode && assertDomElement(element);
const lContext = getLContext(element);
const lView = lContext === null ? null : lContext.lView;
if (lView === null)
return [];
const tView = lView[TVIEW];
const lCleanup = lView[CLEANUP];
const tCleanup = tView.cleanup;
const listeners = [];
if (tCleanup && lCleanup) {
for (let i = 0; i < tCleanup.length; ) {
const firstParam = tCleanup[i++];
const secondParam = tCleanup[i++];
if (typeof firstParam === "string") {
const name2 = firstParam;
const listenerElement = unwrapRNode(lView[secondParam]);
const callback = lCleanup[tCleanup[i++]];
const useCaptureOrIndx = tCleanup[i++];
const type = typeof useCaptureOrIndx === "boolean" || useCaptureOrIndx >= 0 ? "dom" : "output";
const useCapture = typeof useCaptureOrIndx === "boolean" ? useCaptureOrIndx : false;
if (element == listenerElement) {
listeners.push({ element, name: name2, callback, useCapture, type });
}
}
}
}
listeners.sort(sortListeners);
return listeners;
}
function sortListeners(a, b) {
if (a.name == b.name)
return 0;
return a.name < b.name ? -1 : 1;
}
function assertDomElement(value2) {
if (typeof Element !== "undefined" && !(value2 instanceof Element)) {
throw new Error("Expecting instance of DOM Element");
}
}
function extractInputDebugMetadata(inputs) {
const res = {};
for (const key2 in inputs) {
if (!inputs.hasOwnProperty(key2)) {
continue;
}
const value2 = inputs[key2];
if (value2 === void 0) {
continue;
}
let minifiedName;
if (Array.isArray(value2)) {
minifiedName = value2[0];
} else {
minifiedName = value2;
}
res[key2] = minifiedName;
}
return res;
}
var DOCUMENT = void 0;
function setDocument(document2) {
DOCUMENT = document2;
}
function getDocument() {
if (DOCUMENT !== void 0) {
return DOCUMENT;
} else if (typeof document !== "undefined") {
return document;
}
throw new RuntimeError(210, (typeof ngDevMode === "undefined" || ngDevMode) && `The document object is not available in this context. Make sure the DOCUMENT injection token is provided.`);
}
var APP_ID = new InjectionToken(ngDevMode ? "AppId" : "", {
providedIn: "root",
factory: () => DEFAULT_APP_ID
});
var DEFAULT_APP_ID = "ng";
var PLATFORM_INITIALIZER = new InjectionToken(ngDevMode ? "Platform Initializer" : "");
var PLATFORM_ID = new InjectionToken(ngDevMode ? "Platform ID" : "", {
providedIn: "platform",
factory: () => "unknown"
// set a default platform name, when none set explicitly
});
var PACKAGE_ROOT_URL = new InjectionToken(ngDevMode ? "Application Packages Root URL" : "");
var ANIMATION_MODULE_TYPE = new InjectionToken(ngDevMode ? "AnimationModuleType" : "");
var CSP_NONCE = new InjectionToken(ngDevMode ? "CSP nonce" : "", {
providedIn: "root",
factory: () => {
return getDocument().body?.querySelector("[ngCspNonce]")?.getAttribute("ngCspNonce") || null;
}
});
var IMAGE_CONFIG_DEFAULTS = {
breakpoints: [16, 32, 48, 64, 96, 128, 256, 384, 640, 750, 828, 1080, 1200, 1920, 2048, 3840],
placeholderResolution: 30,
disableImageSizeWarning: false,
disableImageLazyLoadWarning: false
};
var IMAGE_CONFIG = new InjectionToken(ngDevMode ? "ImageConfig" : "", { providedIn: "root", factory: () => IMAGE_CONFIG_DEFAULTS });
function makeStateKey(key2) {
return key2;
}
function initTransferState() {
const transferState = new TransferState();
if (inject(PLATFORM_ID) === "browser") {
transferState.store = retrieveTransferredState(getDocument(), inject(APP_ID));
}
return transferState;
}
var _TransferState = class _TransferState {
constructor() {
this.store = {};
this.onSerializeCallbacks = {};
}
/**
* Get the value corresponding to a key. Return `defaultValue` if key is not found.
*/
get(key2, defaultValue) {
return this.store[key2] !== void 0 ? this.store[key2] : defaultValue;
}
/**
* Set the value corresponding to a key.
*/
set(key2, value2) {
this.store[key2] = value2;
}
/**
* Remove a key from the store.
*/
remove(key2) {
delete this.store[key2];
}
/**
* Test whether a key exists in the store.
*/
hasKey(key2) {
return this.store.hasOwnProperty(key2);
}
/**
* Indicates whether the state is empty.
*/
get isEmpty() {
return Object.keys(this.store).length === 0;
}
/**
* Register a callback to provide the value for a key when `toJson` is called.
*/
onSerialize(key2, callback) {
this.onSerializeCallbacks[key2] = callback;
}
/**
* Serialize the current state of the store to JSON.
*/
toJson() {
for (const key2 in this.onSerializeCallbacks) {
if (this.onSerializeCallbacks.hasOwnProperty(key2)) {
try {
this.store[key2] = this.onSerializeCallbacks[key2]();
} catch (e) {
console.warn("Exception in onSerialize callback: ", e);
}
}
}
return JSON.stringify(this.store).replace(/</g, "\\u003C");
}
};
_TransferState.\u0275prov = /** @pureOrBreakMyCode */
\u0275\u0275defineInjectable({
token: _TransferState,
providedIn: "root",
factory: initTransferState
});
var TransferState = _TransferState;
function retrieveTransferredState(doc, appId) {
const script = doc.getElementById(appId + "-state");
if (script?.textContent) {
try {
return JSON.parse(script.textContent);
} catch (e) {
console.warn("Exception while restoring TransferState for app " + appId, e);
}
}
return {};
}
var REFERENCE_NODE_HOST = "h";
var REFERENCE_NODE_BODY = "b";
var NodeNavigationStep;
(function(NodeNavigationStep2) {
NodeNavigationStep2["FirstChild"] = "f";
NodeNavigationStep2["NextSibling"] = "n";
})(NodeNavigationStep || (NodeNavigationStep = {}));
var TRANSFER_STATE_TOKEN_ID = "__nghData__";
var NGH_DATA_KEY = makeStateKey(TRANSFER_STATE_TOKEN_ID);
var _retrieveHydrationInfoImpl = () => null;
function retrieveHydrationInfo(rNode, injector, isRootView2 = false) {
return _retrieveHydrationInfoImpl(rNode, injector, isRootView2);
}
var HydrationStatus;
(function(HydrationStatus2) {
HydrationStatus2["Hydrated"] = "hydrated";
HydrationStatus2["Skipped"] = "skipped";
HydrationStatus2["Mismatched"] = "mismatched";
})(HydrationStatus || (HydrationStatus = {}));
var IS_HYDRATION_DOM_REUSE_ENABLED = new InjectionToken(typeof ngDevMode === "undefined" || !!ngDevMode ? "IS_HYDRATION_DOM_REUSE_ENABLED" : "");
var PRESERVE_HOST_CONTENT_DEFAULT = false;
var PRESERVE_HOST_CONTENT = new InjectionToken(typeof ngDevMode === "undefined" || !!ngDevMode ? "PRESERVE_HOST_CONTENT" : "", {
providedIn: "root",
factory: () => PRESERVE_HOST_CONTENT_DEFAULT
});
var IS_I18N_HYDRATION_ENABLED = new InjectionToken(typeof ngDevMode === "undefined" || !!ngDevMode ? "IS_I18N_HYDRATION_ENABLED" : "");
var policy$1;
function getPolicy$1() {
if (policy$1 === void 0) {
policy$1 = null;
if (_global.trustedTypes) {
try {
policy$1 = _global.trustedTypes.createPolicy("angular", {
createHTML: (s) => s,
createScript: (s) => s,
createScriptURL: (s) => s
});
} catch {
}
}
}
return policy$1;
}
function trustedHTMLFromString(html) {
return getPolicy$1()?.createHTML(html) || html;
}
function trustedScriptURLFromString(url) {
return getPolicy$1()?.createScriptURL(url) || url;
}
var policy;
function getPolicy() {
if (policy === void 0) {
policy = null;
if (_global.trustedTypes) {
try {
policy = _global.trustedTypes.createPolicy("angular#unsafe-bypass", {
createHTML: (s) => s,
createScript: (s) => s,
createScriptURL: (s) => s
});
} catch {
}
}
}
return policy;
}
function trustedHTMLFromStringBypass(html) {
return getPolicy()?.createHTML(html) || html;
}
function trustedScriptFromStringBypass(script) {
return getPolicy()?.createScript(script) || script;
}
function trustedScriptURLFromStringBypass(url) {
return getPolicy()?.createScriptURL(url) || url;
}
var SafeValueImpl = class {
constructor(changingThisBreaksApplicationSecurity) {
this.changingThisBreaksApplicationSecurity = changingThisBreaksApplicationSecurity;
}
toString() {
return `SafeValue must use [property]=binding: ${this.changingThisBreaksApplicationSecurity} (see ${XSS_SECURITY_URL})`;
}
};
var SafeHtmlImpl = class extends SafeValueImpl {
getTypeName() {
return "HTML";
}
};
var SafeStyleImpl = class extends SafeValueImpl {
getTypeName() {
return "Style";
}
};
var SafeScriptImpl = class extends SafeValueImpl {
getTypeName() {
return "Script";
}
};
var SafeUrlImpl = class extends SafeValueImpl {
getTypeName() {
return "URL";
}
};
var SafeResourceUrlImpl = class extends SafeValueImpl {
getTypeName() {
return "ResourceURL";
}
};
function unwrapSafeValue(value2) {
return value2 instanceof SafeValueImpl ? value2.changingThisBreaksApplicationSecurity : value2;
}
function allowSanitizationBypassAndThrow(value2, type) {
const actualType = getSanitizationBypassType(value2);
if (actualType != null && actualType !== type) {
if (actualType === "ResourceURL" && type === "URL")
return true;
throw new Error(`Required a safe ${type}, got a ${actualType} (see ${XSS_SECURITY_URL})`);
}
return actualType === type;
}
function getSanitizationBypassType(value2) {
return value2 instanceof SafeValueImpl && value2.getTypeName() || null;
}
function bypassSanitizationTrustHtml(trustedHtml) {
return new SafeHtmlImpl(trustedHtml);
}
function bypassSanitizationTrustStyle(trustedStyle) {
return new SafeStyleImpl(trustedStyle);
}
function bypassSanitizationTrustScript(trustedScript) {
return new SafeScriptImpl(trustedScript);
}
function bypassSanitizationTrustUrl(trustedUrl) {
return new SafeUrlImpl(trustedUrl);
}
function bypassSanitizationTrustResourceUrl(trustedResourceUrl) {
return new SafeResourceUrlImpl(trustedResourceUrl);
}
function getInertBodyHelper(defaultDoc) {
const inertDocumentHelper = new InertDocumentHelper(defaultDoc);
return isDOMParserAvailable() ? new DOMParserHelper(inertDocumentHelper) : inertDocumentHelper;
}
var DOMParserHelper = class {
constructor(inertDocumentHelper) {
this.inertDocumentHelper = inertDocumentHelper;
}
getInertBodyElement(html) {
html = "<body><remove></remove>" + html;
try {
const body = new window.DOMParser().parseFromString(trustedHTMLFromString(html), "text/html").body;
if (body === null) {
return this.inertDocumentHelper.getInertBodyElement(html);
}
body.removeChild(body.firstChild);
return body;
} catch {
return null;
}
}
};
var InertDocumentHelper = class {
constructor(defaultDoc) {
this.defaultDoc = defaultDoc;
this.inertDocument = this.defaultDoc.implementation.createHTMLDocument("sanitization-inert");
}
getInertBodyElement(html) {
const templateEl = this.inertDocument.createElement("template");
templateEl.innerHTML = trustedHTMLFromString(html);
return templateEl;
}
};
function isDOMParserAvailable() {
try {
return !!new window.DOMParser().parseFromString(trustedHTMLFromString(""), "text/html");
} catch {
return false;
}
}
var SAFE_URL_PATTERN = /^(?!javascript:)(?:[a-z0-9+.-]+:|[^&:\/?#]*(?:[\/?#]|$))/i;
function _sanitizeUrl(url) {
url = String(url);
if (url.match(SAFE_URL_PATTERN))
return url;
if (typeof ngDevMode === "undefined" || ngDevMode) {
console.warn(`WARNING: sanitizing unsafe URL value ${url} (see ${XSS_SECURITY_URL})`);
}
return "unsafe:" + url;
}
function tagSet(tags) {
const res = {};
for (const t of tags.split(","))
res[t] = true;
return res;
}
function merge(...sets) {
const res = {};
for (const s of sets) {
for (const v in s) {
if (s.hasOwnProperty(v))
res[v] = true;
}
}
return res;
}
var VOID_ELEMENTS = tagSet("area,br,col,hr,img,wbr");
var OPTIONAL_END_TAG_BLOCK_ELEMENTS = tagSet("colgroup,dd,dt,li,p,tbody,td,tfoot,th,thead,tr");
var OPTIONAL_END_TAG_INLINE_ELEMENTS = tagSet("rp,rt");
var OPTIONAL_END_TAG_ELEMENTS = merge(OPTIONAL_END_TAG_INLINE_ELEMENTS, OPTIONAL_END_TAG_BLOCK_ELEMENTS);
var BLOCK_ELEMENTS = merge(OPTIONAL_END_TAG_BLOCK_ELEMENTS, tagSet("address,article,aside,blockquote,caption,center,del,details,dialog,dir,div,dl,figure,figcaption,footer,h1,h2,h3,h4,h5,h6,header,hgroup,hr,ins,main,map,menu,nav,ol,pre,section,summary,table,ul"));
var INLINE_ELEMENTS = merge(OPTIONAL_END_TAG_INLINE_ELEMENTS, tagSet("a,abbr,acronym,audio,b,bdi,bdo,big,br,cite,code,del,dfn,em,font,i,img,ins,kbd,label,map,mark,picture,q,ruby,rp,rt,s,samp,small,source,span,strike,strong,sub,sup,time,track,tt,u,var,video"));
var VALID_ELEMENTS = merge(VOID_ELEMENTS, BLOCK_ELEMENTS, INLINE_ELEMENTS, OPTIONAL_END_TAG_ELEMENTS);
var URI_ATTRS = tagSet("background,cite,href,itemtype,longdesc,poster,src,xlink:href");
var HTML_ATTRS = tagSet("abbr,accesskey,align,alt,autoplay,axis,bgcolor,border,cellpadding,cellspacing,class,clear,color,cols,colspan,compact,controls,coords,datetime,default,dir,download,face,headers,height,hidden,hreflang,hspace,ismap,itemscope,itemprop,kind,label,lang,language,loop,media,muted,nohref,nowrap,open,preload,rel,rev,role,rows,rowspan,rules,scope,scrolling,shape,size,sizes,span,srclang,srcset,start,summary,tabindex,target,title,translate,type,usemap,valign,value,vspace,width");
var ARIA_ATTRS = tagSet("aria-activedescendant,aria-atomic,aria-autocomplete,aria-busy,aria-checked,aria-colcount,aria-colindex,aria-colspan,aria-controls,aria-current,aria-describedby,aria-details,aria-disabled,aria-dropeffect,aria-errormessage,aria-expanded,aria-flowto,aria-grabbed,aria-haspopup,aria-hidden,aria-invalid,aria-keyshortcuts,aria-label,aria-labelledby,aria-level,aria-live,aria-modal,aria-multiline,aria-multiselectable,aria-orientation,aria-owns,aria-placeholder,aria-posinset,aria-pressed,aria-readonly,aria-relevant,aria-required,aria-roledescription,aria-rowcount,aria-rowindex,aria-rowspan,aria-selected,aria-setsize,aria-sort,aria-valuemax,aria-valuemin,aria-valuenow,aria-valuetext");
var VALID_ATTRS = merge(URI_ATTRS, HTML_ATTRS, ARIA_ATTRS);
var SKIP_TRAVERSING_CONTENT_IF_INVALID_ELEMENTS = tagSet("script,style,template");
var SanitizingHtmlSerializer = class {
constructor() {
this.sanitizedSomething = false;
this.buf = [];
}
sanitizeChildren(el) {
let current = el.firstChild;
let traverseContent = true;
let parentNodes = [];
while (current) {
if (current.nodeType === Node.ELEMENT_NODE) {
traverseContent = this.startElement(current);
} else if (current.nodeType === Node.TEXT_NODE) {
this.chars(current.nodeValue);
} else {
this.sanitizedSomething = true;
}
if (traverseContent && current.firstChild) {
parentNodes.push(current);
current = getFirstChild(current);
continue;
}
while (current) {
if (current.nodeType === Node.ELEMENT_NODE) {
this.endElement(current);
}
let next = getNextSibling(current);
if (next) {
current = next;
break;
}
current = parentNodes.pop();
}
}
return this.buf.join("");
}
/**
* Sanitizes an opening element tag (if valid) and returns whether the element's contents should
* be traversed. Element content must always be traversed (even if the element itself is not
* valid/safe), unless the element is one of `SKIP_TRAVERSING_CONTENT_IF_INVALID_ELEMENTS`.
*
* @param element The element to sanitize.
* @return True if the element's contents should be traversed.
*/
startElement(element) {
const tagName = getNodeName(element).toLowerCase();
if (!VALID_ELEMENTS.hasOwnProperty(tagName)) {
this.sanitizedSomething = true;
return !SKIP_TRAVERSING_CONTENT_IF_INVALID_ELEMENTS.hasOwnProperty(tagName);
}
this.buf.push("<");
this.buf.push(tagName);
const elAttrs = element.attributes;
for (let i = 0; i < elAttrs.length; i++) {
const elAttr = elAttrs.item(i);
const attrName = elAttr.name;
const lower = attrName.toLowerCase();
if (!VALID_ATTRS.hasOwnProperty(lower)) {
this.sanitizedSomething = true;
continue;
}
let value2 = elAttr.value;
if (URI_ATTRS[lower])
value2 = _sanitizeUrl(value2);
this.buf.push(" ", attrName, '="', encodeEntities(value2), '"');
}
this.buf.push(">");
return true;
}
endElement(current) {
const tagName = getNodeName(current).toLowerCase();
if (VALID_ELEMENTS.hasOwnProperty(tagName) && !VOID_ELEMENTS.hasOwnProperty(tagName)) {
this.buf.push("</");
this.buf.push(tagName);
this.buf.push(">");
}
}
chars(chars) {
this.buf.push(encodeEntities(chars));
}
};
function isClobberedElement(parentNode, childNode) {
return (parentNode.compareDocumentPosition(childNode) & Node.DOCUMENT_POSITION_CONTAINED_BY) !== Node.DOCUMENT_POSITION_CONTAINED_BY;
}
function getNextSibling(node) {
const nextSibling = node.nextSibling;
if (nextSibling && node !== nextSibling.previousSibling) {
throw clobberedElementError(nextSibling);
}
return nextSibling;
}
function getFirstChild(node) {
const firstChild = node.firstChild;
if (firstChild && isClobberedElement(node, firstChild)) {
throw clobberedElementError(firstChild);
}
return firstChild;
}
function getNodeName(node) {
const nodeName = node.nodeName;
return typeof nodeName === "string" ? nodeName : "FORM";
}
function clobberedElementError(node) {
return new Error(`Failed to sanitize html because the element is clobbered: ${node.outerHTML}`);
}
var SURROGATE_PAIR_REGEXP = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g;
var NON_ALPHANUMERIC_REGEXP = /([^\#-~ |!])/g;
function encodeEntities(value2) {
return value2.replace(/&/g, "&").replace(SURROGATE_PAIR_REGEXP, function(match2) {
const hi = match2.charCodeAt(0);
const low = match2.charCodeAt(1);
return "&#" + ((hi - 55296) * 1024 + (low - 56320) + 65536) + ";";
}).replace(NON_ALPHANUMERIC_REGEXP, function(match2) {
return "&#" + match2.charCodeAt(0) + ";";
}).replace(/</g, "<").replace(/>/g, ">");
}
var inertBodyHelper;
function _sanitizeHtml(defaultDoc, unsafeHtmlInput) {
let inertBodyElement = null;
try {
inertBodyHelper = inertBodyHelper || getInertBodyHelper(defaultDoc);
let unsafeHtml = unsafeHtmlInput ? String(unsafeHtmlInput) : "";
inertBodyElement = inertBodyHelper.getInertBodyElement(unsafeHtml);
let mXSSAttempts = 5;
let parsedHtml = unsafeHtml;
do {
if (mXSSAttempts === 0) {
throw new Error("Failed to sanitize html because the input is unstable");
}
mXSSAttempts--;
unsafeHtml = parsedHtml;
parsedHtml = inertBodyElement.innerHTML;
inertBodyElement = inertBodyHelper.getInertBodyElement(unsafeHtml);
} while (unsafeHtml !== parsedHtml);
const sanitizer = new SanitizingHtmlSerializer();
const safeHtml = sanitizer.sanitizeChildren(getTemplateContent(inertBodyElement) || inertBodyElement);
if ((typeof ngDevMode === "undefined" || ngDevMode) && sanitizer.sanitizedSomething) {
console.warn(`WARNING: sanitizing HTML stripped some content, see ${XSS_SECURITY_URL}`);
}
return trustedHTMLFromString(safeHtml);
} finally {
if (inertBodyElement) {
const parent2 = getTemplateContent(inertBodyElement) || inertBodyElement;
while (parent2.firstChild) {
parent2.removeChild(parent2.firstChild);
}
}
}
}
function getTemplateContent(el) {
return "content" in el && isTemplateElement(el) ? el.content : null;
}
function isTemplateElement(el) {
return el.nodeType === Node.ELEMENT_NODE && el.nodeName === "TEMPLATE";
}
var SecurityContext;
(function(SecurityContext2) {
SecurityContext2[SecurityContext2["NONE"] = 0] = "NONE";
SecurityContext2[SecurityContext2["HTML"] = 1] = "HTML";
SecurityContext2[SecurityContext2["STYLE"] = 2] = "STYLE";
SecurityContext2[SecurityContext2["SCRIPT"] = 3] = "SCRIPT";
SecurityContext2[SecurityContext2["URL"] = 4] = "URL";
SecurityContext2[SecurityContext2["RESOURCE_URL"] = 5] = "RESOURCE_URL";
})(SecurityContext || (SecurityContext = {}));
function \u0275\u0275sanitizeHtml(unsafeHtml) {
const sanitizer = getSanitizer();
if (sanitizer) {
return trustedHTMLFromStringBypass(sanitizer.sanitize(SecurityContext.HTML, unsafeHtml) || "");
}
if (allowSanitizationBypassAndThrow(
unsafeHtml,
"HTML"
/* BypassType.Html */
)) {
return trustedHTMLFromStringBypass(unwrapSafeValue(unsafeHtml));
}
return _sanitizeHtml(getDocument(), renderStringify(unsafeHtml));
}
function \u0275\u0275sanitizeStyle(unsafeStyle) {
const sanitizer = getSanitizer();
if (sanitizer) {
return sanitizer.sanitize(SecurityContext.STYLE, unsafeStyle) || "";
}
if (allowSanitizationBypassAndThrow(
unsafeStyle,
"Style"
/* BypassType.Style */
)) {
return unwrapSafeValue(unsafeStyle);
}
return renderStringify(unsafeStyle);
}
function \u0275\u0275sanitizeUrl(unsafeUrl) {
const sanitizer = getSanitizer();
if (sanitizer) {
return sanitizer.sanitize(SecurityContext.URL, unsafeUrl) || "";
}
if (allowSanitizationBypassAndThrow(
unsafeUrl,
"URL"
/* BypassType.Url */
)) {
return unwrapSafeValue(unsafeUrl);
}
return _sanitizeUrl(renderStringify(unsafeUrl));
}
function \u0275\u0275sanitizeResourceUrl(unsafeResourceUrl) {
const sanitizer = getSanitizer();
if (sanitizer) {
return trustedScriptURLFromStringBypass(sanitizer.sanitize(SecurityContext.RESOURCE_URL, unsafeResourceUrl) || "");
}
if (allowSanitizationBypassAndThrow(
unsafeResourceUrl,
"ResourceURL"
/* BypassType.ResourceUrl */
)) {
return trustedScriptURLFromStringBypass(unwrapSafeValue(unsafeResourceUrl));
}
throw new RuntimeError(904, ngDevMode && `unsafe value used in a resource URL context (see ${XSS_SECURITY_URL})`);
}
function \u0275\u0275sanitizeScript(unsafeScript) {
const sanitizer = getSanitizer();
if (sanitizer) {
return trustedScriptFromStringBypass(sanitizer.sanitize(SecurityContext.SCRIPT, unsafeScript) || "");
}
if (allowSanitizationBypassAndThrow(
unsafeScript,
"Script"
/* BypassType.Script */
)) {
return trustedScriptFromStringBypass(unwrapSafeValue(unsafeScript));
}
throw new RuntimeError(905, ngDevMode && "unsafe value used in a script context");
}
function \u0275\u0275trustConstantHtml(html) {
if (ngDevMode && (!Array.isArray(html) || !Array.isArray(html.raw) || html.length !== 1)) {
throw new Error(`Unexpected interpolation in trusted HTML constant: ${html.join("?")}`);
}
return trustedHTMLFromString(html[0]);
}
function \u0275\u0275trustConstantResourceUrl(url) {
if (ngDevMode && (!Array.isArray(url) || !Array.isArray(url.raw) || url.length !== 1)) {
throw new Error(`Unexpected interpolation in trusted URL constant: ${url.join("?")}`);
}
return trustedScriptURLFromString(url[0]);
}
function getUrlSanitizer(tag, prop) {
if (prop === "src" && (tag === "embed" || tag === "frame" || tag === "iframe" || tag === "media" || tag === "script") || prop === "href" && (tag === "base" || tag === "link")) {
return \u0275\u0275sanitizeResourceUrl;
}
return \u0275\u0275sanitizeUrl;
}
function \u0275\u0275sanitizeUrlOrResourceUrl(unsafeUrl, tag, prop) {
return getUrlSanitizer(tag, prop)(unsafeUrl);
}
function validateAgainstEventProperties(name2) {
if (name2.toLowerCase().startsWith("on")) {
const errorMessage = `Binding to event property '${name2}' is disallowed for security reasons, please use (${name2.slice(2)})=...
If '${name2}' is a directive input, make sure the directive is imported by the current module.`;
throw new RuntimeError(306, errorMessage);
}
}
function validateAgainstEventAttributes(name2) {
if (name2.toLowerCase().startsWith("on")) {
const errorMessage = `Binding to event attribute '${name2}' is disallowed for security reasons, please use (${name2.slice(2)})=...`;
throw new RuntimeError(306, errorMessage);
}
}
function getSanitizer() {
const lView = getLView();
return lView && lView[ENVIRONMENT].sanitizer;
}
var COMMENT_DISALLOWED = /^>|^->|<!--|-->|--!>|<!-$/g;
var COMMENT_DELIMITER = /(<|>)/g;
var COMMENT_DELIMITER_ESCAPED = "\u200B$1\u200B";
function escapeCommentText(value2) {
return value2.replace(COMMENT_DISALLOWED, (text2) => text2.replace(COMMENT_DELIMITER, COMMENT_DELIMITER_ESCAPED));
}
function normalizeDebugBindingName(name2) {
name2 = camelCaseToDashCase(name2.replace(/[$@]/g, "_"));
return `ng-reflect-${name2}`;
}
var CAMEL_CASE_REGEXP = /([A-Z])/g;
function camelCaseToDashCase(input2) {
return input2.replace(CAMEL_CASE_REGEXP, (...m) => "-" + m[1].toLowerCase());
}
function normalizeDebugBindingValue(value2) {
try {
return value2 != null ? value2.toString().slice(0, 30) : value2;
} catch (e) {
return "[ERROR] Exception while trying to serialize the value";
}
}
var CUSTOM_ELEMENTS_SCHEMA = {
name: "custom-elements"
};
var NO_ERRORS_SCHEMA = {
name: "no-errors-schema"
};
var shouldThrowErrorOnUnknownElement = false;
var shouldThrowErrorOnUnknownProperty = false;
function validateElementIsKnown(element, lView, tagName, schemas, hasDirectives) {
if (schemas === null)
return;
if (!hasDirectives && tagName !== null) {
const isUnknown = (
// Note that we can't check for `typeof HTMLUnknownElement === 'function'` because
// Domino doesn't expose HTMLUnknownElement globally.
typeof HTMLUnknownElement !== "undefined" && HTMLUnknownElement && element instanceof HTMLUnknownElement || typeof customElements !== "undefined" && tagName.indexOf("-") > -1 && !customElements.get(tagName)
);
if (isUnknown && !matchingSchemas(schemas, tagName)) {
const isHostStandalone = isHostComponentStandalone(lView);
const templateLocation = getTemplateLocationDetails(lView);
const schemas2 = `'${isHostStandalone ? "@Component" : "@NgModule"}.schemas'`;
let message = `'${tagName}' is not a known element${templateLocation}:
`;
message += `1. If '${tagName}' is an Angular component, then verify that it is ${isHostStandalone ? "included in the '@Component.imports' of this component" : "a part of an @NgModule where this component is declared"}.
`;
if (tagName && tagName.indexOf("-") > -1) {
message += `2. If '${tagName}' is a Web Component then add 'CUSTOM_ELEMENTS_SCHEMA' to the ${schemas2} of this component to suppress this message.`;
} else {
message += `2. To allow any element add 'NO_ERRORS_SCHEMA' to the ${schemas2} of this component.`;
}
if (shouldThrowErrorOnUnknownElement) {
throw new RuntimeError(304, message);
} else {
console.error(formatRuntimeError(304, message));
}
}
}
}
function isPropertyValid(element, propName, tagName, schemas) {
if (schemas === null)
return true;
if (matchingSchemas(schemas, tagName) || propName in element || isAnimationProp(propName)) {
return true;
}
return typeof Node === "undefined" || Node === null || !(element instanceof Node);
}
function handleUnknownPropertyError(propName, tagName, nodeType, lView) {
if (!tagName && nodeType === 4) {
tagName = "ng-template";
}
const isHostStandalone = isHostComponentStandalone(lView);
const templateLocation = getTemplateLocationDetails(lView);
let message = `Can't bind to '${propName}' since it isn't a known property of '${tagName}'${templateLocation}.`;
const schemas = `'${isHostStandalone ? "@Component" : "@NgModule"}.schemas'`;
const importLocation = isHostStandalone ? "included in the '@Component.imports' of this component" : "a part of an @NgModule where this component is declared";
if (KNOWN_CONTROL_FLOW_DIRECTIVES.has(propName)) {
const correspondingImport = KNOWN_CONTROL_FLOW_DIRECTIVES.get(propName);
message += `
If the '${propName}' is an Angular control flow directive, please make sure that either the '${correspondingImport}' directive or the 'CommonModule' is ${importLocation}.`;
} else {
message += `
1. If '${tagName}' is an Angular component and it has the '${propName}' input, then verify that it is ${importLocation}.`;
if (tagName && tagName.indexOf("-") > -1) {
message += `
2. If '${tagName}' is a Web Component then add 'CUSTOM_ELEMENTS_SCHEMA' to the ${schemas} of this component to suppress this message.`;
message += `
3. To allow any property add 'NO_ERRORS_SCHEMA' to the ${schemas} of this component.`;
} else {
message += `
2. To allow any property add 'NO_ERRORS_SCHEMA' to the ${schemas} of this component.`;
}
}
reportUnknownPropertyError(message);
}
function reportUnknownPropertyError(message) {
if (shouldThrowErrorOnUnknownProperty) {
throw new RuntimeError(303, message);
} else {
console.error(formatRuntimeError(303, message));
}
}
function getDeclarationComponentDef(lView) {
!ngDevMode && throwError2("Must never be called in production mode");
const declarationLView = lView[DECLARATION_COMPONENT_VIEW];
const context2 = declarationLView[CONTEXT];
if (!context2)
return null;
return context2.constructor ? getComponentDef(context2.constructor) : null;
}
function isHostComponentStandalone(lView) {
!ngDevMode && throwError2("Must never be called in production mode");
const componentDef = getDeclarationComponentDef(lView);
return !!componentDef?.standalone;
}
function getTemplateLocationDetails(lView) {
!ngDevMode && throwError2("Must never be called in production mode");
const hostComponentDef = getDeclarationComponentDef(lView);
const componentClassName = hostComponentDef?.type?.name;
return componentClassName ? ` (used in the '${componentClassName}' component template)` : "";
}
var KNOWN_CONTROL_FLOW_DIRECTIVES = /* @__PURE__ */ new Map([
["ngIf", "NgIf"],
["ngFor", "NgFor"],
["ngSwitchCase", "NgSwitchCase"],
["ngSwitchDefault", "NgSwitchDefault"]
]);
function matchingSchemas(schemas, tagName) {
if (schemas !== null) {
for (let i = 0; i < schemas.length; i++) {
const schema = schemas[i];
if (schema === NO_ERRORS_SCHEMA || schema === CUSTOM_ELEMENTS_SCHEMA && tagName && tagName.indexOf("-") > -1) {
return true;
}
}
}
return false;
}
function \u0275\u0275resolveWindow(element) {
return element.ownerDocument.defaultView;
}
function \u0275\u0275resolveDocument(element) {
return element.ownerDocument;
}
function \u0275\u0275resolveBody(element) {
return element.ownerDocument.body;
}
var INTERPOLATION_DELIMITER = `\uFFFD`;
function maybeUnwrapFn(value2) {
if (value2 instanceof Function) {
return value2();
} else {
return value2;
}
}
function isPlatformBrowser(injector) {
return (injector ?? inject(Injector)).get(PLATFORM_ID) === "browser";
}
var VALUE_STRING_LENGTH_LIMIT = 200;
function assertStandaloneComponentType(type) {
assertComponentDef(type);
const componentDef = getComponentDef(type);
if (!componentDef.standalone) {
throw new RuntimeError(907, `The ${stringifyForError(type)} component is not marked as standalone, but Angular expects to have a standalone component here. Please make sure the ${stringifyForError(type)} component has the \`standalone: true\` flag in the decorator.`);
}
}
function assertComponentDef(type) {
if (!getComponentDef(type)) {
throw new RuntimeError(906, `The ${stringifyForError(type)} is not an Angular component, make sure it has the \`@Component\` decorator.`);
}
}
function throwMultipleComponentError(tNode, first2, second) {
throw new RuntimeError(-300, `Multiple components match node with tagname ${tNode.value}: ${stringifyForError(first2)} and ${stringifyForError(second)}`);
}
function throwErrorIfNoChangesMode(creationMode, oldValue, currValue, propName, lView) {
const hostComponentDef = getDeclarationComponentDef(lView);
const componentClassName = hostComponentDef?.type?.name;
const field = propName ? ` for '${propName}'` : "";
let msg = `ExpressionChangedAfterItHasBeenCheckedError: Expression has changed after it was checked. Previous value${field}: '${formatValue(oldValue)}'. Current value: '${formatValue(currValue)}'.${componentClassName ? ` Expression location: ${componentClassName} component` : ""}`;
if (creationMode) {
msg += ` It seems like the view has been created after its parent and its children have been dirty checked. Has it been created in a change detection hook?`;
}
throw new RuntimeError(-100, msg);
}
function formatValue(value2) {
let strValue = String(value2);
try {
if (Array.isArray(value2) || strValue === "[object Object]") {
strValue = JSON.stringify(value2);
}
} catch (error) {
}
return strValue.length > VALUE_STRING_LENGTH_LIMIT ? strValue.substring(0, VALUE_STRING_LENGTH_LIMIT) + "\u2026" : strValue;
}
function constructDetailsForInterpolation(lView, rootIndex, expressionIndex, meta, changedValue) {
const [propName, prefix, ...chunks] = meta.split(INTERPOLATION_DELIMITER);
let oldValue = prefix, newValue = prefix;
for (let i = 0; i < chunks.length; i++) {
const slotIdx = rootIndex + i;
oldValue += `${lView[slotIdx]}${chunks[i]}`;
newValue += `${slotIdx === expressionIndex ? changedValue : lView[slotIdx]}${chunks[i]}`;
}
return { propName, oldValue, newValue };
}
function getExpressionChangedErrorDetails(lView, bindingIndex, oldValue, newValue) {
const tData = lView[TVIEW].data;
const metadata = tData[bindingIndex];
if (typeof metadata === "string") {
if (metadata.indexOf(INTERPOLATION_DELIMITER) > -1) {
return constructDetailsForInterpolation(lView, bindingIndex, bindingIndex, metadata, newValue);
}
return { propName: metadata, oldValue, newValue };
}
if (metadata === null) {
let idx = bindingIndex - 1;
while (typeof tData[idx] !== "string" && tData[idx + 1] === null) {
idx--;
}
const meta = tData[idx];
if (typeof meta === "string") {
const matches = meta.match(new RegExp(INTERPOLATION_DELIMITER, "g"));
if (matches && matches.length - 1 > bindingIndex - idx) {
return constructDetailsForInterpolation(lView, idx, bindingIndex, meta, newValue);
}
}
}
return { propName: void 0, oldValue, newValue };
}
var RendererStyleFlags2;
(function(RendererStyleFlags22) {
RendererStyleFlags22[RendererStyleFlags22["Important"] = 1] = "Important";
RendererStyleFlags22[RendererStyleFlags22["DashCase"] = 2] = "DashCase";
})(RendererStyleFlags2 || (RendererStyleFlags2 = {}));
var _icuContainerIterate;
function icuContainerIterate(tIcuContainerNode, lView) {
return _icuContainerIterate(tIcuContainerNode, lView);
}
function ensureIcuContainerVisitorLoaded(loader) {
if (_icuContainerIterate === void 0) {
_icuContainerIterate = loader();
}
}
function applyToElementOrContainer(action, renderer2, parent2, lNodeToHandle, beforeNode) {
if (lNodeToHandle != null) {
let lContainer;
let isComponent2 = false;
if (isLContainer(lNodeToHandle)) {
lContainer = lNodeToHandle;
} else if (isLView(lNodeToHandle)) {
isComponent2 = true;
ngDevMode && assertDefined(lNodeToHandle[HOST], "HOST must be defined for a component LView");
lNodeToHandle = lNodeToHandle[HOST];
}
const rNode = unwrapRNode(lNodeToHandle);
if (action === 0 && parent2 !== null) {
if (beforeNode == null) {
nativeAppendChild(renderer2, parent2, rNode);
} else {
nativeInsertBefore(renderer2, parent2, rNode, beforeNode || null, true);
}
} else if (action === 1 && parent2 !== null) {
nativeInsertBefore(renderer2, parent2, rNode, beforeNode || null, true);
} else if (action === 2) {
nativeRemoveNode(renderer2, rNode, isComponent2);
} else if (action === 3) {
ngDevMode && ngDevMode.rendererDestroyNode++;
renderer2.destroyNode(rNode);
}
if (lContainer != null) {
applyContainer(renderer2, action, lContainer, parent2, beforeNode);
}
}
}
function createTextNode(renderer2, value2) {
ngDevMode && ngDevMode.rendererCreateTextNode++;
ngDevMode && ngDevMode.rendererSetText++;
return renderer2.createText(value2);
}
function updateTextNode(renderer2, rNode, value2) {
ngDevMode && ngDevMode.rendererSetText++;
renderer2.setValue(rNode, value2);
}
function createCommentNode(renderer2, value2) {
ngDevMode && ngDevMode.rendererCreateComment++;
return renderer2.createComment(escapeCommentText(value2));
}
function createElementNode(renderer2, name2, namespace) {
ngDevMode && ngDevMode.rendererCreateElement++;
return renderer2.createElement(name2, namespace);
}
function removeViewFromDOM(tView, lView) {
detachViewFromDOM(tView, lView);
lView[HOST] = null;
lView[T_HOST] = null;
}
function addViewToDOM(tView, parentTNode, renderer2, lView, parentNativeNode, beforeNode) {
lView[HOST] = parentNativeNode;
lView[T_HOST] = parentTNode;
applyView(tView, lView, renderer2, 1, parentNativeNode, beforeNode);
}
function detachViewFromDOM(tView, lView) {
lView[ENVIRONMENT].changeDetectionScheduler?.notify(
1
/* NotificationType.AfterRenderHooks */
);
applyView(tView, lView, lView[RENDERER], 2, null, null);
}
function destroyViewTree(rootView) {
let lViewOrLContainer = rootView[CHILD_HEAD];
if (!lViewOrLContainer) {
return cleanUpView(rootView[TVIEW], rootView);
}
while (lViewOrLContainer) {
let next = null;
if (isLView(lViewOrLContainer)) {
next = lViewOrLContainer[CHILD_HEAD];
} else {
ngDevMode && assertLContainer(lViewOrLContainer);
const firstView = lViewOrLContainer[CONTAINER_HEADER_OFFSET];
if (firstView)
next = firstView;
}
if (!next) {
while (lViewOrLContainer && !lViewOrLContainer[NEXT] && lViewOrLContainer !== rootView) {
if (isLView(lViewOrLContainer)) {
cleanUpView(lViewOrLContainer[TVIEW], lViewOrLContainer);
}
lViewOrLContainer = lViewOrLContainer[PARENT];
}
if (lViewOrLContainer === null)
lViewOrLContainer = rootView;
if (isLView(lViewOrLContainer)) {
cleanUpView(lViewOrLContainer[TVIEW], lViewOrLContainer);
}
next = lViewOrLContainer && lViewOrLContainer[NEXT];
}
lViewOrLContainer = next;
}
}
function insertView(tView, lView, lContainer, index2) {
ngDevMode && assertLView(lView);
ngDevMode && assertLContainer(lContainer);
const indexInContainer = CONTAINER_HEADER_OFFSET + index2;
const containerLength = lContainer.length;
if (index2 > 0) {
lContainer[indexInContainer - 1][NEXT] = lView;
}
if (index2 < containerLength - CONTAINER_HEADER_OFFSET) {
lView[NEXT] = lContainer[indexInContainer];
addToArray(lContainer, CONTAINER_HEADER_OFFSET + index2, lView);
} else {
lContainer.push(lView);
lView[NEXT] = null;
}
lView[PARENT] = lContainer;
const declarationLContainer = lView[DECLARATION_LCONTAINER];
if (declarationLContainer !== null && lContainer !== declarationLContainer) {
trackMovedView(declarationLContainer, lView);
}
const lQueries = lView[QUERIES];
if (lQueries !== null) {
lQueries.insertView(tView);
}
updateAncestorTraversalFlagsOnAttach(lView);
lView[FLAGS] |= 128;
}
function trackMovedView(declarationContainer, lView) {
ngDevMode && assertDefined(lView, "LView required");
ngDevMode && assertLContainer(declarationContainer);
const movedViews = declarationContainer[MOVED_VIEWS];
const insertedLContainer = lView[PARENT];
ngDevMode && assertLContainer(insertedLContainer);
const insertedComponentLView = insertedLContainer[PARENT][DECLARATION_COMPONENT_VIEW];
ngDevMode && assertDefined(insertedComponentLView, "Missing insertedComponentLView");
const declaredComponentLView = lView[DECLARATION_COMPONENT_VIEW];
ngDevMode && assertDefined(declaredComponentLView, "Missing declaredComponentLView");
if (declaredComponentLView !== insertedComponentLView) {
declarationContainer[FLAGS] |= LContainerFlags.HasTransplantedViews;
}
if (movedViews === null) {
declarationContainer[MOVED_VIEWS] = [lView];
} else {
movedViews.push(lView);
}
}
function detachMovedView(declarationContainer, lView) {
ngDevMode && assertLContainer(declarationContainer);
ngDevMode && assertDefined(declarationContainer[MOVED_VIEWS], "A projected view should belong to a non-empty projected views collection");
const movedViews = declarationContainer[MOVED_VIEWS];
const declarationViewIndex = movedViews.indexOf(lView);
ngDevMode && assertLContainer(lView[PARENT]);
movedViews.splice(declarationViewIndex, 1);
}
function detachView(lContainer, removeIndex) {
if (lContainer.length <= CONTAINER_HEADER_OFFSET)
return;
const indexInContainer = CONTAINER_HEADER_OFFSET + removeIndex;
const viewToDetach = lContainer[indexInContainer];
if (viewToDetach) {
const declarationLContainer = viewToDetach[DECLARATION_LCONTAINER];
if (declarationLContainer !== null && declarationLContainer !== lContainer) {
detachMovedView(declarationLContainer, viewToDetach);
}
if (removeIndex > 0) {
lContainer[indexInContainer - 1][NEXT] = viewToDetach[NEXT];
}
const removedLView = removeFromArray(lContainer, CONTAINER_HEADER_OFFSET + removeIndex);
removeViewFromDOM(viewToDetach[TVIEW], viewToDetach);
const lQueries = removedLView[QUERIES];
if (lQueries !== null) {
lQueries.detachView(removedLView[TVIEW]);
}
viewToDetach[PARENT] = null;
viewToDetach[NEXT] = null;
viewToDetach[FLAGS] &= ~128;
}
return viewToDetach;
}
function destroyLView(tView, lView) {
if (!(lView[FLAGS] & 256)) {
const renderer2 = lView[RENDERER];
if (renderer2.destroyNode) {
applyView(tView, lView, renderer2, 3, null, null);
}
destroyViewTree(lView);
}
}
function cleanUpView(tView, lView) {
if (lView[FLAGS] & 256) {
return;
}
const prevConsumer = setActiveConsumer(null);
try {
lView[FLAGS] &= ~128;
lView[FLAGS] |= 256;
lView[REACTIVE_TEMPLATE_CONSUMER] && consumerDestroy(lView[REACTIVE_TEMPLATE_CONSUMER]);
executeOnDestroys(tView, lView);
processCleanups(tView, lView);
if (lView[TVIEW].type === 1) {
ngDevMode && ngDevMode.rendererDestroy++;
lView[RENDERER].destroy();
}
const declarationContainer = lView[DECLARATION_LCONTAINER];
if (declarationContainer !== null && isLContainer(lView[PARENT])) {
if (declarationContainer !== lView[PARENT]) {
detachMovedView(declarationContainer, lView);
}
const lQueries = lView[QUERIES];
if (lQueries !== null) {
lQueries.detachView(tView);
}
}
unregisterLView(lView);
} finally {
setActiveConsumer(prevConsumer);
}
}
function processCleanups(tView, lView) {
ngDevMode && assertNotReactive(processCleanups.name);
const tCleanup = tView.cleanup;
const lCleanup = lView[CLEANUP];
if (tCleanup !== null) {
for (let i = 0; i < tCleanup.length - 1; i += 2) {
if (typeof tCleanup[i] === "string") {
const targetIdx = tCleanup[i + 3];
ngDevMode && assertNumber(targetIdx, "cleanup target must be a number");
if (targetIdx >= 0) {
lCleanup[targetIdx]();
} else {
lCleanup[-targetIdx].unsubscribe();
}
i += 2;
} else {
const context2 = lCleanup[tCleanup[i + 1]];
tCleanup[i].call(context2);
}
}
}
if (lCleanup !== null) {
lView[CLEANUP] = null;
}
const destroyHooks = lView[ON_DESTROY_HOOKS];
if (destroyHooks !== null) {
lView[ON_DESTROY_HOOKS] = null;
for (let i = 0; i < destroyHooks.length; i++) {
const destroyHooksFn = destroyHooks[i];
ngDevMode && assertFunction(destroyHooksFn, "Expecting destroy hook to be a function.");
destroyHooksFn();
}
}
}
function executeOnDestroys(tView, lView) {
ngDevMode && assertNotReactive(executeOnDestroys.name);
let destroyHooks;
if (tView != null && (destroyHooks = tView.destroyHooks) != null) {
for (let i = 0; i < destroyHooks.length; i += 2) {
const context2 = lView[destroyHooks[i]];
if (!(context2 instanceof NodeInjectorFactory)) {
const toCall = destroyHooks[i + 1];
if (Array.isArray(toCall)) {
for (let j = 0; j < toCall.length; j += 2) {
const callContext = context2[toCall[j]];
const hook = toCall[j + 1];
profiler(4, callContext, hook);
try {
hook.call(callContext);
} finally {
profiler(5, callContext, hook);
}
}
} else {
profiler(4, context2, toCall);
try {
toCall.call(context2);
} finally {
profiler(5, context2, toCall);
}
}
}
}
}
}
function getParentRElement(tView, tNode, lView) {
return getClosestRElement(tView, tNode.parent, lView);
}
function getClosestRElement(tView, tNode, lView) {
let parentTNode = tNode;
while (parentTNode !== null && parentTNode.type & (8 | 32)) {
tNode = parentTNode;
parentTNode = tNode.parent;
}
if (parentTNode === null) {
return lView[HOST];
} else {
ngDevMode && assertTNodeType(
parentTNode,
3 | 4
/* TNodeType.Container */
);
const { componentOffset } = parentTNode;
if (componentOffset > -1) {
ngDevMode && assertTNodeForLView(parentTNode, lView);
const { encapsulation } = tView.data[parentTNode.directiveStart + componentOffset];
if (encapsulation === ViewEncapsulation$1.None || encapsulation === ViewEncapsulation$1.Emulated) {
return null;
}
}
return getNativeByTNode(parentTNode, lView);
}
}
function nativeInsertBefore(renderer2, parent2, child, beforeNode, isMove) {
ngDevMode && ngDevMode.rendererInsertBefore++;
renderer2.insertBefore(parent2, child, beforeNode, isMove);
}
function nativeAppendChild(renderer2, parent2, child) {
ngDevMode && ngDevMode.rendererAppendChild++;
ngDevMode && assertDefined(parent2, "parent node must be defined");
renderer2.appendChild(parent2, child);
}
function nativeAppendOrInsertBefore(renderer2, parent2, child, beforeNode, isMove) {
if (beforeNode !== null) {
nativeInsertBefore(renderer2, parent2, child, beforeNode, isMove);
} else {
nativeAppendChild(renderer2, parent2, child);
}
}
function nativeRemoveChild(renderer2, parent2, child, isHostElement) {
renderer2.removeChild(parent2, child, isHostElement);
}
function nativeParentNode(renderer2, node) {
return renderer2.parentNode(node);
}
function nativeNextSibling(renderer2, node) {
return renderer2.nextSibling(node);
}
function getInsertInFrontOfRNode(parentTNode, currentTNode, lView) {
return _getInsertInFrontOfRNodeWithI18n(parentTNode, currentTNode, lView);
}
function getInsertInFrontOfRNodeWithNoI18n(parentTNode, currentTNode, lView) {
if (parentTNode.type & (8 | 32)) {
return getNativeByTNode(parentTNode, lView);
}
return null;
}
var _getInsertInFrontOfRNodeWithI18n = getInsertInFrontOfRNodeWithNoI18n;
var _processI18nInsertBefore;
function setI18nHandling(getInsertInFrontOfRNodeWithI18n2, processI18nInsertBefore2) {
_getInsertInFrontOfRNodeWithI18n = getInsertInFrontOfRNodeWithI18n2;
_processI18nInsertBefore = processI18nInsertBefore2;
}
function appendChild(tView, lView, childRNode, childTNode) {
const parentRNode = getParentRElement(tView, childTNode, lView);
const renderer2 = lView[RENDERER];
const parentTNode = childTNode.parent || lView[T_HOST];
const anchorNode = getInsertInFrontOfRNode(parentTNode, childTNode, lView);
if (parentRNode != null) {
if (Array.isArray(childRNode)) {
for (let i = 0; i < childRNode.length; i++) {
nativeAppendOrInsertBefore(renderer2, parentRNode, childRNode[i], anchorNode, false);
}
} else {
nativeAppendOrInsertBefore(renderer2, parentRNode, childRNode, anchorNode, false);
}
}
_processI18nInsertBefore !== void 0 && _processI18nInsertBefore(renderer2, childTNode, lView, childRNode, parentRNode);
}
function getFirstNativeNode(lView, tNode) {
if (tNode !== null) {
ngDevMode && assertTNodeType(
tNode,
3 | 12 | 32 | 16
/* TNodeType.Projection */
);
const tNodeType = tNode.type;
if (tNodeType & 3) {
return getNativeByTNode(tNode, lView);
} else if (tNodeType & 4) {
return getBeforeNodeForView(-1, lView[tNode.index]);
} else if (tNodeType & 8) {
const elIcuContainerChild = tNode.child;
if (elIcuContainerChild !== null) {
return getFirstNativeNode(lView, elIcuContainerChild);
} else {
const rNodeOrLContainer = lView[tNode.index];
if (isLContainer(rNodeOrLContainer)) {
return getBeforeNodeForView(-1, rNodeOrLContainer);
} else {
return unwrapRNode(rNodeOrLContainer);
}
}
} else if (tNodeType & 32) {
let nextRNode = icuContainerIterate(tNode, lView);
let rNode = nextRNode();
return rNode || unwrapRNode(lView[tNode.index]);
} else {
const projectionNodes = getProjectionNodes(lView, tNode);
if (projectionNodes !== null) {
if (Array.isArray(projectionNodes)) {
return projectionNodes[0];
}
const parentView = getLViewParent(lView[DECLARATION_COMPONENT_VIEW]);
ngDevMode && assertParentView(parentView);
return getFirstNativeNode(parentView, projectionNodes);
} else {
return getFirstNativeNode(lView, tNode.next);
}
}
}
return null;
}
function getProjectionNodes(lView, tNode) {
if (tNode !== null) {
const componentView = lView[DECLARATION_COMPONENT_VIEW];
const componentHost = componentView[T_HOST];
const slotIdx = tNode.projection;
ngDevMode && assertProjectionSlots(lView);
return componentHost.projection[slotIdx];
}
return null;
}
function getBeforeNodeForView(viewIndexInContainer, lContainer) {
const nextViewIndex = CONTAINER_HEADER_OFFSET + viewIndexInContainer + 1;
if (nextViewIndex < lContainer.length) {
const lView = lContainer[nextViewIndex];
const firstTNodeOfView = lView[TVIEW].firstChild;
if (firstTNodeOfView !== null) {
return getFirstNativeNode(lView, firstTNodeOfView);
}
}
return lContainer[NATIVE];
}
function nativeRemoveNode(renderer2, rNode, isHostElement) {
ngDevMode && ngDevMode.rendererRemoveNode++;
const nativeParent = nativeParentNode(renderer2, rNode);
if (nativeParent) {
nativeRemoveChild(renderer2, nativeParent, rNode, isHostElement);
}
}
function applyNodes(renderer2, action, tNode, lView, parentRElement, beforeNode, isProjection) {
while (tNode != null) {
ngDevMode && assertTNodeForLView(tNode, lView);
ngDevMode && assertTNodeType(
tNode,
3 | 12 | 16 | 32
/* TNodeType.Icu */
);
const rawSlotValue = lView[tNode.index];
const tNodeType = tNode.type;
if (isProjection) {
if (action === 0) {
rawSlotValue && attachPatchData(unwrapRNode(rawSlotValue), lView);
tNode.flags |= 2;
}
}
if ((tNode.flags & 32) !== 32) {
if (tNodeType & 8) {
applyNodes(renderer2, action, tNode.child, lView, parentRElement, beforeNode, false);
applyToElementOrContainer(action, renderer2, parentRElement, rawSlotValue, beforeNode);
} else if (tNodeType & 32) {
const nextRNode = icuContainerIterate(tNode, lView);
let rNode;
while (rNode = nextRNode()) {
applyToElementOrContainer(action, renderer2, parentRElement, rNode, beforeNode);
}
applyToElementOrContainer(action, renderer2, parentRElement, rawSlotValue, beforeNode);
} else if (tNodeType & 16) {
applyProjectionRecursive(renderer2, action, lView, tNode, parentRElement, beforeNode);
} else {
ngDevMode && assertTNodeType(
tNode,
3 | 4
/* TNodeType.Container */
);
applyToElementOrContainer(action, renderer2, parentRElement, rawSlotValue, beforeNode);
}
}
tNode = isProjection ? tNode.projectionNext : tNode.next;
}
}
function applyView(tView, lView, renderer2, action, parentRElement, beforeNode) {
applyNodes(renderer2, action, tView.firstChild, lView, parentRElement, beforeNode, false);
}
function applyProjection(tView, lView, tProjectionNode) {
const renderer2 = lView[RENDERER];
const parentRNode = getParentRElement(tView, tProjectionNode, lView);
const parentTNode = tProjectionNode.parent || lView[T_HOST];
let beforeNode = getInsertInFrontOfRNode(parentTNode, tProjectionNode, lView);
applyProjectionRecursive(renderer2, 0, lView, tProjectionNode, parentRNode, beforeNode);
}
function applyProjectionRecursive(renderer2, action, lView, tProjectionNode, parentRElement, beforeNode) {
const componentLView = lView[DECLARATION_COMPONENT_VIEW];
const componentNode = componentLView[T_HOST];
ngDevMode && assertEqual(typeof tProjectionNode.projection, "number", "expecting projection index");
const nodeToProjectOrRNodes = componentNode.projection[tProjectionNode.projection];
if (Array.isArray(nodeToProjectOrRNodes)) {
for (let i = 0; i < nodeToProjectOrRNodes.length; i++) {
const rNode = nodeToProjectOrRNodes[i];
applyToElementOrContainer(action, renderer2, parentRElement, rNode, beforeNode);
}
} else {
let nodeToProject = nodeToProjectOrRNodes;
const projectedComponentLView = componentLView[PARENT];
if (hasInSkipHydrationBlockFlag(tProjectionNode)) {
nodeToProject.flags |= 128;
}
applyNodes(renderer2, action, nodeToProject, projectedComponentLView, parentRElement, beforeNode, true);
}
}
function applyContainer(renderer2, action, lContainer, parentRElement, beforeNode) {
ngDevMode && assertLContainer(lContainer);
const anchor = lContainer[NATIVE];
const native = unwrapRNode(lContainer);
if (anchor !== native) {
applyToElementOrContainer(action, renderer2, parentRElement, anchor, beforeNode);
}
for (let i = CONTAINER_HEADER_OFFSET; i < lContainer.length; i++) {
const lView = lContainer[i];
applyView(lView[TVIEW], lView, renderer2, action, parentRElement, anchor);
}
}
function applyStyling(renderer2, isClassBased, rNode, prop, value2) {
if (isClassBased) {
if (!value2) {
ngDevMode && ngDevMode.rendererRemoveClass++;
renderer2.removeClass(rNode, prop);
} else {
ngDevMode && ngDevMode.rendererAddClass++;
renderer2.addClass(rNode, prop);
}
} else {
let flags = prop.indexOf("-") === -1 ? void 0 : RendererStyleFlags2.DashCase;
if (value2 == null) {
ngDevMode && ngDevMode.rendererRemoveStyle++;
renderer2.removeStyle(rNode, prop, flags);
} else {
const isImportant = typeof value2 === "string" ? value2.endsWith("!important") : false;
if (isImportant) {
value2 = value2.slice(0, -10);
flags |= RendererStyleFlags2.Important;
}
ngDevMode && ngDevMode.rendererSetStyle++;
renderer2.setStyle(rNode, prop, value2, flags);
}
}
}
function writeDirectStyle(renderer2, element, newValue) {
ngDevMode && assertString(newValue, "'newValue' should be a string");
renderer2.setAttribute(element, "style", newValue);
ngDevMode && ngDevMode.rendererSetStyle++;
}
function writeDirectClass(renderer2, element, newValue) {
ngDevMode && assertString(newValue, "'newValue' should be a string");
if (newValue === "") {
renderer2.removeAttribute(element, "class");
} else {
renderer2.setAttribute(element, "class", newValue);
}
ngDevMode && ngDevMode.rendererSetClassName++;
}
function setupStaticAttributes(renderer2, element, tNode) {
const { mergedAttrs, classes, styles } = tNode;
if (mergedAttrs !== null) {
setUpAttributes(renderer2, element, mergedAttrs);
}
if (classes !== null) {
writeDirectClass(renderer2, element, classes);
}
if (styles !== null) {
writeDirectStyle(renderer2, element, styles);
}
}
var NO_CHANGE = typeof ngDevMode === "undefined" || ngDevMode ? { __brand__: "NO_CHANGE" } : {};
function \u0275\u0275advance(delta = 1) {
ngDevMode && assertGreaterThan(delta, 0, "Can only advance forward");
selectIndexInternal(getTView(), getLView(), getSelectedIndex() + delta, !!ngDevMode && isInCheckNoChangesMode());
}
function selectIndexInternal(tView, lView, index2, checkNoChangesMode) {
ngDevMode && assertIndexInDeclRange(lView[TVIEW], index2);
if (!checkNoChangesMode) {
const hooksInitPhaseCompleted = (lView[FLAGS] & 3) === 3;
if (hooksInitPhaseCompleted) {
const preOrderCheckHooks = tView.preOrderCheckHooks;
if (preOrderCheckHooks !== null) {
executeCheckHooks(lView, preOrderCheckHooks, index2);
}
} else {
const preOrderHooks = tView.preOrderHooks;
if (preOrderHooks !== null) {
executeInitAndCheckHooks(lView, preOrderHooks, 0, index2);
}
}
}
setSelectedIndex(index2);
}
function \u0275\u0275directiveInject(token, flags = InjectFlags.Default) {
const lView = getLView();
if (lView === null) {
ngDevMode && assertInjectImplementationNotEqual(\u0275\u0275directiveInject);
return \u0275\u0275inject(token, flags);
}
const tNode = getCurrentTNode();
const value2 = getOrCreateInjectable(tNode, lView, resolveForwardRef(token), flags);
ngDevMode && emitInjectEvent(token, value2, flags);
return value2;
}
function \u0275\u0275invalidFactory() {
const msg = ngDevMode ? `This constructor was not compatible with Dependency Injection.` : "invalid";
throw new Error(msg);
}
function writeToDirectiveInput(def, instance, publicName, privateName, flags, value2) {
const prevConsumer = setActiveConsumer(null);
try {
let inputSignalNode = null;
if ((flags & InputFlags.SignalBased) !== 0) {
const field = instance[privateName];
inputSignalNode = field[SIGNAL];
}
if (inputSignalNode !== null && inputSignalNode.transformFn !== void 0) {
value2 = inputSignalNode.transformFn(value2);
}
if ((flags & InputFlags.HasDecoratorInputTransform) !== 0) {
value2 = def.inputTransforms[privateName].call(instance, value2);
}
if (def.setInput !== null) {
def.setInput(instance, inputSignalNode, value2, publicName, privateName);
} else {
applyValueToInputField(instance, inputSignalNode, privateName, value2);
}
} finally {
setActiveConsumer(prevConsumer);
}
}
function processHostBindingOpCodes(tView, lView) {
const hostBindingOpCodes = tView.hostBindingOpCodes;
if (hostBindingOpCodes === null)
return;
try {
for (let i = 0; i < hostBindingOpCodes.length; i++) {
const opCode = hostBindingOpCodes[i];
if (opCode < 0) {
setSelectedIndex(~opCode);
} else {
const directiveIdx = opCode;
const bindingRootIndx = hostBindingOpCodes[++i];
const hostBindingFn = hostBindingOpCodes[++i];
setBindingRootForHostBindings(bindingRootIndx, directiveIdx);
const context2 = lView[directiveIdx];
hostBindingFn(2, context2);
}
}
} finally {
setSelectedIndex(-1);
}
}
function createLView(parentLView, tView, context2, flags, host, tHostNode, environment2, renderer2, injector, embeddedViewInjector, hydrationInfo) {
const lView = tView.blueprint.slice();
lView[HOST] = host;
lView[FLAGS] = flags | 4 | 128 | 8 | 64;
if (embeddedViewInjector !== null || parentLView && parentLView[FLAGS] & 2048) {
lView[FLAGS] |= 2048;
}
resetPreOrderHookFlags(lView);
ngDevMode && tView.declTNode && parentLView && assertTNodeForLView(tView.declTNode, parentLView);
lView[PARENT] = lView[DECLARATION_VIEW] = parentLView;
lView[CONTEXT] = context2;
lView[ENVIRONMENT] = environment2 || parentLView && parentLView[ENVIRONMENT];
ngDevMode && assertDefined(lView[ENVIRONMENT], "LViewEnvironment is required");
lView[RENDERER] = renderer2 || parentLView && parentLView[RENDERER];
ngDevMode && assertDefined(lView[RENDERER], "Renderer is required");
lView[INJECTOR] = injector || parentLView && parentLView[INJECTOR] || null;
lView[T_HOST] = tHostNode;
lView[ID] = getUniqueLViewId();
lView[HYDRATION] = hydrationInfo;
lView[EMBEDDED_VIEW_INJECTOR] = embeddedViewInjector;
ngDevMode && assertEqual(tView.type == 2 ? parentLView !== null : true, true, "Embedded views must have parentLView");
lView[DECLARATION_COMPONENT_VIEW] = tView.type == 2 ? parentLView[DECLARATION_COMPONENT_VIEW] : lView;
return lView;
}
function getOrCreateTNode(tView, index2, type, name2, attrs) {
ngDevMode && index2 !== 0 && // 0 are bogus nodes and they are OK. See `createContainerRef` in
// `view_engine_compatibility` for additional context.
assertGreaterThanOrEqual(index2, HEADER_OFFSET, "TNodes can't be in the LView header.");
ngDevMode && assertPureTNodeType(type);
let tNode = tView.data[index2];
if (tNode === null) {
tNode = createTNodeAtIndex(tView, index2, type, name2, attrs);
if (isInI18nBlock()) {
tNode.flags |= 32;
}
} else if (tNode.type & 64) {
tNode.type = type;
tNode.value = name2;
tNode.attrs = attrs;
const parent2 = getCurrentParentTNode();
tNode.injectorIndex = parent2 === null ? -1 : parent2.injectorIndex;
ngDevMode && assertTNodeForTView(tNode, tView);
ngDevMode && assertEqual(index2, tNode.index, "Expecting same index");
}
setCurrentTNode(tNode, true);
return tNode;
}
function createTNodeAtIndex(tView, index2, type, name2, attrs) {
const currentTNode = getCurrentTNodePlaceholderOk();
const isParent = isCurrentTNodeParent();
const parent2 = isParent ? currentTNode : currentTNode && currentTNode.parent;
const tNode = tView.data[index2] = createTNode(tView, parent2, type, index2, name2, attrs);
if (tView.firstChild === null) {
tView.firstChild = tNode;
}
if (currentTNode !== null) {
if (isParent) {
if (currentTNode.child == null && tNode.parent !== null) {
currentTNode.child = tNode;
}
} else {
if (currentTNode.next === null) {
currentTNode.next = tNode;
tNode.prev = currentTNode;
}
}
}
return tNode;
}
function allocExpando(tView, lView, numSlotsToAlloc, initialValue) {
if (numSlotsToAlloc === 0)
return -1;
if (ngDevMode) {
assertFirstCreatePass(tView);
assertSame(tView, lView[TVIEW], "`LView` must be associated with `TView`!");
assertEqual(tView.data.length, lView.length, "Expecting LView to be same size as TView");
assertEqual(tView.data.length, tView.blueprint.length, "Expecting Blueprint to be same size as TView");
assertFirstUpdatePass(tView);
}
const allocIdx = lView.length;
for (let i = 0; i < numSlotsToAlloc; i++) {
lView.push(initialValue);
tView.blueprint.push(initialValue);
tView.data.push(null);
}
return allocIdx;
}
function executeTemplate(tView, lView, templateFn, rf, context2) {
const prevSelectedIndex = getSelectedIndex();
const isUpdatePhase = rf & 2;
try {
setSelectedIndex(-1);
if (isUpdatePhase && lView.length > HEADER_OFFSET) {
selectIndexInternal(tView, lView, HEADER_OFFSET, !!ngDevMode && isInCheckNoChangesMode());
}
const preHookType = isUpdatePhase ? 2 : 0;
profiler(preHookType, context2);
templateFn(rf, context2);
} finally {
setSelectedIndex(prevSelectedIndex);
const postHookType = isUpdatePhase ? 3 : 1;
profiler(postHookType, context2);
}
}
function executeContentQueries(tView, tNode, lView) {
if (isContentQueryHost(tNode)) {
const prevConsumer = setActiveConsumer(null);
try {
const start = tNode.directiveStart;
const end = tNode.directiveEnd;
for (let directiveIndex = start; directiveIndex < end; directiveIndex++) {
const def = tView.data[directiveIndex];
if (def.contentQueries) {
const directiveInstance = lView[directiveIndex];
ngDevMode && assertDefined(directiveIndex, "Incorrect reference to a directive defining a content query");
def.contentQueries(1, directiveInstance, directiveIndex);
}
}
} finally {
setActiveConsumer(prevConsumer);
}
}
}
function createDirectivesInstances(tView, lView, tNode) {
if (!getBindingsEnabled())
return;
instantiateAllDirectives(tView, lView, tNode, getNativeByTNode(tNode, lView));
if ((tNode.flags & 64) === 64) {
invokeDirectivesHostBindings(tView, lView, tNode);
}
}
function saveResolvedLocalsInData(viewData, tNode, localRefExtractor = getNativeByTNode) {
const localNames = tNode.localNames;
if (localNames !== null) {
let localIndex = tNode.index + 1;
for (let i = 0; i < localNames.length; i += 2) {
const index2 = localNames[i + 1];
const value2 = index2 === -1 ? localRefExtractor(tNode, viewData) : viewData[index2];
viewData[localIndex++] = value2;
}
}
}
function getOrCreateComponentTView(def) {
const tView = def.tView;
if (tView === null || tView.incompleteFirstPass) {
const declTNode = null;
return def.tView = createTView(1, declTNode, def.template, def.decls, def.vars, def.directiveDefs, def.pipeDefs, def.viewQuery, def.schemas, def.consts, def.id);
}
return tView;
}
function createTView(type, declTNode, templateFn, decls, vars, directives, pipes, viewQuery, schemas, constsOrFactory, ssrId) {
ngDevMode && ngDevMode.tView++;
const bindingStartIndex = HEADER_OFFSET + decls;
const initialViewLength = bindingStartIndex + vars;
const blueprint = createViewBlueprint(bindingStartIndex, initialViewLength);
const consts = typeof constsOrFactory === "function" ? constsOrFactory() : constsOrFactory;
const tView = blueprint[TVIEW] = {
type,
blueprint,
template: templateFn,
queries: null,
viewQuery,
declTNode,
data: blueprint.slice().fill(null, bindingStartIndex),
bindingStartIndex,
expandoStartIndex: initialViewLength,
hostBindingOpCodes: null,
firstCreatePass: true,
firstUpdatePass: true,
staticViewQueries: false,
staticContentQueries: false,
preOrderHooks: null,
preOrderCheckHooks: null,
contentHooks: null,
contentCheckHooks: null,
viewHooks: null,
viewCheckHooks: null,
destroyHooks: null,
cleanup: null,
contentQueries: null,
components: null,
directiveRegistry: typeof directives === "function" ? directives() : directives,
pipeRegistry: typeof pipes === "function" ? pipes() : pipes,
firstChild: null,
schemas,
consts,
incompleteFirstPass: false,
ssrId
};
if (ngDevMode) {
Object.seal(tView);
}
return tView;
}
function createViewBlueprint(bindingStartIndex, initialViewLength) {
const blueprint = [];
for (let i = 0; i < initialViewLength; i++) {
blueprint.push(i < bindingStartIndex ? null : NO_CHANGE);
}
return blueprint;
}
function locateHostElement(renderer2, elementOrSelector, encapsulation, injector) {
const preserveHostContent = injector.get(PRESERVE_HOST_CONTENT, PRESERVE_HOST_CONTENT_DEFAULT);
const preserveContent = preserveHostContent || encapsulation === ViewEncapsulation$1.ShadowDom;
const rootElement = renderer2.selectRootElement(elementOrSelector, preserveContent);
applyRootElementTransform(rootElement);
return rootElement;
}
function applyRootElementTransform(rootElement) {
_applyRootElementTransformImpl(rootElement);
}
var _applyRootElementTransformImpl = () => null;
function storeCleanupWithContext(tView, lView, context2, cleanupFn) {
const lCleanup = getOrCreateLViewCleanup(lView);
ngDevMode && assertDefined(context2, "Cleanup context is mandatory when registering framework-level destroy hooks");
lCleanup.push(context2);
if (tView.firstCreatePass) {
getOrCreateTViewCleanup(tView).push(cleanupFn, lCleanup.length - 1);
} else {
if (ngDevMode) {
Object.freeze(getOrCreateTViewCleanup(tView));
}
}
}
function createTNode(tView, tParent, type, index2, value2, attrs) {
ngDevMode && index2 !== 0 && // 0 are bogus nodes and they are OK. See `createContainerRef` in
// `view_engine_compatibility` for additional context.
assertGreaterThanOrEqual(index2, HEADER_OFFSET, "TNodes can't be in the LView header.");
ngDevMode && assertNotSame(attrs, void 0, "'undefined' is not valid value for 'attrs'");
ngDevMode && ngDevMode.tNode++;
ngDevMode && tParent && assertTNodeForTView(tParent, tView);
let injectorIndex = tParent ? tParent.injectorIndex : -1;
let flags = 0;
if (isInSkipHydrationBlock$1()) {
flags |= 128;
}
const tNode = {
type,
index: index2,
insertBeforeIndex: null,
injectorIndex,
directiveStart: -1,
directiveEnd: -1,
directiveStylingLast: -1,
componentOffset: -1,
propertyBindings: null,
flags,
providerIndexes: 0,
value: value2,
attrs,
mergedAttrs: null,
localNames: null,
initialInputs: void 0,
inputs: null,
outputs: null,
tView: null,
next: null,
prev: null,
projectionNext: null,
child: null,
parent: tParent,
projection: null,
styles: null,
stylesWithoutHost: null,
residualStyles: void 0,
classes: null,
classesWithoutHost: null,
residualClasses: void 0,
classBindings: 0,
styleBindings: 0
};
if (ngDevMode) {
Object.seal(tNode);
}
return tNode;
}
function captureNodeBindings(mode, aliasMap, directiveIndex, bindingsResult, hostDirectiveAliasMap) {
for (let publicName in aliasMap) {
if (!aliasMap.hasOwnProperty(publicName)) {
continue;
}
const value2 = aliasMap[publicName];
if (value2 === void 0) {
continue;
}
bindingsResult ??= {};
let internalName;
let inputFlags = InputFlags.None;
if (Array.isArray(value2)) {
internalName = value2[0];
inputFlags = value2[1];
} else {
internalName = value2;
}
let finalPublicName = publicName;
if (hostDirectiveAliasMap !== null) {
if (!hostDirectiveAliasMap.hasOwnProperty(publicName)) {
continue;
}
finalPublicName = hostDirectiveAliasMap[publicName];
}
if (mode === 0) {
addPropertyBinding(bindingsResult, directiveIndex, finalPublicName, internalName, inputFlags);
} else {
addPropertyBinding(bindingsResult, directiveIndex, finalPublicName, internalName);
}
}
return bindingsResult;
}
function addPropertyBinding(bindings, directiveIndex, publicName, internalName, inputFlags) {
let values;
if (bindings.hasOwnProperty(publicName)) {
(values = bindings[publicName]).push(directiveIndex, internalName);
} else {
values = bindings[publicName] = [directiveIndex, internalName];
}
if (inputFlags !== void 0) {
values.push(inputFlags);
}
}
function initializeInputAndOutputAliases(tView, tNode, hostDirectiveDefinitionMap) {
ngDevMode && assertFirstCreatePass(tView);
const start = tNode.directiveStart;
const end = tNode.directiveEnd;
const tViewData = tView.data;
const tNodeAttrs = tNode.attrs;
const inputsFromAttrs = [];
let inputsStore = null;
let outputsStore = null;
for (let directiveIndex = start; directiveIndex < end; directiveIndex++) {
const directiveDef = tViewData[directiveIndex];
const aliasData = hostDirectiveDefinitionMap ? hostDirectiveDefinitionMap.get(directiveDef) : null;
const aliasedInputs = aliasData ? aliasData.inputs : null;
const aliasedOutputs = aliasData ? aliasData.outputs : null;
inputsStore = captureNodeBindings(0, directiveDef.inputs, directiveIndex, inputsStore, aliasedInputs);
outputsStore = captureNodeBindings(1, directiveDef.outputs, directiveIndex, outputsStore, aliasedOutputs);
const initialInputs = inputsStore !== null && tNodeAttrs !== null && !isInlineTemplate(tNode) ? generateInitialInputs(inputsStore, directiveIndex, tNodeAttrs) : null;
inputsFromAttrs.push(initialInputs);
}
if (inputsStore !== null) {
if (inputsStore.hasOwnProperty("class")) {
tNode.flags |= 8;
}
if (inputsStore.hasOwnProperty("style")) {
tNode.flags |= 16;
}
}
tNode.initialInputs = inputsFromAttrs;
tNode.inputs = inputsStore;
tNode.outputs = outputsStore;
}
function mapPropName(name2) {
if (name2 === "class")
return "className";
if (name2 === "for")
return "htmlFor";
if (name2 === "formaction")
return "formAction";
if (name2 === "innerHtml")
return "innerHTML";
if (name2 === "readonly")
return "readOnly";
if (name2 === "tabindex")
return "tabIndex";
return name2;
}
function elementPropertyInternal(tView, tNode, lView, propName, value2, renderer2, sanitizer, nativeOnly) {
ngDevMode && assertNotSame(value2, NO_CHANGE, "Incoming value should never be NO_CHANGE.");
const element = getNativeByTNode(tNode, lView);
let inputData = tNode.inputs;
let dataValue;
if (!nativeOnly && inputData != null && (dataValue = inputData[propName])) {
setInputsForProperty(tView, lView, dataValue, propName, value2);
if (isComponentHost(tNode))
markDirtyIfOnPush(lView, tNode.index);
if (ngDevMode) {
setNgReflectProperties(lView, element, tNode.type, dataValue, value2);
}
} else if (tNode.type & 3) {
propName = mapPropName(propName);
if (ngDevMode) {
validateAgainstEventProperties(propName);
if (!isPropertyValid(element, propName, tNode.value, tView.schemas)) {
handleUnknownPropertyError(propName, tNode.value, tNode.type, lView);
}
ngDevMode.rendererSetProperty++;
}
value2 = sanitizer != null ? sanitizer(value2, tNode.value || "", propName) : value2;
renderer2.setProperty(element, propName, value2);
} else if (tNode.type & 12) {
if (ngDevMode && !matchingSchemas(tView.schemas, tNode.value)) {
handleUnknownPropertyError(propName, tNode.value, tNode.type, lView);
}
}
}
function markDirtyIfOnPush(lView, viewIndex) {
ngDevMode && assertLView(lView);
const childComponentLView = getComponentLViewByIndex(viewIndex, lView);
if (!(childComponentLView[FLAGS] & 16)) {
childComponentLView[FLAGS] |= 64;
}
}
function setNgReflectProperty(lView, element, type, attrName, value2) {
const renderer2 = lView[RENDERER];
attrName = normalizeDebugBindingName(attrName);
const debugValue = normalizeDebugBindingValue(value2);
if (type & 3) {
if (value2 == null) {
renderer2.removeAttribute(element, attrName);
} else {
renderer2.setAttribute(element, attrName, debugValue);
}
} else {
const textContent = escapeCommentText(`bindings=${JSON.stringify({ [attrName]: debugValue }, null, 2)}`);
renderer2.setValue(element, textContent);
}
}
function setNgReflectProperties(lView, element, type, dataValue, value2) {
if (type & (3 | 4)) {
for (let i = 0; i < dataValue.length; i += 3) {
setNgReflectProperty(lView, element, type, dataValue[i + 1], value2);
}
}
}
function resolveDirectives(tView, lView, tNode, localRefs) {
ngDevMode && assertFirstCreatePass(tView);
if (getBindingsEnabled()) {
const exportsMap = localRefs === null ? null : { "": -1 };
const matchResult = findDirectiveDefMatches(tView, tNode);
let directiveDefs;
let hostDirectiveDefs;
if (matchResult === null) {
directiveDefs = hostDirectiveDefs = null;
} else {
[directiveDefs, hostDirectiveDefs] = matchResult;
}
if (directiveDefs !== null) {
initializeDirectives(tView, lView, tNode, directiveDefs, exportsMap, hostDirectiveDefs);
}
if (exportsMap)
cacheMatchingLocalNames(tNode, localRefs, exportsMap);
}
tNode.mergedAttrs = mergeHostAttrs(tNode.mergedAttrs, tNode.attrs);
}
function initializeDirectives(tView, lView, tNode, directives, exportsMap, hostDirectiveDefs) {
ngDevMode && assertFirstCreatePass(tView);
for (let i = 0; i < directives.length; i++) {
diPublicInInjector(getOrCreateNodeInjectorForNode(tNode, lView), tView, directives[i].type);
}
initTNodeFlags(tNode, tView.data.length, directives.length);
for (let i = 0; i < directives.length; i++) {
const def = directives[i];
if (def.providersResolver)
def.providersResolver(def);
}
let preOrderHooksFound = false;
let preOrderCheckHooksFound = false;
let directiveIdx = allocExpando(tView, lView, directives.length, null);
ngDevMode && assertSame(directiveIdx, tNode.directiveStart, "TNode.directiveStart should point to just allocated space");
for (let i = 0; i < directives.length; i++) {
const def = directives[i];
tNode.mergedAttrs = mergeHostAttrs(tNode.mergedAttrs, def.hostAttrs);
configureViewWithDirective(tView, tNode, lView, directiveIdx, def);
saveNameToExportMap(directiveIdx, def, exportsMap);
if (def.contentQueries !== null)
tNode.flags |= 4;
if (def.hostBindings !== null || def.hostAttrs !== null || def.hostVars !== 0)
tNode.flags |= 64;
const lifeCycleHooks = def.type.prototype;
if (!preOrderHooksFound && (lifeCycleHooks.ngOnChanges || lifeCycleHooks.ngOnInit || lifeCycleHooks.ngDoCheck)) {
(tView.preOrderHooks ??= []).push(tNode.index);
preOrderHooksFound = true;
}
if (!preOrderCheckHooksFound && (lifeCycleHooks.ngOnChanges || lifeCycleHooks.ngDoCheck)) {
(tView.preOrderCheckHooks ??= []).push(tNode.index);
preOrderCheckHooksFound = true;
}
directiveIdx++;
}
initializeInputAndOutputAliases(tView, tNode, hostDirectiveDefs);
}
function registerHostBindingOpCodes(tView, tNode, directiveIdx, directiveVarsIdx, def) {
ngDevMode && assertFirstCreatePass(tView);
const hostBindings = def.hostBindings;
if (hostBindings) {
let hostBindingOpCodes = tView.hostBindingOpCodes;
if (hostBindingOpCodes === null) {
hostBindingOpCodes = tView.hostBindingOpCodes = [];
}
const elementIndx = ~tNode.index;
if (lastSelectedElementIdx(hostBindingOpCodes) != elementIndx) {
hostBindingOpCodes.push(elementIndx);
}
hostBindingOpCodes.push(directiveIdx, directiveVarsIdx, hostBindings);
}
}
function lastSelectedElementIdx(hostBindingOpCodes) {
let i = hostBindingOpCodes.length;
while (i > 0) {
const value2 = hostBindingOpCodes[--i];
if (typeof value2 === "number" && value2 < 0) {
return value2;
}
}
return 0;
}
function instantiateAllDirectives(tView, lView, tNode, native) {
const start = tNode.directiveStart;
const end = tNode.directiveEnd;
if (isComponentHost(tNode)) {
ngDevMode && assertTNodeType(
tNode,
3
/* TNodeType.AnyRNode */
);
addComponentLogic(lView, tNode, tView.data[start + tNode.componentOffset]);
}
if (!tView.firstCreatePass) {
getOrCreateNodeInjectorForNode(tNode, lView);
}
attachPatchData(native, lView);
const initialInputs = tNode.initialInputs;
for (let i = start; i < end; i++) {
const def = tView.data[i];
const directive = getNodeInjectable(lView, tView, i, tNode);
attachPatchData(directive, lView);
if (initialInputs !== null) {
setInputsFromAttrs(lView, i - start, directive, def, tNode, initialInputs);
}
if (isComponentDef(def)) {
const componentView = getComponentLViewByIndex(tNode.index, lView);
componentView[CONTEXT] = getNodeInjectable(lView, tView, i, tNode);
}
}
}
function invokeDirectivesHostBindings(tView, lView, tNode) {
const start = tNode.directiveStart;
const end = tNode.directiveEnd;
const elementIndex = tNode.index;
const currentDirectiveIndex = getCurrentDirectiveIndex();
try {
setSelectedIndex(elementIndex);
for (let dirIndex = start; dirIndex < end; dirIndex++) {
const def = tView.data[dirIndex];
const directive = lView[dirIndex];
setCurrentDirectiveIndex(dirIndex);
if (def.hostBindings !== null || def.hostVars !== 0 || def.hostAttrs !== null) {
invokeHostBindingsInCreationMode(def, directive);
}
}
} finally {
setSelectedIndex(-1);
setCurrentDirectiveIndex(currentDirectiveIndex);
}
}
function invokeHostBindingsInCreationMode(def, directive) {
if (def.hostBindings !== null) {
def.hostBindings(1, directive);
}
}
function findDirectiveDefMatches(tView, tNode) {
ngDevMode && assertFirstCreatePass(tView);
ngDevMode && assertTNodeType(
tNode,
3 | 12
/* TNodeType.AnyContainer */
);
const registry = tView.directiveRegistry;
let matches = null;
let hostDirectiveDefs = null;
if (registry) {
for (let i = 0; i < registry.length; i++) {
const def = registry[i];
if (isNodeMatchingSelectorList(
tNode,
def.selectors,
/* isProjectionMode */
false
)) {
matches || (matches = []);
if (isComponentDef(def)) {
if (ngDevMode) {
assertTNodeType(tNode, 2, `"${tNode.value}" tags cannot be used as component hosts. Please use a different tag to activate the ${stringify(def.type)} component.`);
if (isComponentHost(tNode)) {
throwMultipleComponentError(tNode, matches.find(isComponentDef).type, def.type);
}
}
if (def.findHostDirectiveDefs !== null) {
const hostDirectiveMatches = [];
hostDirectiveDefs = hostDirectiveDefs || /* @__PURE__ */ new Map();
def.findHostDirectiveDefs(def, hostDirectiveMatches, hostDirectiveDefs);
matches.unshift(...hostDirectiveMatches, def);
const componentOffset = hostDirectiveMatches.length;
markAsComponentHost(tView, tNode, componentOffset);
} else {
matches.unshift(def);
markAsComponentHost(tView, tNode, 0);
}
} else {
hostDirectiveDefs = hostDirectiveDefs || /* @__PURE__ */ new Map();
def.findHostDirectiveDefs?.(def, matches, hostDirectiveDefs);
matches.push(def);
}
}
}
}
ngDevMode && matches !== null && assertNoDuplicateDirectives(matches);
return matches === null ? null : [matches, hostDirectiveDefs];
}
function markAsComponentHost(tView, hostTNode, componentOffset) {
ngDevMode && assertFirstCreatePass(tView);
ngDevMode && assertGreaterThan(componentOffset, -1, "componentOffset must be great than -1");
hostTNode.componentOffset = componentOffset;
(tView.components ??= []).push(hostTNode.index);
}
function cacheMatchingLocalNames(tNode, localRefs, exportsMap) {
if (localRefs) {
const localNames = tNode.localNames = [];
for (let i = 0; i < localRefs.length; i += 2) {
const index2 = exportsMap[localRefs[i + 1]];
if (index2 == null)
throw new RuntimeError(-301, ngDevMode && `Export of name '${localRefs[i + 1]}' not found!`);
localNames.push(localRefs[i], index2);
}
}
}
function saveNameToExportMap(directiveIdx, def, exportsMap) {
if (exportsMap) {
if (def.exportAs) {
for (let i = 0; i < def.exportAs.length; i++) {
exportsMap[def.exportAs[i]] = directiveIdx;
}
}
if (isComponentDef(def))
exportsMap[""] = directiveIdx;
}
}
function initTNodeFlags(tNode, index2, numberOfDirectives) {
ngDevMode && assertNotEqual(numberOfDirectives, tNode.directiveEnd - tNode.directiveStart, "Reached the max number of directives");
tNode.flags |= 1;
tNode.directiveStart = index2;
tNode.directiveEnd = index2 + numberOfDirectives;
tNode.providerIndexes = index2;
}
function configureViewWithDirective(tView, tNode, lView, directiveIndex, def) {
ngDevMode && assertGreaterThanOrEqual(directiveIndex, HEADER_OFFSET, "Must be in Expando section");
tView.data[directiveIndex] = def;
const directiveFactory = def.factory || (def.factory = getFactoryDef(def.type, true));
const nodeInjectorFactory = new NodeInjectorFactory(directiveFactory, isComponentDef(def), \u0275\u0275directiveInject);
tView.blueprint[directiveIndex] = nodeInjectorFactory;
lView[directiveIndex] = nodeInjectorFactory;
registerHostBindingOpCodes(tView, tNode, directiveIndex, allocExpando(tView, lView, def.hostVars, NO_CHANGE), def);
}
function addComponentLogic(lView, hostTNode, def) {
const native = getNativeByTNode(hostTNode, lView);
const tView = getOrCreateComponentTView(def);
const rendererFactory = lView[ENVIRONMENT].rendererFactory;
let lViewFlags = 16;
if (def.signals) {
lViewFlags = 4096;
} else if (def.onPush) {
lViewFlags = 64;
}
const componentView = addToViewTree(lView, createLView(lView, tView, null, lViewFlags, native, hostTNode, null, rendererFactory.createRenderer(native, def), null, null, null));
lView[hostTNode.index] = componentView;
}
function elementAttributeInternal(tNode, lView, name2, value2, sanitizer, namespace) {
if (ngDevMode) {
assertNotSame(value2, NO_CHANGE, "Incoming value should never be NO_CHANGE.");
validateAgainstEventAttributes(name2);
assertTNodeType(tNode, 2, `Attempted to set attribute \`${name2}\` on a container node. Host bindings are not valid on ng-container or ng-template.`);
}
const element = getNativeByTNode(tNode, lView);
setElementAttribute(lView[RENDERER], element, namespace, tNode.value, name2, value2, sanitizer);
}
function setElementAttribute(renderer2, element, namespace, tagName, name2, value2, sanitizer) {
if (value2 == null) {
ngDevMode && ngDevMode.rendererRemoveAttribute++;
renderer2.removeAttribute(element, name2, namespace);
} else {
ngDevMode && ngDevMode.rendererSetAttribute++;
const strValue = sanitizer == null ? renderStringify(value2) : sanitizer(value2, tagName || "", name2);
renderer2.setAttribute(element, name2, strValue, namespace);
}
}
function setInputsFromAttrs(lView, directiveIndex, instance, def, tNode, initialInputData) {
const initialInputs = initialInputData[directiveIndex];
if (initialInputs !== null) {
for (let i = 0; i < initialInputs.length; ) {
const publicName = initialInputs[i++];
const privateName = initialInputs[i++];
const flags = initialInputs[i++];
const value2 = initialInputs[i++];
writeToDirectiveInput(def, instance, publicName, privateName, flags, value2);
if (ngDevMode) {
const nativeElement = getNativeByTNode(tNode, lView);
setNgReflectProperty(lView, nativeElement, tNode.type, privateName, value2);
}
}
}
}
function generateInitialInputs(inputs, directiveIndex, attrs) {
let inputsToStore = null;
let i = 0;
while (i < attrs.length) {
const attrName = attrs[i];
if (attrName === 0) {
i += 4;
continue;
} else if (attrName === 5) {
i += 2;
continue;
}
if (typeof attrName === "number")
break;
if (inputs.hasOwnProperty(attrName)) {
if (inputsToStore === null)
inputsToStore = [];
const inputConfig = inputs[attrName];
for (let j = 0; j < inputConfig.length; j += 3) {
if (inputConfig[j] === directiveIndex) {
inputsToStore.push(attrName, inputConfig[j + 1], inputConfig[j + 2], attrs[i + 1]);
break;
}
}
}
i += 2;
}
return inputsToStore;
}
function createLContainer(hostNative, currentView, native, tNode) {
ngDevMode && assertLView(currentView);
const lContainer = [
hostNative,
// host native
true,
// Boolean `true` in this position signifies that this is an `LContainer`
0,
// flags
currentView,
// parent
null,
// next
tNode,
// t_host
null,
// dehydrated views
native,
// native,
null,
// view refs
null
// moved views
];
ngDevMode && assertEqual(lContainer.length, CONTAINER_HEADER_OFFSET, "Should allocate correct number of slots for LContainer header.");
return lContainer;
}
function refreshContentQueries(tView, lView) {
const contentQueries = tView.contentQueries;
if (contentQueries !== null) {
const prevConsumer = setActiveConsumer(null);
try {
for (let i = 0; i < contentQueries.length; i += 2) {
const queryStartIdx = contentQueries[i];
const directiveDefIdx = contentQueries[i + 1];
if (directiveDefIdx !== -1) {
const directiveDef = tView.data[directiveDefIdx];
ngDevMode && assertDefined(directiveDef, "DirectiveDef not found.");
ngDevMode && assertDefined(directiveDef.contentQueries, "contentQueries function should be defined");
setCurrentQueryIndex(queryStartIdx);
directiveDef.contentQueries(2, lView[directiveDefIdx], directiveDefIdx);
}
}
} finally {
setActiveConsumer(prevConsumer);
}
}
}
function addToViewTree(lView, lViewOrLContainer) {
if (lView[CHILD_HEAD]) {
lView[CHILD_TAIL][NEXT] = lViewOrLContainer;
} else {
lView[CHILD_HEAD] = lViewOrLContainer;
}
lView[CHILD_TAIL] = lViewOrLContainer;
return lViewOrLContainer;
}
function executeViewQueryFn(flags, viewQueryFn, component) {
ngDevMode && assertDefined(viewQueryFn, "View queries function to execute must be defined.");
setCurrentQueryIndex(0);
const prevConsumer = setActiveConsumer(null);
try {
viewQueryFn(flags, component);
} finally {
setActiveConsumer(prevConsumer);
}
}
function storePropertyBindingMetadata(tData, tNode, propertyName, bindingIndex, ...interpolationParts) {
if (tData[bindingIndex] === null) {
if (tNode.inputs == null || !tNode.inputs[propertyName]) {
const propBindingIdxs = tNode.propertyBindings || (tNode.propertyBindings = []);
propBindingIdxs.push(bindingIndex);
let bindingMetadata = propertyName;
if (interpolationParts.length > 0) {
bindingMetadata += INTERPOLATION_DELIMITER + interpolationParts.join(INTERPOLATION_DELIMITER);
}
tData[bindingIndex] = bindingMetadata;
}
}
}
function getOrCreateLViewCleanup(view) {
return view[CLEANUP] || (view[CLEANUP] = []);
}
function getOrCreateTViewCleanup(tView) {
return tView.cleanup || (tView.cleanup = []);
}
function loadComponentRenderer(currentDef, tNode, lView) {
if (currentDef === null || isComponentDef(currentDef)) {
lView = unwrapLView(lView[tNode.index]);
}
return lView[RENDERER];
}
function handleError(lView, error) {
const injector = lView[INJECTOR];
const errorHandler2 = injector ? injector.get(ErrorHandler, null) : null;
errorHandler2 && errorHandler2.handleError(error);
}
function setInputsForProperty(tView, lView, inputs, publicName, value2) {
for (let i = 0; i < inputs.length; ) {
const index2 = inputs[i++];
const privateName = inputs[i++];
const flags = inputs[i++];
const instance = lView[index2];
ngDevMode && assertIndexInRange(lView, index2);
const def = tView.data[index2];
writeToDirectiveInput(def, instance, publicName, privateName, flags, value2);
}
}
function textBindingInternal(lView, index2, value2) {
ngDevMode && assertString(value2, "Value should be a string");
ngDevMode && assertNotSame(value2, NO_CHANGE, "value should not be NO_CHANGE");
ngDevMode && assertIndexInRange(lView, index2);
const element = getNativeByIndex(index2, lView);
ngDevMode && assertDefined(element, "native element should exist");
updateTextNode(lView[RENDERER], element, value2);
}
function renderComponent(hostLView, componentHostIdx) {
ngDevMode && assertEqual(isCreationMode(hostLView), true, "Should be run in creation mode");
const componentView = getComponentLViewByIndex(componentHostIdx, hostLView);
const componentTView = componentView[TVIEW];
syncViewWithBlueprint(componentTView, componentView);
const hostRNode = componentView[HOST];
if (hostRNode !== null && componentView[HYDRATION] === null) {
componentView[HYDRATION] = retrieveHydrationInfo(hostRNode, componentView[INJECTOR]);
}
renderView(componentTView, componentView, componentView[CONTEXT]);
}
function syncViewWithBlueprint(tView, lView) {
for (let i = lView.length; i < tView.blueprint.length; i++) {
lView.push(tView.blueprint[i]);
}
}
function renderView(tView, lView, context2) {
ngDevMode && assertEqual(isCreationMode(lView), true, "Should be run in creation mode");
ngDevMode && assertNotReactive(renderView.name);
enterView(lView);
try {
const viewQuery = tView.viewQuery;
if (viewQuery !== null) {
executeViewQueryFn(1, viewQuery, context2);
}
const templateFn = tView.template;
if (templateFn !== null) {
executeTemplate(tView, lView, templateFn, 1, context2);
}
if (tView.firstCreatePass) {
tView.firstCreatePass = false;
}
lView[QUERIES]?.finishViewCreation(tView);
if (tView.staticContentQueries) {
refreshContentQueries(tView, lView);
}
if (tView.staticViewQueries) {
executeViewQueryFn(2, tView.viewQuery, context2);
}
const components = tView.components;
if (components !== null) {
renderChildComponents(lView, components);
}
} catch (error) {
if (tView.firstCreatePass) {
tView.incompleteFirstPass = true;
tView.firstCreatePass = false;
}
throw error;
} finally {
lView[FLAGS] &= ~4;
leaveView();
}
}
function renderChildComponents(hostLView, components) {
for (let i = 0; i < components.length; i++) {
renderComponent(hostLView, components[i]);
}
}
function createAndRenderEmbeddedLView(declarationLView, templateTNode, context2, options) {
const prevConsumer = setActiveConsumer(null);
try {
const embeddedTView = templateTNode.tView;
ngDevMode && assertDefined(embeddedTView, "TView must be defined for a template node.");
ngDevMode && assertTNodeForLView(templateTNode, declarationLView);
const isSignalView = declarationLView[FLAGS] & 4096;
const viewFlags = isSignalView ? 4096 : 16;
const embeddedLView = createLView(declarationLView, embeddedTView, context2, viewFlags, null, templateTNode, null, null, options?.injector ?? null, options?.embeddedViewInjector ?? null, options?.dehydratedView ?? null);
const declarationLContainer = declarationLView[templateTNode.index];
ngDevMode && assertLContainer(declarationLContainer);
embeddedLView[DECLARATION_LCONTAINER] = declarationLContainer;
const declarationViewLQueries = declarationLView[QUERIES];
if (declarationViewLQueries !== null) {
embeddedLView[QUERIES] = declarationViewLQueries.createEmbeddedView(embeddedTView);
}
renderView(embeddedTView, embeddedLView, context2);
return embeddedLView;
} finally {
setActiveConsumer(prevConsumer);
}
}
function getLViewFromLContainer(lContainer, index2) {
const adjustedIndex = CONTAINER_HEADER_OFFSET + index2;
if (adjustedIndex < lContainer.length) {
const lView = lContainer[adjustedIndex];
ngDevMode && assertLView(lView);
return lView;
}
return void 0;
}
function shouldAddViewToDom(tNode, dehydratedView) {
return !dehydratedView || dehydratedView.firstChild === null || hasInSkipHydrationBlockFlag(tNode);
}
function addLViewToLContainer(lContainer, lView, index2, addToDOM = true) {
const tView = lView[TVIEW];
insertView(tView, lView, lContainer, index2);
if (addToDOM) {
const beforeNode = getBeforeNodeForView(index2, lContainer);
const renderer2 = lView[RENDERER];
const parentRNode = nativeParentNode(renderer2, lContainer[NATIVE]);
if (parentRNode !== null) {
addViewToDOM(tView, lContainer[T_HOST], renderer2, lView, parentRNode, beforeNode);
}
}
const hydrationInfo = lView[HYDRATION];
if (hydrationInfo !== null && hydrationInfo.firstChild !== null) {
hydrationInfo.firstChild = null;
}
}
function removeLViewFromLContainer(lContainer, index2) {
const lView = detachView(lContainer, index2);
if (lView !== void 0) {
destroyLView(lView[TVIEW], lView);
}
return lView;
}
function collectNativeNodes(tView, lView, tNode, result, isProjection = false) {
while (tNode !== null) {
ngDevMode && assertTNodeType(
tNode,
3 | 12 | 16 | 32
/* TNodeType.Icu */
);
const lNode = lView[tNode.index];
if (lNode !== null) {
result.push(unwrapRNode(lNode));
}
if (isLContainer(lNode)) {
collectNativeNodesInLContainer(lNode, result);
}
const tNodeType = tNode.type;
if (tNodeType & 8) {
collectNativeNodes(tView, lView, tNode.child, result);
} else if (tNodeType & 32) {
const nextRNode = icuContainerIterate(tNode, lView);
let rNode;
while (rNode = nextRNode()) {
result.push(rNode);
}
} else if (tNodeType & 16) {
const nodesInSlot = getProjectionNodes(lView, tNode);
if (Array.isArray(nodesInSlot)) {
result.push(...nodesInSlot);
} else {
const parentView = getLViewParent(lView[DECLARATION_COMPONENT_VIEW]);
ngDevMode && assertParentView(parentView);
collectNativeNodes(parentView[TVIEW], parentView, nodesInSlot, result, true);
}
}
tNode = isProjection ? tNode.projectionNext : tNode.next;
}
return result;
}
function collectNativeNodesInLContainer(lContainer, result) {
for (let i = CONTAINER_HEADER_OFFSET; i < lContainer.length; i++) {
const lViewInAContainer = lContainer[i];
const lViewFirstChildTNode = lViewInAContainer[TVIEW].firstChild;
if (lViewFirstChildTNode !== null) {
collectNativeNodes(lViewInAContainer[TVIEW], lViewInAContainer, lViewFirstChildTNode, result);
}
}
if (lContainer[NATIVE] !== lContainer[HOST]) {
result.push(lContainer[NATIVE]);
}
}
var freeConsumers = [];
function getOrBorrowReactiveLViewConsumer(lView) {
return lView[REACTIVE_TEMPLATE_CONSUMER] ?? borrowReactiveLViewConsumer(lView);
}
function borrowReactiveLViewConsumer(lView) {
const consumer = freeConsumers.pop() ?? Object.create(REACTIVE_LVIEW_CONSUMER_NODE);
consumer.lView = lView;
return consumer;
}
function maybeReturnReactiveLViewConsumer(consumer) {
if (consumer.lView[REACTIVE_TEMPLATE_CONSUMER] === consumer) {
return;
}
consumer.lView = null;
freeConsumers.push(consumer);
}
var REACTIVE_LVIEW_CONSUMER_NODE = __spreadProps(__spreadValues({}, REACTIVE_NODE), {
consumerIsAlwaysLive: true,
consumerMarkedDirty: (node) => {
markAncestorsForTraversal(node.lView);
},
consumerOnSignalRead() {
this.lView[REACTIVE_TEMPLATE_CONSUMER] = this;
}
});
var MAXIMUM_REFRESH_RERUNS = 100;
function detectChangesInternal(lView, notifyErrorHandler = true, mode = 0) {
const environment2 = lView[ENVIRONMENT];
const rendererFactory = environment2.rendererFactory;
const checkNoChangesMode = !!ngDevMode && isInCheckNoChangesMode();
if (!checkNoChangesMode) {
rendererFactory.begin?.();
}
try {
detectChangesInViewWhileDirty(lView, mode);
} catch (error) {
if (notifyErrorHandler) {
handleError(lView, error);
}
throw error;
} finally {
if (!checkNoChangesMode) {
rendererFactory.end?.();
environment2.inlineEffectRunner?.flush();
}
}
}
function detectChangesInViewWhileDirty(lView, mode) {
detectChangesInView$1(lView, mode);
let retries = 0;
while (requiresRefreshOrTraversal(lView)) {
if (retries === MAXIMUM_REFRESH_RERUNS) {
throw new RuntimeError(103, ngDevMode && "Infinite change detection while trying to refresh views. There may be components which each cause the other to require a refresh, causing an infinite loop.");
}
retries++;
detectChangesInView$1(
lView,
1
/* ChangeDetectionMode.Targeted */
);
}
}
function checkNoChangesInternal(lView, notifyErrorHandler = true) {
setIsInCheckNoChangesMode(true);
try {
detectChangesInternal(lView, notifyErrorHandler);
} finally {
setIsInCheckNoChangesMode(false);
}
}
function refreshView(tView, lView, templateFn, context2) {
ngDevMode && assertEqual(isCreationMode(lView), false, "Should be run in update mode");
const flags = lView[FLAGS];
if ((flags & 256) === 256)
return;
const isInCheckNoChangesPass = ngDevMode && isInCheckNoChangesMode();
!isInCheckNoChangesPass && lView[ENVIRONMENT].inlineEffectRunner?.flush();
enterView(lView);
let prevConsumer = null;
let currentConsumer = null;
if (!isInCheckNoChangesPass && viewShouldHaveReactiveConsumer(tView)) {
currentConsumer = getOrBorrowReactiveLViewConsumer(lView);
prevConsumer = consumerBeforeComputation(currentConsumer);
}
try {
resetPreOrderHookFlags(lView);
setBindingIndex(tView.bindingStartIndex);
if (templateFn !== null) {
executeTemplate(tView, lView, templateFn, 2, context2);
}
const hooksInitPhaseCompleted = (flags & 3) === 3;
if (!isInCheckNoChangesPass) {
if (hooksInitPhaseCompleted) {
const preOrderCheckHooks = tView.preOrderCheckHooks;
if (preOrderCheckHooks !== null) {
executeCheckHooks(lView, preOrderCheckHooks, null);
}
} else {
const preOrderHooks = tView.preOrderHooks;
if (preOrderHooks !== null) {
executeInitAndCheckHooks(lView, preOrderHooks, 0, null);
}
incrementInitPhaseFlags(
lView,
0
/* InitPhaseState.OnInitHooksToBeRun */
);
}
}
markTransplantedViewsForRefresh(lView);
detectChangesInEmbeddedViews(
lView,
0
/* ChangeDetectionMode.Global */
);
if (tView.contentQueries !== null) {
refreshContentQueries(tView, lView);
}
if (!isInCheckNoChangesPass) {
if (hooksInitPhaseCompleted) {
const contentCheckHooks = tView.contentCheckHooks;
if (contentCheckHooks !== null) {
executeCheckHooks(lView, contentCheckHooks);
}
} else {
const contentHooks = tView.contentHooks;
if (contentHooks !== null) {
executeInitAndCheckHooks(
lView,
contentHooks,
1
/* InitPhaseState.AfterContentInitHooksToBeRun */
);
}
incrementInitPhaseFlags(
lView,
1
/* InitPhaseState.AfterContentInitHooksToBeRun */
);
}
}
processHostBindingOpCodes(tView, lView);
const components = tView.components;
if (components !== null) {
detectChangesInChildComponents(
lView,
components,
0
/* ChangeDetectionMode.Global */
);
}
const viewQuery = tView.viewQuery;
if (viewQuery !== null) {
executeViewQueryFn(2, viewQuery, context2);
}
if (!isInCheckNoChangesPass) {
if (hooksInitPhaseCompleted) {
const viewCheckHooks = tView.viewCheckHooks;
if (viewCheckHooks !== null) {
executeCheckHooks(lView, viewCheckHooks);
}
} else {
const viewHooks = tView.viewHooks;
if (viewHooks !== null) {
executeInitAndCheckHooks(
lView,
viewHooks,
2
/* InitPhaseState.AfterViewInitHooksToBeRun */
);
}
incrementInitPhaseFlags(
lView,
2
/* InitPhaseState.AfterViewInitHooksToBeRun */
);
}
}
if (tView.firstUpdatePass === true) {
tView.firstUpdatePass = false;
}
if (lView[EFFECTS_TO_SCHEDULE]) {
for (const notifyEffect of lView[EFFECTS_TO_SCHEDULE]) {
notifyEffect();
}
lView[EFFECTS_TO_SCHEDULE] = null;
}
if (!isInCheckNoChangesPass) {
lView[FLAGS] &= ~(64 | 8);
}
} catch (e) {
markAncestorsForTraversal(lView);
throw e;
} finally {
if (currentConsumer !== null) {
consumerAfterComputation(currentConsumer, prevConsumer);
maybeReturnReactiveLViewConsumer(currentConsumer);
}
leaveView();
}
}
function viewShouldHaveReactiveConsumer(tView) {
return tView.type !== 2;
}
function detectChangesInEmbeddedViews(lView, mode) {
for (let lContainer = getFirstLContainer(lView); lContainer !== null; lContainer = getNextLContainer(lContainer)) {
for (let i = CONTAINER_HEADER_OFFSET; i < lContainer.length; i++) {
const embeddedLView = lContainer[i];
detectChangesInViewIfAttached(embeddedLView, mode);
}
}
}
function markTransplantedViewsForRefresh(lView) {
for (let lContainer = getFirstLContainer(lView); lContainer !== null; lContainer = getNextLContainer(lContainer)) {
if (!(lContainer[FLAGS] & LContainerFlags.HasTransplantedViews))
continue;
const movedViews = lContainer[MOVED_VIEWS];
ngDevMode && assertDefined(movedViews, "Transplanted View flags set but missing MOVED_VIEWS");
for (let i = 0; i < movedViews.length; i++) {
const movedLView = movedViews[i];
const insertionLContainer = movedLView[PARENT];
ngDevMode && assertLContainer(insertionLContainer);
markViewForRefresh(movedLView);
}
}
}
function detectChangesInComponent(hostLView, componentHostIdx, mode) {
ngDevMode && assertEqual(isCreationMode(hostLView), false, "Should be run in update mode");
const componentView = getComponentLViewByIndex(componentHostIdx, hostLView);
detectChangesInViewIfAttached(componentView, mode);
}
function detectChangesInViewIfAttached(lView, mode) {
if (!viewAttachedToChangeDetector(lView)) {
return;
}
detectChangesInView$1(lView, mode);
}
function detectChangesInView$1(lView, mode) {
const isInCheckNoChangesPass = ngDevMode && isInCheckNoChangesMode();
const tView = lView[TVIEW];
const flags = lView[FLAGS];
const consumer = lView[REACTIVE_TEMPLATE_CONSUMER];
let shouldRefreshView = !!(mode === 0 && flags & 16);
shouldRefreshView ||= !!(flags & 64 && mode === 0 && !isInCheckNoChangesPass);
shouldRefreshView ||= !!(flags & 1024);
shouldRefreshView ||= !!(consumer?.dirty && consumerPollProducersForChange(consumer));
if (consumer) {
consumer.dirty = false;
}
lView[FLAGS] &= ~(8192 | 1024);
if (shouldRefreshView) {
refreshView(tView, lView, tView.template, lView[CONTEXT]);
} else if (flags & 8192) {
detectChangesInEmbeddedViews(
lView,
1
/* ChangeDetectionMode.Targeted */
);
const components = tView.components;
if (components !== null) {
detectChangesInChildComponents(
lView,
components,
1
/* ChangeDetectionMode.Targeted */
);
}
}
}
function detectChangesInChildComponents(hostLView, components, mode) {
for (let i = 0; i < components.length; i++) {
detectChangesInComponent(hostLView, components[i], mode);
}
}
function markViewDirty(lView) {
lView[ENVIRONMENT].changeDetectionScheduler?.notify();
while (lView) {
lView[FLAGS] |= 64;
const parent2 = getLViewParent(lView);
if (isRootView(lView) && !parent2) {
return lView;
}
lView = parent2;
}
return null;
}
var ViewRef$1 = class {
get rootNodes() {
const lView = this._lView;
const tView = lView[TVIEW];
return collectNativeNodes(tView, lView, tView.firstChild, []);
}
constructor(_lView, _cdRefInjectingView, notifyErrorHandler = true) {
this._lView = _lView;
this._cdRefInjectingView = _cdRefInjectingView;
this.notifyErrorHandler = notifyErrorHandler;
this._appRef = null;
this._attachedToViewContainer = false;
}
get context() {
return this._lView[CONTEXT];
}
/**
* @deprecated Replacing the full context object is not supported. Modify the context
* directly, or consider using a `Proxy` if you need to replace the full object.
* // TODO(devversion): Remove this.
*/
set context(value2) {
if (ngDevMode) {
console.warn("Angular: Replacing the `context` object of an `EmbeddedViewRef` is deprecated.");
}
this._lView[CONTEXT] = value2;
}
get destroyed() {
return (this._lView[FLAGS] & 256) === 256;
}
destroy() {
if (this._appRef) {
this._appRef.detachView(this);
} else if (this._attachedToViewContainer) {
const parent2 = this._lView[PARENT];
if (isLContainer(parent2)) {
const viewRefs = parent2[VIEW_REFS];
const index2 = viewRefs ? viewRefs.indexOf(this) : -1;
if (index2 > -1) {
ngDevMode && assertEqual(index2, parent2.indexOf(this._lView) - CONTAINER_HEADER_OFFSET, "An attached view should be in the same position within its container as its ViewRef in the VIEW_REFS array.");
detachView(parent2, index2);
removeFromArray(viewRefs, index2);
}
}
this._attachedToViewContainer = false;
}
destroyLView(this._lView[TVIEW], this._lView);
}
onDestroy(callback) {
storeLViewOnDestroy(this._lView, callback);
}
/**
* Marks a view and all of its ancestors dirty.
*
* This can be used to ensure an {@link ChangeDetectionStrategy#OnPush} component is
* checked when it needs to be re-rendered but the two normal triggers haven't marked it
* dirty (i.e. inputs haven't changed and events haven't fired in the view).
*
* <!-- TODO: Add a link to a chapter on OnPush components -->
*
* @usageNotes
* ### Example
*
* ```typescript
* @Component({
* selector: 'app-root',
* template: `Number of ticks: {{numberOfTicks}}`
* changeDetection: ChangeDetectionStrategy.OnPush,
* })
* class AppComponent {
* numberOfTicks = 0;
*
* constructor(private ref: ChangeDetectorRef) {
* setInterval(() => {
* this.numberOfTicks++;
* // the following is required, otherwise the view will not be updated
* this.ref.markForCheck();
* }, 1000);
* }
* }
* ```
*/
markForCheck() {
markViewDirty(this._cdRefInjectingView || this._lView);
}
/**
* Detaches the view from the change detection tree.
*
* Detached views will not be checked during change detection runs until they are
* re-attached, even if they are dirty. `detach` can be used in combination with
* {@link ChangeDetectorRef#detectChanges} to implement local change
* detection checks.
*
* <!-- TODO: Add a link to a chapter on detach/reattach/local digest -->
* <!-- TODO: Add a live demo once ref.detectChanges is merged into master -->
*
* @usageNotes
* ### Example
*
* The following example defines a component with a large list of readonly data.
* Imagine the data changes constantly, many times per second. For performance reasons,
* we want to check and update the list every five seconds. We can do that by detaching
* the component's change detector and doing a local check every five seconds.
*
* ```typescript
* class DataProvider {
* // in a real application the returned data will be different every time
* get data() {
* return [1,2,3,4,5];
* }
* }
*
* @Component({
* selector: 'giant-list',
* template: `
* <li *ngFor="let d of dataProvider.data">Data {{d}}</li>
* `,
* })
* class GiantList {
* constructor(private ref: ChangeDetectorRef, private dataProvider: DataProvider) {
* ref.detach();
* setInterval(() => {
* this.ref.detectChanges();
* }, 5000);
* }
* }
*
* @Component({
* selector: 'app',
* providers: [DataProvider],
* template: `
* <giant-list><giant-list>
* `,
* })
* class App {
* }
* ```
*/
detach() {
this._lView[FLAGS] &= ~128;
}
/**
* Re-attaches a view to the change detection tree.
*
* This can be used to re-attach views that were previously detached from the tree
* using {@link ChangeDetectorRef#detach}. Views are attached to the tree by default.
*
* <!-- TODO: Add a link to a chapter on detach/reattach/local digest -->
*
* @usageNotes
* ### Example
*
* The following example creates a component displaying `live` data. The component will detach
* its change detector from the main change detector tree when the component's live property
* is set to false.
*
* ```typescript
* class DataProvider {
* data = 1;
*
* constructor() {
* setInterval(() => {
* this.data = this.data * 2;
* }, 500);
* }
* }
*
* @Component({
* selector: 'live-data',
* inputs: ['live'],
* template: 'Data: {{dataProvider.data}}'
* })
* class LiveData {
* constructor(private ref: ChangeDetectorRef, private dataProvider: DataProvider) {}
*
* set live(value) {
* if (value) {
* this.ref.reattach();
* } else {
* this.ref.detach();
* }
* }
* }
*
* @Component({
* selector: 'app-root',
* providers: [DataProvider],
* template: `
* Live Update: <input type="checkbox" [(ngModel)]="live">
* <live-data [live]="live"><live-data>
* `,
* })
* class AppComponent {
* live = true;
* }
* ```
*/
reattach() {
updateAncestorTraversalFlagsOnAttach(this._lView);
this._lView[FLAGS] |= 128;
}
/**
* Checks the view and its children.
*
* This can also be used in combination with {@link ChangeDetectorRef#detach} to implement
* local change detection checks.
*
* <!-- TODO: Add a link to a chapter on detach/reattach/local digest -->
* <!-- TODO: Add a live demo once ref.detectChanges is merged into master -->
*
* @usageNotes
* ### Example
*
* The following example defines a component with a large list of readonly data.
* Imagine, the data changes constantly, many times per second. For performance reasons,
* we want to check and update the list every five seconds.
*
* We can do that by detaching the component's change detector and doing a local change detection
* check every five seconds.
*
* See {@link ChangeDetectorRef#detach} for more information.
*/
detectChanges() {
this._lView[FLAGS] |= 1024;
detectChangesInternal(this._lView, this.notifyErrorHandler);
}
/**
* Checks the change detector and its children, and throws if any changes are detected.
*
* This is used in development mode to verify that running change detection doesn't
* introduce other changes.
*/
checkNoChanges() {
if (ngDevMode) {
checkNoChangesInternal(this._lView, this.notifyErrorHandler);
}
}
attachToViewContainerRef() {
if (this._appRef) {
throw new RuntimeError(902, ngDevMode && "This view is already attached directly to the ApplicationRef!");
}
this._attachedToViewContainer = true;
}
detachFromAppRef() {
this._appRef = null;
detachViewFromDOM(this._lView[TVIEW], this._lView);
}
attachToAppRef(appRef) {
if (this._attachedToViewContainer) {
throw new RuntimeError(902, ngDevMode && "This view is already attached to a ViewContainer!");
}
this._appRef = appRef;
updateAncestorTraversalFlagsOnAttach(this._lView);
}
};
var _TemplateRef = class _TemplateRef {
};
_TemplateRef.__NG_ELEMENT_ID__ = injectTemplateRef;
var TemplateRef = _TemplateRef;
var ViewEngineTemplateRef = TemplateRef;
var R3TemplateRef = class TemplateRef2 extends ViewEngineTemplateRef {
constructor(_declarationLView, _declarationTContainer, elementRef) {
super();
this._declarationLView = _declarationLView;
this._declarationTContainer = _declarationTContainer;
this.elementRef = elementRef;
}
/**
* Returns an `ssrId` associated with a TView, which was used to
* create this instance of the `TemplateRef`.
*
* @internal
*/
get ssrId() {
return this._declarationTContainer.tView?.ssrId || null;
}
createEmbeddedView(context2, injector) {
return this.createEmbeddedViewImpl(context2, injector);
}
/**
* @internal
*/
createEmbeddedViewImpl(context2, injector, dehydratedView) {
const embeddedLView = createAndRenderEmbeddedLView(this._declarationLView, this._declarationTContainer, context2, { embeddedViewInjector: injector, dehydratedView });
return new ViewRef$1(embeddedLView);
}
};
function injectTemplateRef() {
return createTemplateRef(getCurrentTNode(), getLView());
}
function createTemplateRef(hostTNode, hostLView) {
if (hostTNode.type & 4) {
ngDevMode && assertDefined(hostTNode.tView, "TView must be allocated");
return new R3TemplateRef(hostLView, hostTNode, createElementRef(hostTNode, hostLView));
}
return null;
}
var REF_EXTRACTOR_REGEXP = new RegExp(`^(\\d+)*(${REFERENCE_NODE_BODY}|${REFERENCE_NODE_HOST})*(.*)`);
var _findMatchingDehydratedViewImpl = () => null;
function findMatchingDehydratedView(lContainer, template) {
return _findMatchingDehydratedViewImpl(lContainer, template);
}
var ChangeDetectionScheduler = class {
};
var ComponentRef$1 = class {
};
var ComponentFactory$1 = class {
};
function noComponentFactoryError(component) {
const error = Error(`No component factory found for ${stringify(component)}.`);
error[ERROR_COMPONENT] = component;
return error;
}
var ERROR_COMPONENT = "ngComponent";
var _NullComponentFactoryResolver = class {
resolveComponentFactory(component) {
throw noComponentFactoryError(component);
}
};
var _ComponentFactoryResolver$1 = class _ComponentFactoryResolver$1 {
};
_ComponentFactoryResolver$1.NULL = /* @__PURE__ */ new _NullComponentFactoryResolver();
var ComponentFactoryResolver$1 = _ComponentFactoryResolver$1;
var RendererFactory2 = class {
};
var _Renderer2 = class _Renderer2 {
constructor() {
this.destroyNode = null;
}
};
_Renderer2.__NG_ELEMENT_ID__ = () => injectRenderer2();
var Renderer2 = _Renderer2;
function injectRenderer2() {
const lView = getLView();
const tNode = getCurrentTNode();
const nodeAtIndex = getComponentLViewByIndex(tNode.index, lView);
return (isLView(nodeAtIndex) ? nodeAtIndex : lView)[RENDERER];
}
var _Sanitizer = class _Sanitizer {
};
_Sanitizer.\u0275prov = \u0275\u0275defineInjectable({
token: _Sanitizer,
providedIn: "root",
factory: () => null
});
var Sanitizer = _Sanitizer;
var NOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR = {};
var markedFeatures = /* @__PURE__ */ new Set();
function performanceMarkFeature(feature) {
if (markedFeatures.has(feature)) {
return;
}
markedFeatures.add(feature);
performance?.mark?.("mark_feature_usage", { detail: { feature } });
}
function noop2(...args) {
}
function getNativeRequestAnimationFrame() {
const isBrowser = typeof _global["requestAnimationFrame"] === "function";
let nativeRequestAnimationFrame = _global[isBrowser ? "requestAnimationFrame" : "setTimeout"];
let nativeCancelAnimationFrame = _global[isBrowser ? "cancelAnimationFrame" : "clearTimeout"];
if (typeof Zone !== "undefined" && nativeRequestAnimationFrame && nativeCancelAnimationFrame) {
const unpatchedRequestAnimationFrame = nativeRequestAnimationFrame[Zone.__symbol__("OriginalDelegate")];
if (unpatchedRequestAnimationFrame) {
nativeRequestAnimationFrame = unpatchedRequestAnimationFrame;
}
const unpatchedCancelAnimationFrame = nativeCancelAnimationFrame[Zone.__symbol__("OriginalDelegate")];
if (unpatchedCancelAnimationFrame) {
nativeCancelAnimationFrame = unpatchedCancelAnimationFrame;
}
}
return { nativeRequestAnimationFrame, nativeCancelAnimationFrame };
}
var AsyncStackTaggingZoneSpec = class {
constructor(namePrefix, consoleAsyncStackTaggingImpl = console) {
this.name = "asyncStackTagging for " + namePrefix;
this.createTask = consoleAsyncStackTaggingImpl?.createTask ?? (() => null);
}
onScheduleTask(delegate, _current, target, task) {
task.consoleTask = this.createTask(`Zone - ${task.source || task.type}`);
return delegate.scheduleTask(target, task);
}
onInvokeTask(delegate, _currentZone, targetZone, task, applyThis, applyArgs) {
let ret;
if (task.consoleTask) {
ret = task.consoleTask.run(() => delegate.invokeTask(targetZone, task, applyThis, applyArgs));
} else {
ret = delegate.invokeTask(targetZone, task, applyThis, applyArgs);
}
return ret;
}
};
var NgZone = class _NgZone {
constructor({ enableLongStackTrace = false, shouldCoalesceEventChangeDetection = false, shouldCoalesceRunChangeDetection = false }) {
this.hasPendingMacrotasks = false;
this.hasPendingMicrotasks = false;
this.isStable = true;
this.onUnstable = new EventEmitter(false);
this.onMicrotaskEmpty = new EventEmitter(false);
this.onStable = new EventEmitter(false);
this.onError = new EventEmitter(false);
if (typeof Zone == "undefined") {
throw new RuntimeError(908, ngDevMode && `In this configuration Angular requires Zone.js`);
}
Zone.assertZonePatched();
const self2 = this;
self2._nesting = 0;
self2._outer = self2._inner = Zone.current;
if (ngDevMode) {
self2._inner = self2._inner.fork(new AsyncStackTaggingZoneSpec("Angular"));
}
if (Zone["TaskTrackingZoneSpec"]) {
self2._inner = self2._inner.fork(new Zone["TaskTrackingZoneSpec"]());
}
if (enableLongStackTrace && Zone["longStackTraceZoneSpec"]) {
self2._inner = self2._inner.fork(Zone["longStackTraceZoneSpec"]);
}
self2.shouldCoalesceEventChangeDetection = !shouldCoalesceRunChangeDetection && shouldCoalesceEventChangeDetection;
self2.shouldCoalesceRunChangeDetection = shouldCoalesceRunChangeDetection;
self2.lastRequestAnimationFrameId = -1;
self2.nativeRequestAnimationFrame = getNativeRequestAnimationFrame().nativeRequestAnimationFrame;
forkInnerZoneWithAngularBehavior(self2);
}
/**
This method checks whether the method call happens within an Angular Zone instance.
*/
static isInAngularZone() {
return typeof Zone !== "undefined" && Zone.current.get("isAngularZone") === true;
}
/**
Assures that the method is called within the Angular Zone, otherwise throws an error.
*/
static assertInAngularZone() {
if (!_NgZone.isInAngularZone()) {
throw new RuntimeError(909, ngDevMode && "Expected to be in Angular Zone, but it is not!");
}
}
/**
Assures that the method is called outside of the Angular Zone, otherwise throws an error.
*/
static assertNotInAngularZone() {
if (_NgZone.isInAngularZone()) {
throw new RuntimeError(909, ngDevMode && "Expected to not be in Angular Zone, but it is!");
}
}
/**
* Executes the `fn` function synchronously within the Angular zone and returns value returned by
* the function.
*
* Running functions via `run` allows you to reenter Angular zone from a task that was executed
* outside of the Angular zone (typically started via {@link #runOutsideAngular}).
*
* Any future tasks or microtasks scheduled from within this function will continue executing from
* within the Angular zone.
*
* If a synchronous error happens it will be rethrown and not reported via `onError`.
*/
run(fn, applyThis, applyArgs) {
return this._inner.run(fn, applyThis, applyArgs);
}
/**
* Executes the `fn` function synchronously within the Angular zone as a task and returns value
* returned by the function.
*
* Running functions via `run` allows you to reenter Angular zone from a task that was executed
* outside of the Angular zone (typically started via {@link #runOutsideAngular}).
*
* Any future tasks or microtasks scheduled from within this function will continue executing from
* within the Angular zone.
*
* If a synchronous error happens it will be rethrown and not reported via `onError`.
*/
runTask(fn, applyThis, applyArgs, name2) {
const zone = this._inner;
const task = zone.scheduleEventTask("NgZoneEvent: " + name2, fn, EMPTY_PAYLOAD, noop2, noop2);
try {
return zone.runTask(task, applyThis, applyArgs);
} finally {
zone.cancelTask(task);
}
}
/**
* Same as `run`, except that synchronous errors are caught and forwarded via `onError` and not
* rethrown.
*/
runGuarded(fn, applyThis, applyArgs) {
return this._inner.runGuarded(fn, applyThis, applyArgs);
}
/**
* Executes the `fn` function synchronously in Angular's parent zone and returns value returned by
* the function.
*
* Running functions via {@link #runOutsideAngular} allows you to escape Angular's zone and do
* work that
* doesn't trigger Angular change-detection or is subject to Angular's error handling.
*
* Any future tasks or microtasks scheduled from within this function will continue executing from
* outside of the Angular zone.
*
* Use {@link #run} to reenter the Angular zone and do work that updates the application model.
*/
runOutsideAngular(fn) {
return this._outer.run(fn);
}
};
var EMPTY_PAYLOAD = {};
function checkStable(zone) {
if (zone._nesting == 0 && !zone.hasPendingMicrotasks && !zone.isStable) {
try {
zone._nesting++;
zone.onMicrotaskEmpty.emit(null);
} finally {
zone._nesting--;
if (!zone.hasPendingMicrotasks) {
try {
zone.runOutsideAngular(() => zone.onStable.emit(null));
} finally {
zone.isStable = true;
}
}
}
}
}
function delayChangeDetectionForEvents(zone) {
if (zone.isCheckStableRunning || zone.lastRequestAnimationFrameId !== -1) {
return;
}
zone.lastRequestAnimationFrameId = zone.nativeRequestAnimationFrame.call(_global, () => {
if (!zone.fakeTopEventTask) {
zone.fakeTopEventTask = Zone.root.scheduleEventTask("fakeTopEventTask", () => {
zone.lastRequestAnimationFrameId = -1;
updateMicroTaskStatus(zone);
zone.isCheckStableRunning = true;
checkStable(zone);
zone.isCheckStableRunning = false;
}, void 0, () => {
}, () => {
});
}
zone.fakeTopEventTask.invoke();
});
updateMicroTaskStatus(zone);
}
function forkInnerZoneWithAngularBehavior(zone) {
const delayChangeDetectionForEventsDelegate = () => {
delayChangeDetectionForEvents(zone);
};
zone._inner = zone._inner.fork({
name: "angular",
properties: { "isAngularZone": true },
onInvokeTask: (delegate, current, target, task, applyThis, applyArgs) => {
if (shouldBeIgnoredByZone(applyArgs)) {
return delegate.invokeTask(target, task, applyThis, applyArgs);
}
try {
onEnter(zone);
return delegate.invokeTask(target, task, applyThis, applyArgs);
} finally {
if (zone.shouldCoalesceEventChangeDetection && task.type === "eventTask" || zone.shouldCoalesceRunChangeDetection) {
delayChangeDetectionForEventsDelegate();
}
onLeave(zone);
}
},
onInvoke: (delegate, current, target, callback, applyThis, applyArgs, source) => {
try {
onEnter(zone);
return delegate.invoke(target, callback, applyThis, applyArgs, source);
} finally {
if (zone.shouldCoalesceRunChangeDetection) {
delayChangeDetectionForEventsDelegate();
}
onLeave(zone);
}
},
onHasTask: (delegate, current, target, hasTaskState) => {
delegate.hasTask(target, hasTaskState);
if (current === target) {
if (hasTaskState.change == "microTask") {
zone._hasPendingMicrotasks = hasTaskState.microTask;
updateMicroTaskStatus(zone);
checkStable(zone);
} else if (hasTaskState.change == "macroTask") {
zone.hasPendingMacrotasks = hasTaskState.macroTask;
}
}
},
onHandleError: (delegate, current, target, error) => {
delegate.handleError(target, error);
zone.runOutsideAngular(() => zone.onError.emit(error));
return false;
}
});
}
function updateMicroTaskStatus(zone) {
if (zone._hasPendingMicrotasks || (zone.shouldCoalesceEventChangeDetection || zone.shouldCoalesceRunChangeDetection) && zone.lastRequestAnimationFrameId !== -1) {
zone.hasPendingMicrotasks = true;
} else {
zone.hasPendingMicrotasks = false;
}
}
function onEnter(zone) {
zone._nesting++;
if (zone.isStable) {
zone.isStable = false;
zone.onUnstable.emit(null);
}
}
function onLeave(zone) {
zone._nesting--;
checkStable(zone);
}
var NoopNgZone = class {
constructor() {
this.hasPendingMicrotasks = false;
this.hasPendingMacrotasks = false;
this.isStable = true;
this.onUnstable = new EventEmitter();
this.onMicrotaskEmpty = new EventEmitter();
this.onStable = new EventEmitter();
this.onError = new EventEmitter();
}
run(fn, applyThis, applyArgs) {
return fn.apply(applyThis, applyArgs);
}
runGuarded(fn, applyThis, applyArgs) {
return fn.apply(applyThis, applyArgs);
}
runOutsideAngular(fn) {
return fn();
}
runTask(fn, applyThis, applyArgs, name2) {
return fn.apply(applyThis, applyArgs);
}
};
function shouldBeIgnoredByZone(applyArgs) {
if (!Array.isArray(applyArgs)) {
return false;
}
if (applyArgs.length !== 1) {
return false;
}
return applyArgs[0].data?.["__ignore_ng_zone__"] === true;
}
function getNgZone(ngZoneToUse = "zone.js", options) {
if (ngZoneToUse === "noop") {
return new NoopNgZone();
}
if (ngZoneToUse === "zone.js") {
return new NgZone(options);
}
return ngZoneToUse;
}
var AfterRenderPhase;
(function(AfterRenderPhase2) {
AfterRenderPhase2[AfterRenderPhase2["EarlyRead"] = 0] = "EarlyRead";
AfterRenderPhase2[AfterRenderPhase2["Write"] = 1] = "Write";
AfterRenderPhase2[AfterRenderPhase2["MixedReadWrite"] = 2] = "MixedReadWrite";
AfterRenderPhase2[AfterRenderPhase2["Read"] = 3] = "Read";
})(AfterRenderPhase || (AfterRenderPhase = {}));
var NOOP_AFTER_RENDER_REF = {
destroy() {
}
};
function internalAfterNextRender(callback, options) {
const injector = options?.injector ?? inject(Injector);
if (!options?.runOnServer && !isPlatformBrowser(injector))
return;
const afterRenderEventManager = injector.get(AfterRenderEventManager);
afterRenderEventManager.internalCallbacks.push(callback);
}
function afterNextRender(callback, options) {
!options && assertInInjectionContext(afterNextRender);
const injector = options?.injector ?? inject(Injector);
if (!isPlatformBrowser(injector)) {
return NOOP_AFTER_RENDER_REF;
}
performanceMarkFeature("NgAfterNextRender");
const afterRenderEventManager = injector.get(AfterRenderEventManager);
const callbackHandler = afterRenderEventManager.handler ??= new AfterRenderCallbackHandlerImpl();
const phase = options?.phase ?? AfterRenderPhase.MixedReadWrite;
const destroy = () => {
callbackHandler.unregister(instance);
unregisterFn();
};
const unregisterFn = injector.get(DestroyRef).onDestroy(destroy);
const instance = runInInjectionContext(injector, () => new AfterRenderCallback(phase, () => {
destroy();
callback();
}));
callbackHandler.register(instance);
return { destroy };
}
var AfterRenderCallback = class {
constructor(phase, callbackFn) {
this.phase = phase;
this.callbackFn = callbackFn;
this.zone = inject(NgZone);
this.errorHandler = inject(ErrorHandler, { optional: true });
inject(ChangeDetectionScheduler, { optional: true })?.notify(
1
/* NotificationType.AfterRenderHooks */
);
}
invoke() {
try {
this.zone.runOutsideAngular(this.callbackFn);
} catch (err) {
this.errorHandler?.handleError(err);
}
}
};
var AfterRenderCallbackHandlerImpl = class {
constructor() {
this.executingCallbacks = false;
this.buckets = {
// Note: the order of these keys controls the order the phases are run.
[AfterRenderPhase.EarlyRead]: /* @__PURE__ */ new Set(),
[AfterRenderPhase.Write]: /* @__PURE__ */ new Set(),
[AfterRenderPhase.MixedReadWrite]: /* @__PURE__ */ new Set(),
[AfterRenderPhase.Read]: /* @__PURE__ */ new Set()
};
this.deferredCallbacks = /* @__PURE__ */ new Set();
}
register(callback) {
const target = this.executingCallbacks ? this.deferredCallbacks : this.buckets[callback.phase];
target.add(callback);
}
unregister(callback) {
this.buckets[callback.phase].delete(callback);
this.deferredCallbacks.delete(callback);
}
execute() {
this.executingCallbacks = true;
for (const bucket of Object.values(this.buckets)) {
for (const callback of bucket) {
callback.invoke();
}
}
this.executingCallbacks = false;
for (const callback of this.deferredCallbacks) {
this.buckets[callback.phase].add(callback);
}
this.deferredCallbacks.clear();
}
destroy() {
for (const bucket of Object.values(this.buckets)) {
bucket.clear();
}
this.deferredCallbacks.clear();
}
};
var _AfterRenderEventManager = class _AfterRenderEventManager {
constructor() {
this.handler = null;
this.internalCallbacks = [];
}
/**
* Executes internal and user-provided callbacks.
*/
execute() {
this.executeInternalCallbacks();
this.handler?.execute();
}
executeInternalCallbacks() {
const callbacks = [...this.internalCallbacks];
this.internalCallbacks.length = 0;
for (const callback of callbacks) {
callback();
}
}
ngOnDestroy() {
this.handler?.destroy();
this.handler = null;
this.internalCallbacks.length = 0;
}
};
_AfterRenderEventManager.\u0275prov = \u0275\u0275defineInjectable({
token: _AfterRenderEventManager,
providedIn: "root",
factory: () => new _AfterRenderEventManager()
});
var AfterRenderEventManager = _AfterRenderEventManager;
function isModuleWithProviders(value2) {
return value2.ngModule !== void 0;
}
function isNgModule(value2) {
return !!getNgModuleDef(value2);
}
function isPipe(value2) {
return !!getPipeDef$1(value2);
}
function isDirective(value2) {
return !!getDirectiveDef(value2);
}
function isComponent(value2) {
return !!getComponentDef(value2);
}
function getDependencyTypeForError(type) {
if (getComponentDef(type))
return "component";
if (getDirectiveDef(type))
return "directive";
if (getPipeDef$1(type))
return "pipe";
return "type";
}
function verifyStandaloneImport(depType, importingType) {
if (isForwardRef(depType)) {
depType = resolveForwardRef(depType);
if (!depType) {
throw new Error(`Expected forwardRef function, imported from "${stringifyForError(importingType)}", to return a standalone entity or NgModule but got "${stringifyForError(depType) || depType}".`);
}
}
if (getNgModuleDef(depType) == null) {
const def = getComponentDef(depType) || getDirectiveDef(depType) || getPipeDef$1(depType);
if (def != null) {
if (!def.standalone) {
throw new Error(`The "${stringifyForError(depType)}" ${getDependencyTypeForError(depType)}, imported from "${stringifyForError(importingType)}", is not standalone. Did you forget to add the standalone: true flag?`);
}
} else {
if (isModuleWithProviders(depType)) {
throw new Error(`A module with providers was imported from "${stringifyForError(importingType)}". Modules with providers are not supported in standalone components imports.`);
} else {
throw new Error(`The "${stringifyForError(depType)}" type, imported from "${stringifyForError(importingType)}", must be a standalone component / directive / pipe or an NgModule. Did you forget to add the required @Component / @Directive / @Pipe or @NgModule annotation?`);
}
}
}
}
var USE_RUNTIME_DEPS_TRACKER_FOR_JIT = true;
var DepsTracker = class {
constructor() {
this.ownerNgModule = /* @__PURE__ */ new Map();
this.ngModulesWithSomeUnresolvedDecls = /* @__PURE__ */ new Set();
this.ngModulesScopeCache = /* @__PURE__ */ new Map();
this.standaloneComponentsScopeCache = /* @__PURE__ */ new Map();
}
/**
* Attempts to resolve ng module's forward ref declarations as much as possible and add them to
* the `ownerNgModule` map. This method normally should be called after the initial parsing when
* all the forward refs are resolved (e.g., when trying to render a component)
*/
resolveNgModulesDecls() {
if (this.ngModulesWithSomeUnresolvedDecls.size === 0) {
return;
}
for (const moduleType of this.ngModulesWithSomeUnresolvedDecls) {
const def = getNgModuleDef(moduleType);
if (def?.declarations) {
for (const decl of maybeUnwrapFn(def.declarations)) {
if (isComponent(decl)) {
this.ownerNgModule.set(decl, moduleType);
}
}
}
}
this.ngModulesWithSomeUnresolvedDecls.clear();
}
/** @override */
getComponentDependencies(type, rawImports) {
this.resolveNgModulesDecls();
const def = getComponentDef(type);
if (def === null) {
throw new Error(`Attempting to get component dependencies for a type that is not a component: ${type}`);
}
if (def.standalone) {
const scope = this.getStandaloneComponentScope(type, rawImports);
if (scope.compilation.isPoisoned) {
return { dependencies: [] };
}
return {
dependencies: [
...scope.compilation.directives,
...scope.compilation.pipes,
...scope.compilation.ngModules
]
};
} else {
if (!this.ownerNgModule.has(type)) {
return { dependencies: [] };
}
const scope = this.getNgModuleScope(this.ownerNgModule.get(type));
if (scope.compilation.isPoisoned) {
return { dependencies: [] };
}
return {
dependencies: [
...scope.compilation.directives,
...scope.compilation.pipes
]
};
}
}
/**
* @override
* This implementation does not make use of param scopeInfo since it assumes the scope info is
* already added to the type itself through methods like {@link ɵɵsetNgModuleScope}
*/
registerNgModule(type, scopeInfo) {
if (!isNgModule(type)) {
throw new Error(`Attempting to register a Type which is not NgModule as NgModule: ${type}`);
}
this.ngModulesWithSomeUnresolvedDecls.add(type);
}
/** @override */
clearScopeCacheFor(type) {
this.ngModulesScopeCache.delete(type);
this.standaloneComponentsScopeCache.delete(type);
}
/** @override */
getNgModuleScope(type) {
if (this.ngModulesScopeCache.has(type)) {
return this.ngModulesScopeCache.get(type);
}
const scope = this.computeNgModuleScope(type);
this.ngModulesScopeCache.set(type, scope);
return scope;
}
/** Compute NgModule scope afresh. */
computeNgModuleScope(type) {
const def = getNgModuleDef(type, true);
const scope = {
exported: { directives: /* @__PURE__ */ new Set(), pipes: /* @__PURE__ */ new Set() },
compilation: { directives: /* @__PURE__ */ new Set(), pipes: /* @__PURE__ */ new Set() }
};
for (const imported of maybeUnwrapFn(def.imports)) {
if (isNgModule(imported)) {
const importedScope = this.getNgModuleScope(imported);
addSet(importedScope.exported.directives, scope.compilation.directives);
addSet(importedScope.exported.pipes, scope.compilation.pipes);
} else if (isStandalone(imported)) {
if (isDirective(imported) || isComponent(imported)) {
scope.compilation.directives.add(imported);
} else if (isPipe(imported)) {
scope.compilation.pipes.add(imported);
} else {
throw new RuntimeError(1e3, "The standalone imported type is neither a component nor a directive nor a pipe");
}
} else {
scope.compilation.isPoisoned = true;
break;
}
}
if (!scope.compilation.isPoisoned) {
for (const decl of maybeUnwrapFn(def.declarations)) {
if (isNgModule(decl) || isStandalone(decl)) {
scope.compilation.isPoisoned = true;
break;
}
if (isPipe(decl)) {
scope.compilation.pipes.add(decl);
} else {
scope.compilation.directives.add(decl);
}
}
}
for (const exported of maybeUnwrapFn(def.exports)) {
if (isNgModule(exported)) {
const exportedScope = this.getNgModuleScope(exported);
addSet(exportedScope.exported.directives, scope.exported.directives);
addSet(exportedScope.exported.pipes, scope.exported.pipes);
addSet(exportedScope.exported.directives, scope.compilation.directives);
addSet(exportedScope.exported.pipes, scope.compilation.pipes);
} else if (isPipe(exported)) {
scope.exported.pipes.add(exported);
} else {
scope.exported.directives.add(exported);
}
}
return scope;
}
/** @override */
getStandaloneComponentScope(type, rawImports) {
if (this.standaloneComponentsScopeCache.has(type)) {
return this.standaloneComponentsScopeCache.get(type);
}
const ans = this.computeStandaloneComponentScope(type, rawImports);
this.standaloneComponentsScopeCache.set(type, ans);
return ans;
}
computeStandaloneComponentScope(type, rawImports) {
const ans = {
compilation: {
// Standalone components are always able to self-reference.
directives: /* @__PURE__ */ new Set([type]),
pipes: /* @__PURE__ */ new Set(),
ngModules: /* @__PURE__ */ new Set()
}
};
for (const rawImport of flatten(rawImports ?? [])) {
const imported = resolveForwardRef(rawImport);
try {
verifyStandaloneImport(imported, type);
} catch (e) {
ans.compilation.isPoisoned = true;
return ans;
}
if (isNgModule(imported)) {
ans.compilation.ngModules.add(imported);
const importedScope = this.getNgModuleScope(imported);
if (importedScope.exported.isPoisoned) {
ans.compilation.isPoisoned = true;
return ans;
}
addSet(importedScope.exported.directives, ans.compilation.directives);
addSet(importedScope.exported.pipes, ans.compilation.pipes);
} else if (isPipe(imported)) {
ans.compilation.pipes.add(imported);
} else if (isDirective(imported) || isComponent(imported)) {
ans.compilation.directives.add(imported);
} else {
ans.compilation.isPoisoned = true;
return ans;
}
}
return ans;
}
/** @override */
isOrphanComponent(cmp) {
const def = getComponentDef(cmp);
if (!def || def.standalone) {
return false;
}
this.resolveNgModulesDecls();
return !this.ownerNgModule.has(cmp);
}
};
function addSet(sourceSet, targetSet) {
for (const m of sourceSet) {
targetSet.add(m);
}
}
var depsTracker = new DepsTracker();
function computeStaticStyling(tNode, attrs, writeToHost) {
ngDevMode && assertFirstCreatePass(getTView(), "Expecting to be called in first template pass only");
let styles = writeToHost ? tNode.styles : null;
let classes = writeToHost ? tNode.classes : null;
let mode = 0;
if (attrs !== null) {
for (let i = 0; i < attrs.length; i++) {
const value2 = attrs[i];
if (typeof value2 === "number") {
mode = value2;
} else if (mode == 1) {
classes = concatStringsWithSpace(classes, value2);
} else if (mode == 2) {
const style = value2;
const styleValue = attrs[++i];
styles = concatStringsWithSpace(styles, style + ": " + styleValue + ";");
}
}
}
writeToHost ? tNode.styles = styles : tNode.stylesWithoutHost = styles;
writeToHost ? tNode.classes = classes : tNode.classesWithoutHost = classes;
}
var ComponentFactoryResolver = class extends ComponentFactoryResolver$1 {
/**
* @param ngModule The NgModuleRef to which all resolved factories are bound.
*/
constructor(ngModule) {
super();
this.ngModule = ngModule;
}
resolveComponentFactory(component) {
ngDevMode && assertComponentType(component);
const componentDef = getComponentDef(component);
return new ComponentFactory(componentDef, this.ngModule);
}
};
function toRefArray(map2) {
const array = [];
for (const publicName in map2) {
if (!map2.hasOwnProperty(publicName)) {
continue;
}
const value2 = map2[publicName];
if (value2 === void 0) {
continue;
}
array.push({
propName: Array.isArray(value2) ? value2[0] : value2,
templateName: publicName
});
}
return array;
}
function getNamespace(elementName) {
const name2 = elementName.toLowerCase();
return name2 === "svg" ? SVG_NAMESPACE : name2 === "math" ? MATH_ML_NAMESPACE : null;
}
var ChainedInjector = class {
constructor(injector, parentInjector) {
this.injector = injector;
this.parentInjector = parentInjector;
}
get(token, notFoundValue, flags) {
flags = convertToBitFlags(flags);
const value2 = this.injector.get(token, NOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR, flags);
if (value2 !== NOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR || notFoundValue === NOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR) {
return value2;
}
return this.parentInjector.get(token, notFoundValue, flags);
}
};
var ComponentFactory = class extends ComponentFactory$1 {
get inputs() {
const componentDef = this.componentDef;
const inputTransforms = componentDef.inputTransforms;
const refArray = toRefArray(componentDef.inputs);
if (inputTransforms !== null) {
for (const input2 of refArray) {
if (inputTransforms.hasOwnProperty(input2.propName)) {
input2.transform = inputTransforms[input2.propName];
}
}
}
return refArray;
}
get outputs() {
return toRefArray(this.componentDef.outputs);
}
/**
* @param componentDef The component definition.
* @param ngModule The NgModuleRef to which the factory is bound.
*/
constructor(componentDef, ngModule) {
super();
this.componentDef = componentDef;
this.ngModule = ngModule;
this.componentType = componentDef.type;
this.selector = stringifyCSSSelectorList(componentDef.selectors);
this.ngContentSelectors = componentDef.ngContentSelectors ? componentDef.ngContentSelectors : [];
this.isBoundToModule = !!ngModule;
}
create(injector, projectableNodes, rootSelectorOrNode, environmentInjector) {
const prevConsumer = setActiveConsumer(null);
try {
if (ngDevMode && false) {
if (depsTracker.isOrphanComponent(this.componentType)) {
throw new RuntimeError(1001, `Orphan component found! Trying to render the component ${debugStringifyTypeForError(this.componentType)} without first loading the NgModule that declares it. It is recommended to make this component standalone in order to avoid this error. If this is not possible now, import the component's NgModule in the appropriate NgModule, or the standalone component in which you are trying to render this component. If this is a lazy import, load the NgModule lazily as well and use its module injector.`);
}
}
environmentInjector = environmentInjector || this.ngModule;
let realEnvironmentInjector = environmentInjector instanceof EnvironmentInjector ? environmentInjector : environmentInjector?.injector;
if (realEnvironmentInjector && this.componentDef.getStandaloneInjector !== null) {
realEnvironmentInjector = this.componentDef.getStandaloneInjector(realEnvironmentInjector) || realEnvironmentInjector;
}
const rootViewInjector = realEnvironmentInjector ? new ChainedInjector(injector, realEnvironmentInjector) : injector;
const rendererFactory = rootViewInjector.get(RendererFactory2, null);
if (rendererFactory === null) {
throw new RuntimeError(407, ngDevMode && "Angular was not able to inject a renderer (RendererFactory2). Likely this is due to a broken DI hierarchy. Make sure that any injector used to create this component has a correct parent.");
}
const sanitizer = rootViewInjector.get(Sanitizer, null);
const afterRenderEventManager = rootViewInjector.get(AfterRenderEventManager, null);
const changeDetectionScheduler = rootViewInjector.get(ChangeDetectionScheduler, null);
const environment2 = {
rendererFactory,
sanitizer,
// We don't use inline effects (yet).
inlineEffectRunner: null,
afterRenderEventManager,
changeDetectionScheduler
};
const hostRenderer = rendererFactory.createRenderer(null, this.componentDef);
const elementName = this.componentDef.selectors[0][0] || "div";
const hostRNode = rootSelectorOrNode ? locateHostElement(hostRenderer, rootSelectorOrNode, this.componentDef.encapsulation, rootViewInjector) : createElementNode(hostRenderer, elementName, getNamespace(elementName));
let rootFlags = 512;
if (this.componentDef.signals) {
rootFlags |= 4096;
} else if (!this.componentDef.onPush) {
rootFlags |= 16;
}
let hydrationInfo = null;
if (hostRNode !== null) {
hydrationInfo = retrieveHydrationInfo(
hostRNode,
rootViewInjector,
true
/* isRootView */
);
}
const rootTView = createTView(0, null, null, 1, 0, null, null, null, null, null, null);
const rootLView = createLView(null, rootTView, null, rootFlags, null, null, environment2, hostRenderer, rootViewInjector, null, hydrationInfo);
enterView(rootLView);
let component;
let tElementNode;
try {
const rootComponentDef = this.componentDef;
let rootDirectives;
let hostDirectiveDefs = null;
if (rootComponentDef.findHostDirectiveDefs) {
rootDirectives = [];
hostDirectiveDefs = /* @__PURE__ */ new Map();
rootComponentDef.findHostDirectiveDefs(rootComponentDef, rootDirectives, hostDirectiveDefs);
rootDirectives.push(rootComponentDef);
ngDevMode && assertNoDuplicateDirectives(rootDirectives);
} else {
rootDirectives = [rootComponentDef];
}
const hostTNode = createRootComponentTNode(rootLView, hostRNode);
const componentView = createRootComponentView(hostTNode, hostRNode, rootComponentDef, rootDirectives, rootLView, environment2, hostRenderer);
tElementNode = getTNode(rootTView, HEADER_OFFSET);
if (hostRNode) {
setRootNodeAttributes(hostRenderer, rootComponentDef, hostRNode, rootSelectorOrNode);
}
if (projectableNodes !== void 0) {
projectNodes(tElementNode, this.ngContentSelectors, projectableNodes);
}
component = createRootComponent(componentView, rootComponentDef, rootDirectives, hostDirectiveDefs, rootLView, [LifecycleHooksFeature]);
renderView(rootTView, rootLView, null);
} finally {
leaveView();
}
return new ComponentRef(this.componentType, component, createElementRef(tElementNode, rootLView), rootLView, tElementNode);
} finally {
setActiveConsumer(prevConsumer);
}
}
};
var ComponentRef = class extends ComponentRef$1 {
constructor(componentType, instance, location2, _rootLView, _tNode) {
super();
this.location = location2;
this._rootLView = _rootLView;
this._tNode = _tNode;
this.previousInputValues = null;
this.instance = instance;
this.hostView = this.changeDetectorRef = new ViewRef$1(
_rootLView,
void 0,
/* _cdRefInjectingView */
false
);
this.componentType = componentType;
}
setInput(name2, value2) {
const inputData = this._tNode.inputs;
let dataValue;
if (inputData !== null && (dataValue = inputData[name2])) {
this.previousInputValues ??= /* @__PURE__ */ new Map();
if (this.previousInputValues.has(name2) && Object.is(this.previousInputValues.get(name2), value2)) {
return;
}
const lView = this._rootLView;
setInputsForProperty(lView[TVIEW], lView, dataValue, name2, value2);
this.previousInputValues.set(name2, value2);
const childComponentLView = getComponentLViewByIndex(this._tNode.index, lView);
markViewDirty(childComponentLView);
} else {
if (ngDevMode) {
const cmpNameForError = stringifyForError(this.componentType);
let message = `Can't set value of the '${name2}' input on the '${cmpNameForError}' component. `;
message += `Make sure that the '${name2}' property is annotated with @Input() or a mapped @Input('${name2}') exists.`;
reportUnknownPropertyError(message);
}
}
}
get injector() {
return new NodeInjector(this._tNode, this._rootLView);
}
destroy() {
this.hostView.destroy();
}
onDestroy(callback) {
this.hostView.onDestroy(callback);
}
};
function createRootComponentTNode(lView, rNode) {
const tView = lView[TVIEW];
const index2 = HEADER_OFFSET;
ngDevMode && assertIndexInRange(lView, index2);
lView[index2] = rNode;
return getOrCreateTNode(tView, index2, 2, "#host", null);
}
function createRootComponentView(tNode, hostRNode, rootComponentDef, rootDirectives, rootView, environment2, hostRenderer) {
const tView = rootView[TVIEW];
applyRootComponentStyling(rootDirectives, tNode, hostRNode, hostRenderer);
let hydrationInfo = null;
if (hostRNode !== null) {
hydrationInfo = retrieveHydrationInfo(hostRNode, rootView[INJECTOR]);
}
const viewRenderer = environment2.rendererFactory.createRenderer(hostRNode, rootComponentDef);
let lViewFlags = 16;
if (rootComponentDef.signals) {
lViewFlags = 4096;
} else if (rootComponentDef.onPush) {
lViewFlags = 64;
}
const componentView = createLView(rootView, getOrCreateComponentTView(rootComponentDef), null, lViewFlags, rootView[tNode.index], tNode, environment2, viewRenderer, null, null, hydrationInfo);
if (tView.firstCreatePass) {
markAsComponentHost(tView, tNode, rootDirectives.length - 1);
}
addToViewTree(rootView, componentView);
return rootView[tNode.index] = componentView;
}
function applyRootComponentStyling(rootDirectives, tNode, rNode, hostRenderer) {
for (const def of rootDirectives) {
tNode.mergedAttrs = mergeHostAttrs(tNode.mergedAttrs, def.hostAttrs);
}
if (tNode.mergedAttrs !== null) {
computeStaticStyling(tNode, tNode.mergedAttrs, true);
if (rNode !== null) {
setupStaticAttributes(hostRenderer, rNode, tNode);
}
}
}
function createRootComponent(componentView, rootComponentDef, rootDirectives, hostDirectiveDefs, rootLView, hostFeatures) {
const rootTNode = getCurrentTNode();
ngDevMode && assertDefined(rootTNode, "tNode should have been already created");
const tView = rootLView[TVIEW];
const native = getNativeByTNode(rootTNode, rootLView);
initializeDirectives(tView, rootLView, rootTNode, rootDirectives, null, hostDirectiveDefs);
for (let i = 0; i < rootDirectives.length; i++) {
const directiveIndex = rootTNode.directiveStart + i;
const directiveInstance = getNodeInjectable(rootLView, tView, directiveIndex, rootTNode);
attachPatchData(directiveInstance, rootLView);
}
invokeDirectivesHostBindings(tView, rootLView, rootTNode);
if (native) {
attachPatchData(native, rootLView);
}
ngDevMode && assertGreaterThan(rootTNode.componentOffset, -1, "componentOffset must be great than -1");
const component = getNodeInjectable(rootLView, tView, rootTNode.directiveStart + rootTNode.componentOffset, rootTNode);
componentView[CONTEXT] = rootLView[CONTEXT] = component;
if (hostFeatures !== null) {
for (const feature of hostFeatures) {
feature(component, rootComponentDef);
}
}
executeContentQueries(tView, rootTNode, rootLView);
return component;
}
function setRootNodeAttributes(hostRenderer, componentDef, hostRNode, rootSelectorOrNode) {
if (rootSelectorOrNode) {
setUpAttributes(hostRenderer, hostRNode, ["ng-version", "17.3.12"]);
} else {
const { attrs, classes } = extractAttrsAndClassesFromSelector(componentDef.selectors[0]);
if (attrs) {
setUpAttributes(hostRenderer, hostRNode, attrs);
}
if (classes && classes.length > 0) {
writeDirectClass(hostRenderer, hostRNode, classes.join(" "));
}
}
}
function projectNodes(tNode, ngContentSelectors, projectableNodes) {
const projection = tNode.projection = [];
for (let i = 0; i < ngContentSelectors.length; i++) {
const nodesforSlot = projectableNodes[i];
projection.push(nodesforSlot != null ? Array.from(nodesforSlot) : null);
}
}
function LifecycleHooksFeature() {
const tNode = getCurrentTNode();
ngDevMode && assertDefined(tNode, "TNode is required");
registerPostOrderHooks(getLView()[TVIEW], tNode);
}
var _ViewContainerRef = class _ViewContainerRef {
};
_ViewContainerRef.__NG_ELEMENT_ID__ = injectViewContainerRef;
var ViewContainerRef = _ViewContainerRef;
function injectViewContainerRef() {
const previousTNode = getCurrentTNode();
return createContainerRef(previousTNode, getLView());
}
var VE_ViewContainerRef = ViewContainerRef;
var R3ViewContainerRef = class ViewContainerRef2 extends VE_ViewContainerRef {
constructor(_lContainer, _hostTNode, _hostLView) {
super();
this._lContainer = _lContainer;
this._hostTNode = _hostTNode;
this._hostLView = _hostLView;
}
get element() {
return createElementRef(this._hostTNode, this._hostLView);
}
get injector() {
return new NodeInjector(this._hostTNode, this._hostLView);
}
/** @deprecated No replacement */
get parentInjector() {
const parentLocation = getParentInjectorLocation(this._hostTNode, this._hostLView);
if (hasParentInjector(parentLocation)) {
const parentView = getParentInjectorView(parentLocation, this._hostLView);
const injectorIndex = getParentInjectorIndex(parentLocation);
ngDevMode && assertNodeInjector(parentView, injectorIndex);
const parentTNode = parentView[TVIEW].data[
injectorIndex + 8
/* NodeInjectorOffset.TNODE */
];
return new NodeInjector(parentTNode, parentView);
} else {
return new NodeInjector(null, this._hostLView);
}
}
clear() {
while (this.length > 0) {
this.remove(this.length - 1);
}
}
get(index2) {
const viewRefs = getViewRefs(this._lContainer);
return viewRefs !== null && viewRefs[index2] || null;
}
get length() {
return this._lContainer.length - CONTAINER_HEADER_OFFSET;
}
createEmbeddedView(templateRef, context2, indexOrOptions) {
let index2;
let injector;
if (typeof indexOrOptions === "number") {
index2 = indexOrOptions;
} else if (indexOrOptions != null) {
index2 = indexOrOptions.index;
injector = indexOrOptions.injector;
}
const dehydratedView = findMatchingDehydratedView(this._lContainer, templateRef.ssrId);
const viewRef = templateRef.createEmbeddedViewImpl(context2 || {}, injector, dehydratedView);
this.insertImpl(viewRef, index2, shouldAddViewToDom(this._hostTNode, dehydratedView));
return viewRef;
}
createComponent(componentFactoryOrType, indexOrOptions, injector, projectableNodes, environmentInjector) {
const isComponentFactory = componentFactoryOrType && !isType(componentFactoryOrType);
let index2;
if (isComponentFactory) {
if (ngDevMode) {
assertEqual(typeof indexOrOptions !== "object", true, "It looks like Component factory was provided as the first argument and an options object as the second argument. This combination of arguments is incompatible. You can either change the first argument to provide Component type or change the second argument to be a number (representing an index at which to insert the new component's host view into this container)");
}
index2 = indexOrOptions;
} else {
if (ngDevMode) {
assertDefined(getComponentDef(componentFactoryOrType), `Provided Component class doesn't contain Component definition. Please check whether provided class has @Component decorator.`);
assertEqual(typeof indexOrOptions !== "number", true, "It looks like Component type was provided as the first argument and a number (representing an index at which to insert the new component's host view into this container as the second argument. This combination of arguments is incompatible. Please use an object as the second argument instead.");
}
const options = indexOrOptions || {};
if (ngDevMode && options.environmentInjector && options.ngModuleRef) {
throwError2(`Cannot pass both environmentInjector and ngModuleRef options to createComponent().`);
}
index2 = options.index;
injector = options.injector;
projectableNodes = options.projectableNodes;
environmentInjector = options.environmentInjector || options.ngModuleRef;
}
const componentFactory = isComponentFactory ? componentFactoryOrType : new ComponentFactory(getComponentDef(componentFactoryOrType));
const contextInjector = injector || this.parentInjector;
if (!environmentInjector && componentFactory.ngModule == null) {
const _injector = isComponentFactory ? contextInjector : this.parentInjector;
const result = _injector.get(EnvironmentInjector, null);
if (result) {
environmentInjector = result;
}
}
const componentDef = getComponentDef(componentFactory.componentType ?? {});
const dehydratedView = findMatchingDehydratedView(this._lContainer, componentDef?.id ?? null);
const rNode = dehydratedView?.firstChild ?? null;
const componentRef = componentFactory.create(contextInjector, projectableNodes, rNode, environmentInjector);
this.insertImpl(componentRef.hostView, index2, shouldAddViewToDom(this._hostTNode, dehydratedView));
return componentRef;
}
insert(viewRef, index2) {
return this.insertImpl(viewRef, index2, true);
}
insertImpl(viewRef, index2, addToDOM) {
const lView = viewRef._lView;
if (ngDevMode && viewRef.destroyed) {
throw new Error("Cannot insert a destroyed View in a ViewContainer!");
}
if (viewAttachedToContainer(lView)) {
const prevIdx = this.indexOf(viewRef);
if (prevIdx !== -1) {
this.detach(prevIdx);
} else {
const prevLContainer = lView[PARENT];
ngDevMode && assertEqual(isLContainer(prevLContainer), true, "An attached view should have its PARENT point to a container.");
const prevVCRef = new R3ViewContainerRef(prevLContainer, prevLContainer[T_HOST], prevLContainer[PARENT]);
prevVCRef.detach(prevVCRef.indexOf(viewRef));
}
}
const adjustedIdx = this._adjustIndex(index2);
const lContainer = this._lContainer;
addLViewToLContainer(lContainer, lView, adjustedIdx, addToDOM);
viewRef.attachToViewContainerRef();
addToArray(getOrCreateViewRefs(lContainer), adjustedIdx, viewRef);
return viewRef;
}
move(viewRef, newIndex) {
if (ngDevMode && viewRef.destroyed) {
throw new Error("Cannot move a destroyed View in a ViewContainer!");
}
return this.insert(viewRef, newIndex);
}
indexOf(viewRef) {
const viewRefsArr = getViewRefs(this._lContainer);
return viewRefsArr !== null ? viewRefsArr.indexOf(viewRef) : -1;
}
remove(index2) {
const adjustedIdx = this._adjustIndex(index2, -1);
const detachedView = detachView(this._lContainer, adjustedIdx);
if (detachedView) {
removeFromArray(getOrCreateViewRefs(this._lContainer), adjustedIdx);
destroyLView(detachedView[TVIEW], detachedView);
}
}
detach(index2) {
const adjustedIdx = this._adjustIndex(index2, -1);
const view = detachView(this._lContainer, adjustedIdx);
const wasDetached = view && removeFromArray(getOrCreateViewRefs(this._lContainer), adjustedIdx) != null;
return wasDetached ? new ViewRef$1(view) : null;
}
_adjustIndex(index2, shift = 0) {
if (index2 == null) {
return this.length + shift;
}
if (ngDevMode) {
assertGreaterThan(index2, -1, `ViewRef index must be positive, got ${index2}`);
assertLessThan(index2, this.length + 1 + shift, "index");
}
return index2;
}
};
function getViewRefs(lContainer) {
return lContainer[VIEW_REFS];
}
function getOrCreateViewRefs(lContainer) {
return lContainer[VIEW_REFS] || (lContainer[VIEW_REFS] = []);
}
function createContainerRef(hostTNode, hostLView) {
ngDevMode && assertTNodeType(
hostTNode,
12 | 3
/* TNodeType.AnyRNode */
);
let lContainer;
const slotValue = hostLView[hostTNode.index];
if (isLContainer(slotValue)) {
lContainer = slotValue;
} else {
lContainer = createLContainer(slotValue, hostLView, null, hostTNode);
hostLView[hostTNode.index] = lContainer;
addToViewTree(hostLView, lContainer);
}
_locateOrCreateAnchorNode(lContainer, hostLView, hostTNode, slotValue);
return new R3ViewContainerRef(lContainer, hostTNode, hostLView);
}
function insertAnchorNode(hostLView, hostTNode) {
const renderer2 = hostLView[RENDERER];
ngDevMode && ngDevMode.rendererCreateComment++;
const commentNode = renderer2.createComment(ngDevMode ? "container" : "");
const hostNative = getNativeByTNode(hostTNode, hostLView);
const parentOfHostNative = nativeParentNode(renderer2, hostNative);
nativeInsertBefore(renderer2, parentOfHostNative, commentNode, nativeNextSibling(renderer2, hostNative), false);
return commentNode;
}
var _locateOrCreateAnchorNode = createAnchorNode;
var _populateDehydratedViewsInLContainer = () => false;
function populateDehydratedViewsInLContainer(lContainer, tNode, hostLView) {
return _populateDehydratedViewsInLContainer(lContainer, tNode, hostLView);
}
function createAnchorNode(lContainer, hostLView, hostTNode, slotValue) {
if (lContainer[NATIVE])
return;
let commentNode;
if (hostTNode.type & 8) {
commentNode = unwrapRNode(slotValue);
} else {
commentNode = insertAnchorNode(hostLView, hostTNode);
}
lContainer[NATIVE] = commentNode;
}
var LQuery_ = class _LQuery_ {
constructor(queryList) {
this.queryList = queryList;
this.matches = null;
}
clone() {
return new _LQuery_(this.queryList);
}
setDirty() {
this.queryList.setDirty();
}
};
var LQueries_ = class _LQueries_ {
constructor(queries = []) {
this.queries = queries;
}
createEmbeddedView(tView) {
const tQueries = tView.queries;
if (tQueries !== null) {
const noOfInheritedQueries = tView.contentQueries !== null ? tView.contentQueries[0] : tQueries.length;
const viewLQueries = [];
for (let i = 0; i < noOfInheritedQueries; i++) {
const tQuery = tQueries.getByIndex(i);
const parentLQuery = this.queries[tQuery.indexInDeclarationView];
viewLQueries.push(parentLQuery.clone());
}
return new _LQueries_(viewLQueries);
}
return null;
}
insertView(tView) {
this.dirtyQueriesWithMatches(tView);
}
detachView(tView) {
this.dirtyQueriesWithMatches(tView);
}
finishViewCreation(tView) {
this.dirtyQueriesWithMatches(tView);
}
dirtyQueriesWithMatches(tView) {
for (let i = 0; i < this.queries.length; i++) {
if (getTQuery(tView, i).matches !== null) {
this.queries[i].setDirty();
}
}
}
};
var TQueryMetadata_ = class {
constructor(predicate, flags, read = null) {
this.flags = flags;
this.read = read;
if (typeof predicate === "string") {
this.predicate = splitQueryMultiSelectors(predicate);
} else {
this.predicate = predicate;
}
}
};
var TQueries_ = class _TQueries_ {
constructor(queries = []) {
this.queries = queries;
}
elementStart(tView, tNode) {
ngDevMode && assertFirstCreatePass(tView, "Queries should collect results on the first template pass only");
for (let i = 0; i < this.queries.length; i++) {
this.queries[i].elementStart(tView, tNode);
}
}
elementEnd(tNode) {
for (let i = 0; i < this.queries.length; i++) {
this.queries[i].elementEnd(tNode);
}
}
embeddedTView(tNode) {
let queriesForTemplateRef = null;
for (let i = 0; i < this.length; i++) {
const childQueryIndex = queriesForTemplateRef !== null ? queriesForTemplateRef.length : 0;
const tqueryClone = this.getByIndex(i).embeddedTView(tNode, childQueryIndex);
if (tqueryClone) {
tqueryClone.indexInDeclarationView = i;
if (queriesForTemplateRef !== null) {
queriesForTemplateRef.push(tqueryClone);
} else {
queriesForTemplateRef = [tqueryClone];
}
}
}
return queriesForTemplateRef !== null ? new _TQueries_(queriesForTemplateRef) : null;
}
template(tView, tNode) {
ngDevMode && assertFirstCreatePass(tView, "Queries should collect results on the first template pass only");
for (let i = 0; i < this.queries.length; i++) {
this.queries[i].template(tView, tNode);
}
}
getByIndex(index2) {
ngDevMode && assertIndexInRange(this.queries, index2);
return this.queries[index2];
}
get length() {
return this.queries.length;
}
track(tquery) {
this.queries.push(tquery);
}
};
var TQuery_ = class _TQuery_ {
constructor(metadata, nodeIndex = -1) {
this.metadata = metadata;
this.matches = null;
this.indexInDeclarationView = -1;
this.crossesNgTemplate = false;
this._appliesToNextNode = true;
this._declarationNodeIndex = nodeIndex;
}
elementStart(tView, tNode) {
if (this.isApplyingToNode(tNode)) {
this.matchTNode(tView, tNode);
}
}
elementEnd(tNode) {
if (this._declarationNodeIndex === tNode.index) {
this._appliesToNextNode = false;
}
}
template(tView, tNode) {
this.elementStart(tView, tNode);
}
embeddedTView(tNode, childQueryIndex) {
if (this.isApplyingToNode(tNode)) {
this.crossesNgTemplate = true;
this.addMatch(-tNode.index, childQueryIndex);
return new _TQuery_(this.metadata);
}
return null;
}
isApplyingToNode(tNode) {
if (this._appliesToNextNode && (this.metadata.flags & 1) !== 1) {
const declarationNodeIdx = this._declarationNodeIndex;
let parent2 = tNode.parent;
while (parent2 !== null && parent2.type & 8 && parent2.index !== declarationNodeIdx) {
parent2 = parent2.parent;
}
return declarationNodeIdx === (parent2 !== null ? parent2.index : -1);
}
return this._appliesToNextNode;
}
matchTNode(tView, tNode) {
const predicate = this.metadata.predicate;
if (Array.isArray(predicate)) {
for (let i = 0; i < predicate.length; i++) {
const name2 = predicate[i];
this.matchTNodeWithReadOption(tView, tNode, getIdxOfMatchingSelector(tNode, name2));
this.matchTNodeWithReadOption(tView, tNode, locateDirectiveOrProvider(tNode, tView, name2, false, false));
}
} else {
if (predicate === TemplateRef) {
if (tNode.type & 4) {
this.matchTNodeWithReadOption(tView, tNode, -1);
}
} else {
this.matchTNodeWithReadOption(tView, tNode, locateDirectiveOrProvider(tNode, tView, predicate, false, false));
}
}
}
matchTNodeWithReadOption(tView, tNode, nodeMatchIdx) {
if (nodeMatchIdx !== null) {
const read = this.metadata.read;
if (read !== null) {
if (read === ElementRef || read === ViewContainerRef || read === TemplateRef && tNode.type & 4) {
this.addMatch(tNode.index, -2);
} else {
const directiveOrProviderIdx = locateDirectiveOrProvider(tNode, tView, read, false, false);
if (directiveOrProviderIdx !== null) {
this.addMatch(tNode.index, directiveOrProviderIdx);
}
}
} else {
this.addMatch(tNode.index, nodeMatchIdx);
}
}
}
addMatch(tNodeIdx, matchIdx) {
if (this.matches === null) {
this.matches = [tNodeIdx, matchIdx];
} else {
this.matches.push(tNodeIdx, matchIdx);
}
}
};
function getIdxOfMatchingSelector(tNode, selector) {
const localNames = tNode.localNames;
if (localNames !== null) {
for (let i = 0; i < localNames.length; i += 2) {
if (localNames[i] === selector) {
return localNames[i + 1];
}
}
}
return null;
}
function createResultByTNodeType(tNode, currentView) {
if (tNode.type & (3 | 8)) {
return createElementRef(tNode, currentView);
} else if (tNode.type & 4) {
return createTemplateRef(tNode, currentView);
}
return null;
}
function createResultForNode(lView, tNode, matchingIdx, read) {
if (matchingIdx === -1) {
return createResultByTNodeType(tNode, lView);
} else if (matchingIdx === -2) {
return createSpecialToken(lView, tNode, read);
} else {
return getNodeInjectable(lView, lView[TVIEW], matchingIdx, tNode);
}
}
function createSpecialToken(lView, tNode, read) {
if (read === ElementRef) {
return createElementRef(tNode, lView);
} else if (read === TemplateRef) {
return createTemplateRef(tNode, lView);
} else if (read === ViewContainerRef) {
ngDevMode && assertTNodeType(
tNode,
3 | 12
/* TNodeType.AnyContainer */
);
return createContainerRef(tNode, lView);
} else {
ngDevMode && throwError2(`Special token to read should be one of ElementRef, TemplateRef or ViewContainerRef but got ${stringify(read)}.`);
}
}
function materializeViewResults(tView, lView, tQuery, queryIndex) {
const lQuery = lView[QUERIES].queries[queryIndex];
if (lQuery.matches === null) {
const tViewData = tView.data;
const tQueryMatches = tQuery.matches;
const result = [];
for (let i = 0; tQueryMatches !== null && i < tQueryMatches.length; i += 2) {
const matchedNodeIdx = tQueryMatches[i];
if (matchedNodeIdx < 0) {
result.push(null);
} else {
ngDevMode && assertIndexInRange(tViewData, matchedNodeIdx);
const tNode = tViewData[matchedNodeIdx];
result.push(createResultForNode(lView, tNode, tQueryMatches[i + 1], tQuery.metadata.read));
}
}
lQuery.matches = result;
}
return lQuery.matches;
}
function collectQueryResults(tView, lView, queryIndex, result) {
const tQuery = tView.queries.getByIndex(queryIndex);
const tQueryMatches = tQuery.matches;
if (tQueryMatches !== null) {
const lViewResults = materializeViewResults(tView, lView, tQuery, queryIndex);
for (let i = 0; i < tQueryMatches.length; i += 2) {
const tNodeIdx = tQueryMatches[i];
if (tNodeIdx > 0) {
result.push(lViewResults[i / 2]);
} else {
const childQueryIndex = tQueryMatches[i + 1];
const declarationLContainer = lView[-tNodeIdx];
ngDevMode && assertLContainer(declarationLContainer);
for (let i2 = CONTAINER_HEADER_OFFSET; i2 < declarationLContainer.length; i2++) {
const embeddedLView = declarationLContainer[i2];
if (embeddedLView[DECLARATION_LCONTAINER] === embeddedLView[PARENT]) {
collectQueryResults(embeddedLView[TVIEW], embeddedLView, childQueryIndex, result);
}
}
if (declarationLContainer[MOVED_VIEWS] !== null) {
const embeddedLViews = declarationLContainer[MOVED_VIEWS];
for (let i2 = 0; i2 < embeddedLViews.length; i2++) {
const embeddedLView = embeddedLViews[i2];
collectQueryResults(embeddedLView[TVIEW], embeddedLView, childQueryIndex, result);
}
}
}
}
}
return result;
}
function loadQueryInternal(lView, queryIndex) {
ngDevMode && assertDefined(lView[QUERIES], "LQueries should be defined when trying to load a query");
ngDevMode && assertIndexInRange(lView[QUERIES].queries, queryIndex);
return lView[QUERIES].queries[queryIndex].queryList;
}
function createLQuery(tView, lView, flags) {
const queryList = new QueryList(
(flags & 4) === 4
/* QueryFlags.emitDistinctChangesOnly */
);
storeCleanupWithContext(tView, lView, queryList, queryList.destroy);
const lQueries = (lView[QUERIES] ??= new LQueries_()).queries;
return lQueries.push(new LQuery_(queryList)) - 1;
}
function createViewQuery(predicate, flags, read) {
ngDevMode && assertNumber(flags, "Expecting flags");
const tView = getTView();
if (tView.firstCreatePass) {
createTQuery(tView, new TQueryMetadata_(predicate, flags, read), -1);
if ((flags & 2) === 2) {
tView.staticViewQueries = true;
}
}
return createLQuery(tView, getLView(), flags);
}
function createContentQuery(directiveIndex, predicate, flags, read) {
ngDevMode && assertNumber(flags, "Expecting flags");
const tView = getTView();
if (tView.firstCreatePass) {
const tNode = getCurrentTNode();
createTQuery(tView, new TQueryMetadata_(predicate, flags, read), tNode.index);
saveContentQueryAndDirectiveIndex(tView, directiveIndex);
if ((flags & 2) === 2) {
tView.staticContentQueries = true;
}
}
return createLQuery(tView, getLView(), flags);
}
function splitQueryMultiSelectors(locator) {
return locator.split(",").map((s) => s.trim());
}
function createTQuery(tView, metadata, nodeIndex) {
if (tView.queries === null)
tView.queries = new TQueries_();
tView.queries.track(new TQuery_(metadata, nodeIndex));
}
function saveContentQueryAndDirectiveIndex(tView, directiveIndex) {
const tViewContentQueries = tView.contentQueries || (tView.contentQueries = []);
const lastSavedDirectiveIndex = tViewContentQueries.length ? tViewContentQueries[tViewContentQueries.length - 1] : -1;
if (directiveIndex !== lastSavedDirectiveIndex) {
tViewContentQueries.push(tView.queries.length - 1, directiveIndex);
}
}
function getTQuery(tView, index2) {
ngDevMode && assertDefined(tView.queries, "TQueries must be defined to retrieve a TQuery");
return tView.queries.getByIndex(index2);
}
function getQueryResults(lView, queryIndex) {
const tView = lView[TVIEW];
const tQuery = getTQuery(tView, queryIndex);
return tQuery.crossesNgTemplate ? collectQueryResults(tView, lView, queryIndex, []) : materializeViewResults(tView, lView, tQuery, queryIndex);
}
function isSignal(value2) {
return typeof value2 === "function" && value2[SIGNAL] !== void 0;
}
function signal(initialValue, options) {
performanceMarkFeature("NgSignals");
const signalFn = createSignal(initialValue);
const node = signalFn[SIGNAL];
if (options?.equal) {
node.equal = options.equal;
}
signalFn.set = (newValue) => signalSetFn(node, newValue);
signalFn.update = (updateFn) => signalUpdateFn(node, updateFn);
signalFn.asReadonly = signalAsReadonlyFn.bind(signalFn);
if (ngDevMode) {
signalFn.toString = () => `[Signal: ${signalFn()}]`;
}
return signalFn;
}
function signalAsReadonlyFn() {
const node = this[SIGNAL];
if (node.readonlyFn === void 0) {
const readonlyFn = () => this();
readonlyFn[SIGNAL] = node;
node.readonlyFn = readonlyFn;
}
return node.readonlyFn;
}
function isWritableSignal(value2) {
return isSignal(value2) && typeof value2.set === "function";
}
function createQuerySignalFn(firstOnly, required) {
let node;
const signalFn = createComputed(() => {
node._dirtyCounter();
const value2 = refreshSignalQuery(node, firstOnly);
if (required && value2 === void 0) {
throw new RuntimeError(-951, ngDevMode && "Child query result is required but no value is available.");
}
return value2;
});
node = signalFn[SIGNAL];
node._dirtyCounter = signal(0);
node._flatValue = void 0;
if (ngDevMode) {
signalFn.toString = () => `[Query Signal]`;
}
return signalFn;
}
function createSingleResultOptionalQuerySignalFn() {
return createQuerySignalFn(
/* firstOnly */
true,
/* required */
false
);
}
function createSingleResultRequiredQuerySignalFn() {
return createQuerySignalFn(
/* firstOnly */
true,
/* required */
true
);
}
function createMultiResultQuerySignalFn() {
return createQuerySignalFn(
/* firstOnly */
false,
/* required */
false
);
}
function bindQueryToSignal(target, queryIndex) {
const node = target[SIGNAL];
node._lView = getLView();
node._queryIndex = queryIndex;
node._queryList = loadQueryInternal(node._lView, queryIndex);
node._queryList.onDirty(() => node._dirtyCounter.update((v) => v + 1));
}
function refreshSignalQuery(node, firstOnly) {
const lView = node._lView;
const queryIndex = node._queryIndex;
if (lView === void 0 || queryIndex === void 0 || lView[FLAGS] & 4) {
return firstOnly ? void 0 : EMPTY_ARRAY;
}
const queryList = loadQueryInternal(lView, queryIndex);
const results = getQueryResults(lView, queryIndex);
queryList.reset(results, unwrapElementRef);
if (firstOnly) {
return queryList.first;
} else {
const resultChanged = queryList._changesDetected;
if (resultChanged || node._flatValue === void 0) {
return node._flatValue = queryList.toArray();
}
return node._flatValue;
}
}
function viewChildFn(locator, opts) {
ngDevMode && assertInInjectionContext(viewChild);
return createSingleResultOptionalQuerySignalFn();
}
function viewChildRequiredFn(locator, opts) {
ngDevMode && assertInInjectionContext(viewChild);
return createSingleResultRequiredQuerySignalFn();
}
var viewChild = (() => {
viewChildFn.required = viewChildRequiredFn;
return viewChildFn;
})();
function contentChildFn(locator, opts) {
ngDevMode && assertInInjectionContext(contentChild);
return createSingleResultOptionalQuerySignalFn();
}
function contentChildRequiredFn(locator, opts) {
ngDevMode && assertInInjectionContext(contentChildren);
return createSingleResultRequiredQuerySignalFn();
}
var contentChild = (() => {
contentChildFn.required = contentChildRequiredFn;
return contentChildFn;
})();
function contentChildren(locator, opts) {
return createMultiResultQuerySignalFn();
}
function createModelSignal(initialValue) {
const node = Object.create(INPUT_SIGNAL_NODE);
const emitterRef = new OutputEmitterRef();
node.value = initialValue;
function getter() {
producerAccessed(node);
assertModelSet(node.value);
return node.value;
}
getter[SIGNAL] = node;
getter.asReadonly = signalAsReadonlyFn.bind(getter);
getter.set = (newValue) => {
if (!node.equal(node.value, newValue)) {
signalSetFn(node, newValue);
emitterRef.emit(newValue);
}
};
getter.update = (updateFn) => {
assertModelSet(node.value);
getter.set(updateFn(node.value));
};
getter.subscribe = emitterRef.subscribe.bind(emitterRef);
getter.destroyRef = emitterRef.destroyRef;
if (ngDevMode) {
getter.toString = () => `[Model Signal: ${getter()}]`;
}
return getter;
}
function assertModelSet(value2) {
if (value2 === REQUIRED_UNSET_VALUE) {
throw new RuntimeError(-952, ngDevMode && "Model is required but no value is available yet.");
}
}
function modelFunction(initialValue) {
ngDevMode && assertInInjectionContext(model);
return createModelSignal(initialValue);
}
function modelRequiredFunction() {
ngDevMode && assertInInjectionContext(model);
return createModelSignal(REQUIRED_UNSET_VALUE);
}
var model = (() => {
modelFunction.required = modelRequiredFunction;
return modelFunction;
})();
var emitDistinctChangesOnlyDefaultValue = true;
var Query = class {
};
var ContentChildren = makePropDecorator("ContentChildren", (selector, opts = {}) => __spreadValues({
selector,
first: false,
isViewQuery: false,
descendants: false,
emitDistinctChangesOnly: emitDistinctChangesOnlyDefaultValue
}, opts), Query);
var ContentChild = makePropDecorator("ContentChild", (selector, opts = {}) => __spreadValues({ selector, first: true, isViewQuery: false, descendants: true }, opts), Query);
var ViewChildren = makePropDecorator("ViewChildren", (selector, opts = {}) => __spreadValues({
selector,
first: false,
isViewQuery: true,
descendants: true,
emitDistinctChangesOnly: emitDistinctChangesOnlyDefaultValue
}, opts), Query);
var ViewChild = makePropDecorator("ViewChild", (selector, opts) => __spreadValues({ selector, first: true, isViewQuery: true, descendants: true }, opts), Query);
function resolveComponentResources(resourceResolver) {
const componentResolved = [];
const urlMap = /* @__PURE__ */ new Map();
function cachedResourceResolve(url) {
let promise = urlMap.get(url);
if (!promise) {
const resp = resourceResolver(url);
urlMap.set(url, promise = resp.then(unwrapResponse));
}
return promise;
}
componentResourceResolutionQueue.forEach((component, type) => {
const promises = [];
if (component.templateUrl) {
promises.push(cachedResourceResolve(component.templateUrl).then((template) => {
component.template = template;
}));
}
const styles = typeof component.styles === "string" ? [component.styles] : component.styles || [];
component.styles = styles;
if (component.styleUrl && component.styleUrls?.length) {
throw new Error("@Component cannot define both `styleUrl` and `styleUrls`. Use `styleUrl` if the component has one stylesheet, or `styleUrls` if it has multiple");
} else if (component.styleUrls?.length) {
const styleOffset = component.styles.length;
const styleUrls = component.styleUrls;
component.styleUrls.forEach((styleUrl, index2) => {
styles.push("");
promises.push(cachedResourceResolve(styleUrl).then((style) => {
styles[styleOffset + index2] = style;
styleUrls.splice(styleUrls.indexOf(styleUrl), 1);
if (styleUrls.length == 0) {
component.styleUrls = void 0;
}
}));
});
} else if (component.styleUrl) {
promises.push(cachedResourceResolve(component.styleUrl).then((style) => {
styles.push(style);
component.styleUrl = void 0;
}));
}
const fullyResolved = Promise.all(promises).then(() => componentDefResolved(type));
componentResolved.push(fullyResolved);
});
clearResolutionOfComponentResourcesQueue();
return Promise.all(componentResolved).then(() => void 0);
}
var componentResourceResolutionQueue = /* @__PURE__ */ new Map();
var componentDefPendingResolution = /* @__PURE__ */ new Set();
function maybeQueueResolutionOfComponentResources(type, metadata) {
if (componentNeedsResolution(metadata)) {
componentResourceResolutionQueue.set(type, metadata);
componentDefPendingResolution.add(type);
}
}
function componentNeedsResolution(component) {
return !!(component.templateUrl && !component.hasOwnProperty("template") || component.styleUrls && component.styleUrls.length || component.styleUrl);
}
function clearResolutionOfComponentResourcesQueue() {
const old = componentResourceResolutionQueue;
componentResourceResolutionQueue = /* @__PURE__ */ new Map();
return old;
}
function isComponentResourceResolutionQueueEmpty() {
return componentResourceResolutionQueue.size === 0;
}
function unwrapResponse(response) {
return typeof response == "string" ? response : response.text();
}
function componentDefResolved(type) {
componentDefPendingResolution.delete(type);
}
var modules = /* @__PURE__ */ new Map();
var checkForDuplicateNgModules = true;
function assertSameOrNotExisting(id, type, incoming) {
if (type && type !== incoming && checkForDuplicateNgModules) {
throw new Error(`Duplicate module registered for ${id} - ${stringify(type)} vs ${stringify(type.name)}`);
}
}
function registerNgModuleType(ngModuleType, id) {
const existing = modules.get(id) || null;
assertSameOrNotExisting(id, existing, ngModuleType);
modules.set(id, ngModuleType);
}
function \u0275\u0275validateIframeAttribute(attrValue, tagName, attrName) {
const lView = getLView();
const tNode = getSelectedTNode();
const element = getNativeByTNode(tNode, lView);
if (tNode.type === 2 && tagName.toLowerCase() === "iframe") {
const iframe = element;
iframe.src = "";
iframe.srcdoc = trustedHTMLFromString("");
nativeRemoveNode(lView[RENDERER], iframe);
const errorMessage = ngDevMode && `Angular has detected that the \`${attrName}\` was applied as a binding to an <iframe>${getTemplateLocationDetails(lView)}. For security reasons, the \`${attrName}\` can be set on an <iframe> as a static attribute only.
To fix this, switch the \`${attrName}\` binding to a static attribute in a template or in host bindings section.`;
throw new RuntimeError(-910, errorMessage);
}
return attrValue;
}
function getSuperType(type) {
return Object.getPrototypeOf(type.prototype).constructor;
}
function \u0275\u0275InheritDefinitionFeature(definition) {
let superType = getSuperType(definition.type);
let shouldInheritFields = true;
const inheritanceChain = [definition];
while (superType) {
let superDef = void 0;
if (isComponentDef(definition)) {
superDef = superType.\u0275cmp || superType.\u0275dir;
} else {
if (superType.\u0275cmp) {
throw new RuntimeError(903, ngDevMode && `Directives cannot inherit Components. Directive ${stringifyForError(definition.type)} is attempting to extend component ${stringifyForError(superType)}`);
}
superDef = superType.\u0275dir;
}
if (superDef) {
if (shouldInheritFields) {
inheritanceChain.push(superDef);
const writeableDef = definition;
writeableDef.inputs = maybeUnwrapEmpty(definition.inputs);
writeableDef.inputTransforms = maybeUnwrapEmpty(definition.inputTransforms);
writeableDef.declaredInputs = maybeUnwrapEmpty(definition.declaredInputs);
writeableDef.outputs = maybeUnwrapEmpty(definition.outputs);
const superHostBindings = superDef.hostBindings;
superHostBindings && inheritHostBindings(definition, superHostBindings);
const superViewQuery = superDef.viewQuery;
const superContentQueries = superDef.contentQueries;
superViewQuery && inheritViewQuery(definition, superViewQuery);
superContentQueries && inheritContentQueries(definition, superContentQueries);
mergeInputsWithTransforms(definition, superDef);
fillProperties(definition.outputs, superDef.outputs);
if (isComponentDef(superDef) && superDef.data.animation) {
const defData = definition.data;
defData.animation = (defData.animation || []).concat(superDef.data.animation);
}
}
const features = superDef.features;
if (features) {
for (let i = 0; i < features.length; i++) {
const feature = features[i];
if (feature && feature.ngInherit) {
feature(definition);
}
if (feature === \u0275\u0275InheritDefinitionFeature) {
shouldInheritFields = false;
}
}
}
}
superType = Object.getPrototypeOf(superType);
}
mergeHostAttrsAcrossInheritance(inheritanceChain);
}
function mergeInputsWithTransforms(target, source) {
for (const key2 in source.inputs) {
if (!source.inputs.hasOwnProperty(key2)) {
continue;
}
if (target.inputs.hasOwnProperty(key2)) {
continue;
}
const value2 = source.inputs[key2];
if (value2 === void 0) {
continue;
}
target.inputs[key2] = value2;
target.declaredInputs[key2] = source.declaredInputs[key2];
if (source.inputTransforms !== null) {
const minifiedName = Array.isArray(value2) ? value2[0] : value2;
if (!source.inputTransforms.hasOwnProperty(minifiedName)) {
continue;
}
target.inputTransforms ??= {};
target.inputTransforms[minifiedName] = source.inputTransforms[minifiedName];
}
}
}
function mergeHostAttrsAcrossInheritance(inheritanceChain) {
let hostVars = 0;
let hostAttrs = null;
for (let i = inheritanceChain.length - 1; i >= 0; i--) {
const def = inheritanceChain[i];
def.hostVars = hostVars += def.hostVars;
def.hostAttrs = mergeHostAttrs(def.hostAttrs, hostAttrs = mergeHostAttrs(hostAttrs, def.hostAttrs));
}
}
function maybeUnwrapEmpty(value2) {
if (value2 === EMPTY_OBJ) {
return {};
} else if (value2 === EMPTY_ARRAY) {
return [];
} else {
return value2;
}
}
function inheritViewQuery(definition, superViewQuery) {
const prevViewQuery = definition.viewQuery;
if (prevViewQuery) {
definition.viewQuery = (rf, ctx) => {
superViewQuery(rf, ctx);
prevViewQuery(rf, ctx);
};
} else {
definition.viewQuery = superViewQuery;
}
}
function inheritContentQueries(definition, superContentQueries) {
const prevContentQueries = definition.contentQueries;
if (prevContentQueries) {
definition.contentQueries = (rf, ctx, directiveIndex) => {
superContentQueries(rf, ctx, directiveIndex);
prevContentQueries(rf, ctx, directiveIndex);
};
} else {
definition.contentQueries = superContentQueries;
}
}
function inheritHostBindings(definition, superHostBindings) {
const prevHostBindings = definition.hostBindings;
if (prevHostBindings) {
definition.hostBindings = (rf, ctx) => {
superHostBindings(rf, ctx);
prevHostBindings(rf, ctx);
};
} else {
definition.hostBindings = superHostBindings;
}
}
var COPY_DIRECTIVE_FIELDS = [
// The child class should use the providers of its parent.
"providersResolver"
// Not listed here are any fields which are handled by the `ɵɵInheritDefinitionFeature`, such
// as inputs, outputs, and host binding functions.
];
var COPY_COMPONENT_FIELDS = [
// The child class should use the template function of its parent, including all template
// semantics.
"template",
"decls",
"consts",
"vars",
"onPush",
"ngContentSelectors",
// The child class should use the CSS styles of its parent, including all styling semantics.
"styles",
"encapsulation",
// The child class should be checked by the runtime in the same way as its parent.
"schemas"
];
function \u0275\u0275CopyDefinitionFeature(definition) {
let superType = getSuperType(definition.type);
let superDef = void 0;
if (isComponentDef(definition)) {
superDef = superType.\u0275cmp;
} else {
superDef = superType.\u0275dir;
}
const defAny = definition;
for (const field of COPY_DIRECTIVE_FIELDS) {
defAny[field] = superDef[field];
}
if (isComponentDef(superDef)) {
for (const field of COPY_COMPONENT_FIELDS) {
defAny[field] = superDef[field];
}
}
}
function \u0275\u0275HostDirectivesFeature(rawHostDirectives) {
const feature = (definition) => {
const resolved = (Array.isArray(rawHostDirectives) ? rawHostDirectives : rawHostDirectives()).map((dir) => {
return typeof dir === "function" ? { directive: resolveForwardRef(dir), inputs: EMPTY_OBJ, outputs: EMPTY_OBJ } : {
directive: resolveForwardRef(dir.directive),
inputs: bindingArrayToMap(dir.inputs),
outputs: bindingArrayToMap(dir.outputs)
};
});
if (definition.hostDirectives === null) {
definition.findHostDirectiveDefs = findHostDirectiveDefs;
definition.hostDirectives = resolved;
} else {
definition.hostDirectives.unshift(...resolved);
}
};
feature.ngInherit = true;
return feature;
}
function findHostDirectiveDefs(currentDef, matchedDefs, hostDirectiveDefs) {
if (currentDef.hostDirectives !== null) {
for (const hostDirectiveConfig of currentDef.hostDirectives) {
const hostDirectiveDef = getDirectiveDef(hostDirectiveConfig.directive);
if (typeof ngDevMode === "undefined" || ngDevMode) {
validateHostDirective(hostDirectiveConfig, hostDirectiveDef);
}
patchDeclaredInputs(hostDirectiveDef.declaredInputs, hostDirectiveConfig.inputs);
findHostDirectiveDefs(hostDirectiveDef, matchedDefs, hostDirectiveDefs);
hostDirectiveDefs.set(hostDirectiveDef, hostDirectiveConfig);
matchedDefs.push(hostDirectiveDef);
}
}
}
function bindingArrayToMap(bindings) {
if (bindings === void 0 || bindings.length === 0) {
return EMPTY_OBJ;
}
const result = {};
for (let i = 0; i < bindings.length; i += 2) {
result[bindings[i]] = bindings[i + 1];
}
return result;
}
function patchDeclaredInputs(declaredInputs, exposedInputs) {
for (const publicName in exposedInputs) {
if (exposedInputs.hasOwnProperty(publicName)) {
const remappedPublicName = exposedInputs[publicName];
const privateName = declaredInputs[publicName];
if ((typeof ngDevMode === "undefined" || ngDevMode) && declaredInputs.hasOwnProperty(remappedPublicName)) {
assertEqual(declaredInputs[remappedPublicName], declaredInputs[publicName], `Conflicting host directive input alias ${publicName}.`);
}
declaredInputs[remappedPublicName] = privateName;
}
}
}
function validateHostDirective(hostDirectiveConfig, directiveDef) {
const type = hostDirectiveConfig.directive;
if (directiveDef === null) {
if (getComponentDef(type) !== null) {
throw new RuntimeError(310, `Host directive ${type.name} cannot be a component.`);
}
throw new RuntimeError(307, `Could not resolve metadata for host directive ${type.name}. Make sure that the ${type.name} class is annotated with an @Directive decorator.`);
}
if (!directiveDef.standalone) {
throw new RuntimeError(308, `Host directive ${directiveDef.type.name} must be standalone.`);
}
validateMappings("input", directiveDef, hostDirectiveConfig.inputs);
validateMappings("output", directiveDef, hostDirectiveConfig.outputs);
}
function validateMappings(bindingType, def, hostDirectiveBindings) {
const className = def.type.name;
const bindings = bindingType === "input" ? def.inputs : def.outputs;
for (const publicName in hostDirectiveBindings) {
if (hostDirectiveBindings.hasOwnProperty(publicName)) {
if (!bindings.hasOwnProperty(publicName)) {
throw new RuntimeError(311, `Directive ${className} does not have an ${bindingType} with a public name of ${publicName}.`);
}
const remappedPublicName = hostDirectiveBindings[publicName];
if (bindings.hasOwnProperty(remappedPublicName) && remappedPublicName !== publicName) {
throw new RuntimeError(312, `Cannot alias ${bindingType} ${publicName} of host directive ${className} to ${remappedPublicName}, because it already has a different ${bindingType} with the same public name.`);
}
}
}
}
function \u0275\u0275InputTransformsFeature(definition) {
const inputs = definition.inputConfig;
const inputTransforms = {};
for (const minifiedKey in inputs) {
if (inputs.hasOwnProperty(minifiedKey)) {
const value2 = inputs[minifiedKey];
if (Array.isArray(value2) && value2[3]) {
inputTransforms[minifiedKey] = value2[3];
}
}
}
definition.inputTransforms = inputTransforms;
}
var NgModuleRef$1 = class {
};
var NgModuleFactory$1 = class {
};
function createNgModule(ngModule, parentInjector) {
return new NgModuleRef(ngModule, parentInjector ?? null, []);
}
var NgModuleRef = class extends NgModuleRef$1 {
constructor(ngModuleType, _parent, additionalProviders) {
super();
this._parent = _parent;
this._bootstrapComponents = [];
this.destroyCbs = [];
this.componentFactoryResolver = new ComponentFactoryResolver(this);
const ngModuleDef = getNgModuleDef(ngModuleType);
ngDevMode && assertDefined(ngModuleDef, `NgModule '${stringify(ngModuleType)}' is not a subtype of 'NgModuleType'.`);
this._bootstrapComponents = maybeUnwrapFn(ngModuleDef.bootstrap);
this._r3Injector = createInjectorWithoutInjectorInstances(ngModuleType, _parent, [
{ provide: NgModuleRef$1, useValue: this },
{
provide: ComponentFactoryResolver$1,
useValue: this.componentFactoryResolver
},
...additionalProviders
], stringify(ngModuleType), /* @__PURE__ */ new Set(["environment"]));
this._r3Injector.resolveInjectorInitializers();
this.instance = this._r3Injector.get(ngModuleType);
}
get injector() {
return this._r3Injector;
}
destroy() {
ngDevMode && assertDefined(this.destroyCbs, "NgModule already destroyed");
const injector = this._r3Injector;
!injector.destroyed && injector.destroy();
this.destroyCbs.forEach((fn) => fn());
this.destroyCbs = null;
}
onDestroy(callback) {
ngDevMode && assertDefined(this.destroyCbs, "NgModule already destroyed");
this.destroyCbs.push(callback);
}
};
var NgModuleFactory = class extends NgModuleFactory$1 {
constructor(moduleType) {
super();
this.moduleType = moduleType;
}
create(parentInjector) {
return new NgModuleRef(this.moduleType, parentInjector, []);
}
};
function createNgModuleRefWithProviders(moduleType, parentInjector, additionalProviders) {
return new NgModuleRef(moduleType, parentInjector, additionalProviders);
}
var EnvironmentNgModuleRefAdapter = class extends NgModuleRef$1 {
constructor(config2) {
super();
this.componentFactoryResolver = new ComponentFactoryResolver(this);
this.instance = null;
const injector = new R3Injector([
...config2.providers,
{ provide: NgModuleRef$1, useValue: this },
{ provide: ComponentFactoryResolver$1, useValue: this.componentFactoryResolver }
], config2.parent || getNullInjector(), config2.debugName, /* @__PURE__ */ new Set(["environment"]));
this.injector = injector;
if (config2.runEnvironmentInitializers) {
injector.resolveInjectorInitializers();
}
}
destroy() {
this.injector.destroy();
}
onDestroy(callback) {
this.injector.onDestroy(callback);
}
};
function createEnvironmentInjector(providers, parent2, debugName = null) {
const adapter = new EnvironmentNgModuleRefAdapter({ providers, parent: parent2, debugName, runEnvironmentInitializers: true });
return adapter.injector;
}
var _CachedInjectorService = class _CachedInjectorService {
constructor() {
this.cachedInjectors = /* @__PURE__ */ new Map();
}
getOrCreateInjector(key2, parentInjector, providers, debugName) {
if (!this.cachedInjectors.has(key2)) {
const injector = providers.length > 0 ? createEnvironmentInjector(providers, parentInjector, debugName) : null;
this.cachedInjectors.set(key2, injector);
}
return this.cachedInjectors.get(key2);
}
ngOnDestroy() {
try {
for (const injector of this.cachedInjectors.values()) {
if (injector !== null) {
injector.destroy();
}
}
} finally {
this.cachedInjectors.clear();
}
}
};
_CachedInjectorService.\u0275prov = \u0275\u0275defineInjectable({
token: _CachedInjectorService,
providedIn: "environment",
factory: () => new _CachedInjectorService()
});
var CachedInjectorService = _CachedInjectorService;
function setClassMetadata(type, decorators, ctorParameters, propDecorators) {
return noSideEffects(() => {
const clazz = type;
if (decorators !== null) {
if (clazz.hasOwnProperty("decorators") && clazz.decorators !== void 0) {
clazz.decorators.push(...decorators);
} else {
clazz.decorators = decorators;
}
}
if (ctorParameters !== null) {
clazz.ctorParameters = ctorParameters;
}
if (propDecorators !== null) {
if (clazz.hasOwnProperty("propDecorators") && clazz.propDecorators !== void 0) {
clazz.propDecorators = __spreadValues(__spreadValues({}, clazz.propDecorators), propDecorators);
} else {
clazz.propDecorators = propDecorators;
}
}
});
}
var _PendingTasks = class _PendingTasks {
constructor() {
this.taskId = 0;
this.pendingTasks = /* @__PURE__ */ new Set();
this.hasPendingTasks = new BehaviorSubject(false);
}
get _hasPendingTasks() {
return this.hasPendingTasks.value;
}
add() {
if (!this._hasPendingTasks) {
this.hasPendingTasks.next(true);
}
const taskId = this.taskId++;
this.pendingTasks.add(taskId);
return taskId;
}
remove(taskId) {
this.pendingTasks.delete(taskId);
if (this.pendingTasks.size === 0 && this._hasPendingTasks) {
this.hasPendingTasks.next(false);
}
}
ngOnDestroy() {
this.pendingTasks.clear();
if (this._hasPendingTasks) {
this.hasPendingTasks.next(false);
}
}
};
_PendingTasks.\u0275fac = function PendingTasks_Factory(t) {
return new (t || _PendingTasks)();
};
_PendingTasks.\u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({ token: _PendingTasks, factory: _PendingTasks.\u0275fac, providedIn: "root" });
var PendingTasks = _PendingTasks;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(PendingTasks, [{
type: Injectable,
args: [{ providedIn: "root" }]
}], null, null);
})();
function isListLikeIterable(obj) {
if (!isJsObject(obj))
return false;
return Array.isArray(obj) || !(obj instanceof Map) && // JS Map are iterables but return entries as [k, v]
Symbol.iterator in obj;
}
function areIterablesEqual(a, b, comparator) {
const iterator1 = a[Symbol.iterator]();
const iterator2 = b[Symbol.iterator]();
while (true) {
const item1 = iterator1.next();
const item2 = iterator2.next();
if (item1.done && item2.done)
return true;
if (item1.done || item2.done)
return false;
if (!comparator(item1.value, item2.value))
return false;
}
}
function iterateListLike(obj, fn) {
if (Array.isArray(obj)) {
for (let i = 0; i < obj.length; i++) {
fn(obj[i]);
}
} else {
const iterator2 = obj[Symbol.iterator]();
let item;
while (!(item = iterator2.next()).done) {
fn(item.value);
}
}
}
function isJsObject(o) {
return o !== null && (typeof o === "function" || typeof o === "object");
}
function devModeEqual(a, b) {
const isListLikeIterableA = isListLikeIterable(a);
const isListLikeIterableB = isListLikeIterable(b);
if (isListLikeIterableA && isListLikeIterableB) {
return areIterablesEqual(a, b, devModeEqual);
} else {
const isAObject = a && (typeof a === "object" || typeof a === "function");
const isBObject = b && (typeof b === "object" || typeof b === "function");
if (!isListLikeIterableA && isAObject && !isListLikeIterableB && isBObject) {
return true;
} else {
return Object.is(a, b);
}
}
}
function updateBinding(lView, bindingIndex, value2) {
return lView[bindingIndex] = value2;
}
function getBinding(lView, bindingIndex) {
ngDevMode && assertIndexInRange(lView, bindingIndex);
ngDevMode && assertNotSame(lView[bindingIndex], NO_CHANGE, "Stored value should never be NO_CHANGE.");
return lView[bindingIndex];
}
function bindingUpdated(lView, bindingIndex, value2) {
ngDevMode && assertNotSame(value2, NO_CHANGE, "Incoming value should never be NO_CHANGE.");
ngDevMode && assertLessThan(bindingIndex, lView.length, `Slot should have been initialized to NO_CHANGE`);
const oldValue = lView[bindingIndex];
if (Object.is(oldValue, value2)) {
return false;
} else {
if (ngDevMode && isInCheckNoChangesMode()) {
const oldValueToCompare = oldValue !== NO_CHANGE ? oldValue : void 0;
if (!devModeEqual(oldValueToCompare, value2)) {
const details = getExpressionChangedErrorDetails(lView, bindingIndex, oldValueToCompare, value2);
throwErrorIfNoChangesMode(oldValue === NO_CHANGE, details.oldValue, details.newValue, details.propName, lView);
}
return false;
}
lView[bindingIndex] = value2;
return true;
}
}
function bindingUpdated2(lView, bindingIndex, exp1, exp2) {
const different = bindingUpdated(lView, bindingIndex, exp1);
return bindingUpdated(lView, bindingIndex + 1, exp2) || different;
}
function bindingUpdated3(lView, bindingIndex, exp1, exp2, exp3) {
const different = bindingUpdated2(lView, bindingIndex, exp1, exp2);
return bindingUpdated(lView, bindingIndex + 2, exp3) || different;
}
function bindingUpdated4(lView, bindingIndex, exp1, exp2, exp3, exp4) {
const different = bindingUpdated2(lView, bindingIndex, exp1, exp2);
return bindingUpdated2(lView, bindingIndex + 2, exp3, exp4) || different;
}
function isDetachedByI18n(tNode) {
return (tNode.flags & 32) === 32;
}
function templateFirstCreatePass(index2, tView, lView, templateFn, decls, vars, tagName, attrsIndex, localRefsIndex) {
ngDevMode && assertFirstCreatePass(tView);
ngDevMode && ngDevMode.firstCreatePass++;
const tViewConsts = tView.consts;
const tNode = getOrCreateTNode(tView, index2, 4, tagName || null, getConstant(tViewConsts, attrsIndex));
resolveDirectives(tView, lView, tNode, getConstant(tViewConsts, localRefsIndex));
registerPostOrderHooks(tView, tNode);
const embeddedTView = tNode.tView = createTView(
2,
tNode,
templateFn,
decls,
vars,
tView.directiveRegistry,
tView.pipeRegistry,
null,
tView.schemas,
tViewConsts,
null
/* ssrId */
);
if (tView.queries !== null) {
tView.queries.template(tView, tNode);
embeddedTView.queries = tView.queries.embeddedTView(tNode);
}
return tNode;
}
function \u0275\u0275template(index2, templateFn, decls, vars, tagName, attrsIndex, localRefsIndex, localRefExtractor) {
const lView = getLView();
const tView = getTView();
const adjustedIndex = index2 + HEADER_OFFSET;
const tNode = tView.firstCreatePass ? templateFirstCreatePass(adjustedIndex, tView, lView, templateFn, decls, vars, tagName, attrsIndex, localRefsIndex) : tView.data[adjustedIndex];
setCurrentTNode(tNode, false);
const comment = _locateOrCreateContainerAnchor(tView, lView, tNode, index2);
if (wasLastNodeCreated()) {
appendChild(tView, lView, comment, tNode);
}
attachPatchData(comment, lView);
const lContainer = createLContainer(comment, lView, comment, tNode);
lView[adjustedIndex] = lContainer;
addToViewTree(lView, lContainer);
populateDehydratedViewsInLContainer(lContainer, tNode, lView);
if (isDirectiveHost(tNode)) {
createDirectivesInstances(tView, lView, tNode);
}
if (localRefsIndex != null) {
saveResolvedLocalsInData(lView, tNode, localRefExtractor);
}
return \u0275\u0275template;
}
var _locateOrCreateContainerAnchor = createContainerAnchorImpl;
function createContainerAnchorImpl(tView, lView, tNode, index2) {
lastNodeWasCreated(true);
return lView[RENDERER].createComment(ngDevMode ? "container" : "");
}
var DeferDependenciesLoadingState;
(function(DeferDependenciesLoadingState2) {
DeferDependenciesLoadingState2[DeferDependenciesLoadingState2["NOT_STARTED"] = 0] = "NOT_STARTED";
DeferDependenciesLoadingState2[DeferDependenciesLoadingState2["IN_PROGRESS"] = 1] = "IN_PROGRESS";
DeferDependenciesLoadingState2[DeferDependenciesLoadingState2["COMPLETE"] = 2] = "COMPLETE";
DeferDependenciesLoadingState2[DeferDependenciesLoadingState2["FAILED"] = 3] = "FAILED";
})(DeferDependenciesLoadingState || (DeferDependenciesLoadingState = {}));
var MINIMUM_SLOT = 0;
var LOADING_AFTER_SLOT = 1;
var DeferBlockState;
(function(DeferBlockState2) {
DeferBlockState2[DeferBlockState2["Placeholder"] = 0] = "Placeholder";
DeferBlockState2[DeferBlockState2["Loading"] = 1] = "Loading";
DeferBlockState2[DeferBlockState2["Complete"] = 2] = "Complete";
DeferBlockState2[DeferBlockState2["Error"] = 3] = "Error";
})(DeferBlockState || (DeferBlockState = {}));
var DeferBlockInternalState;
(function(DeferBlockInternalState2) {
DeferBlockInternalState2[DeferBlockInternalState2["Initial"] = -1] = "Initial";
})(DeferBlockInternalState || (DeferBlockInternalState = {}));
var NEXT_DEFER_BLOCK_STATE = 0;
var DEFER_BLOCK_STATE = 1;
var STATE_IS_FROZEN_UNTIL = 2;
var LOADING_AFTER_CLEANUP_FN = 3;
var TRIGGER_CLEANUP_FNS = 4;
var PREFETCH_TRIGGER_CLEANUP_FNS = 5;
var DeferBlockBehavior;
(function(DeferBlockBehavior2) {
DeferBlockBehavior2[DeferBlockBehavior2["Manual"] = 0] = "Manual";
DeferBlockBehavior2[DeferBlockBehavior2["Playthrough"] = 1] = "Playthrough";
})(DeferBlockBehavior || (DeferBlockBehavior = {}));
function storeTriggerCleanupFn(type, lDetails, cleanupFn) {
const key2 = type === 1 ? PREFETCH_TRIGGER_CLEANUP_FNS : TRIGGER_CLEANUP_FNS;
if (lDetails[key2] === null) {
lDetails[key2] = [];
}
lDetails[key2].push(cleanupFn);
}
function invokeTriggerCleanupFns(type, lDetails) {
const key2 = type === 1 ? PREFETCH_TRIGGER_CLEANUP_FNS : TRIGGER_CLEANUP_FNS;
const cleanupFns = lDetails[key2];
if (cleanupFns !== null) {
for (const cleanupFn of cleanupFns) {
cleanupFn();
}
lDetails[key2] = null;
}
}
function invokeAllTriggerCleanupFns(lDetails) {
invokeTriggerCleanupFns(1, lDetails);
invokeTriggerCleanupFns(0, lDetails);
}
function getDeferBlockDataIndex(deferBlockIndex) {
return deferBlockIndex + 1;
}
function getLDeferBlockDetails(lView, tNode) {
const tView = lView[TVIEW];
const slotIndex = getDeferBlockDataIndex(tNode.index);
ngDevMode && assertIndexInDeclRange(tView, slotIndex);
return lView[slotIndex];
}
function setLDeferBlockDetails(lView, deferBlockIndex, lDetails) {
const tView = lView[TVIEW];
const slotIndex = getDeferBlockDataIndex(deferBlockIndex);
ngDevMode && assertIndexInDeclRange(tView, slotIndex);
lView[slotIndex] = lDetails;
}
function getTDeferBlockDetails(tView, tNode) {
const slotIndex = getDeferBlockDataIndex(tNode.index);
ngDevMode && assertIndexInDeclRange(tView, slotIndex);
return tView.data[slotIndex];
}
function setTDeferBlockDetails(tView, deferBlockIndex, deferBlockConfig) {
const slotIndex = getDeferBlockDataIndex(deferBlockIndex);
ngDevMode && assertIndexInDeclRange(tView, slotIndex);
tView.data[slotIndex] = deferBlockConfig;
}
function getTemplateIndexForState(newState, hostLView, tNode) {
const tView = hostLView[TVIEW];
const tDetails = getTDeferBlockDetails(tView, tNode);
switch (newState) {
case DeferBlockState.Complete:
return tDetails.primaryTmplIndex;
case DeferBlockState.Loading:
return tDetails.loadingTmplIndex;
case DeferBlockState.Error:
return tDetails.errorTmplIndex;
case DeferBlockState.Placeholder:
return tDetails.placeholderTmplIndex;
default:
ngDevMode && throwError2(`Unexpected defer block state: ${newState}`);
return null;
}
}
function getMinimumDurationForState(tDetails, currentState) {
if (currentState === DeferBlockState.Placeholder) {
return tDetails.placeholderBlockConfig?.[MINIMUM_SLOT] ?? null;
} else if (currentState === DeferBlockState.Loading) {
return tDetails.loadingBlockConfig?.[MINIMUM_SLOT] ?? null;
}
return null;
}
function getLoadingBlockAfter(tDetails) {
return tDetails.loadingBlockConfig?.[LOADING_AFTER_SLOT] ?? null;
}
function addDepsToRegistry(currentDeps, newDeps) {
if (!currentDeps || currentDeps.length === 0) {
return newDeps;
}
const currentDepSet = new Set(currentDeps);
for (const dep of newDeps) {
currentDepSet.add(dep);
}
return currentDeps.length === currentDepSet.size ? currentDeps : Array.from(currentDepSet);
}
function getPrimaryBlockTNode(tView, tDetails) {
const adjustedIndex = tDetails.primaryTmplIndex + HEADER_OFFSET;
return getTNode(tView, adjustedIndex);
}
function assertDeferredDependenciesLoaded(tDetails) {
assertEqual(tDetails.loadingState, DeferDependenciesLoadingState.COMPLETE, "Expecting all deferred dependencies to be loaded.");
}
var eventListenerOptions = {
passive: true,
capture: true
};
var hoverTriggers = /* @__PURE__ */ new WeakMap();
var interactionTriggers = /* @__PURE__ */ new WeakMap();
var viewportTriggers = /* @__PURE__ */ new WeakMap();
var interactionEventNames = ["click", "keydown"];
var hoverEventNames = ["mouseenter", "focusin"];
var intersectionObserver = null;
var observedViewportElements = 0;
var DeferEventEntry = class {
constructor() {
this.callbacks = /* @__PURE__ */ new Set();
this.listener = () => {
for (const callback of this.callbacks) {
callback();
}
};
}
};
function onInteraction(trigger, callback) {
let entry = interactionTriggers.get(trigger);
if (!entry) {
entry = new DeferEventEntry();
interactionTriggers.set(trigger, entry);
for (const name2 of interactionEventNames) {
trigger.addEventListener(name2, entry.listener, eventListenerOptions);
}
}
entry.callbacks.add(callback);
return () => {
const { callbacks, listener } = entry;
callbacks.delete(callback);
if (callbacks.size === 0) {
interactionTriggers.delete(trigger);
for (const name2 of interactionEventNames) {
trigger.removeEventListener(name2, listener, eventListenerOptions);
}
}
};
}
function onHover(trigger, callback) {
let entry = hoverTriggers.get(trigger);
if (!entry) {
entry = new DeferEventEntry();
hoverTriggers.set(trigger, entry);
for (const name2 of hoverEventNames) {
trigger.addEventListener(name2, entry.listener, eventListenerOptions);
}
}
entry.callbacks.add(callback);
return () => {
const { callbacks, listener } = entry;
callbacks.delete(callback);
if (callbacks.size === 0) {
for (const name2 of hoverEventNames) {
trigger.removeEventListener(name2, listener, eventListenerOptions);
}
hoverTriggers.delete(trigger);
}
};
}
function onViewport(trigger, callback, injector) {
const ngZone = injector.get(NgZone);
let entry = viewportTriggers.get(trigger);
intersectionObserver = intersectionObserver || ngZone.runOutsideAngular(() => {
return new IntersectionObserver((entries) => {
for (const current of entries) {
if (current.isIntersecting && viewportTriggers.has(current.target)) {
ngZone.run(viewportTriggers.get(current.target).listener);
}
}
});
});
if (!entry) {
entry = new DeferEventEntry();
ngZone.runOutsideAngular(() => intersectionObserver.observe(trigger));
viewportTriggers.set(trigger, entry);
observedViewportElements++;
}
entry.callbacks.add(callback);
return () => {
if (!viewportTriggers.has(trigger)) {
return;
}
entry.callbacks.delete(callback);
if (entry.callbacks.size === 0) {
intersectionObserver?.unobserve(trigger);
viewportTriggers.delete(trigger);
observedViewportElements--;
}
if (observedViewportElements === 0) {
intersectionObserver?.disconnect();
intersectionObserver = null;
}
};
}
function getTriggerLView(deferredHostLView, deferredTNode, walkUpTimes) {
if (walkUpTimes == null) {
return deferredHostLView;
}
if (walkUpTimes >= 0) {
return walkUpViews(walkUpTimes, deferredHostLView);
}
const deferredContainer = deferredHostLView[deferredTNode.index];
ngDevMode && assertLContainer(deferredContainer);
const triggerLView = deferredContainer[CONTAINER_HEADER_OFFSET] ?? null;
if (ngDevMode && triggerLView !== null) {
const lDetails = getLDeferBlockDetails(deferredHostLView, deferredTNode);
const renderedState = lDetails[DEFER_BLOCK_STATE];
assertEqual(renderedState, DeferBlockState.Placeholder, "Expected a placeholder to be rendered in this defer block.");
assertLView(triggerLView);
}
return triggerLView;
}
function getTriggerElement(triggerLView, triggerIndex) {
const element = getNativeByIndex(HEADER_OFFSET + triggerIndex, triggerLView);
ngDevMode && assertElement(element);
return element;
}
function registerDomTrigger(initialLView, tNode, triggerIndex, walkUpTimes, registerFn, callback, type) {
const injector = initialLView[INJECTOR];
function pollDomTrigger() {
if (isDestroyed(initialLView)) {
return;
}
const lDetails = getLDeferBlockDetails(initialLView, tNode);
const renderedState = lDetails[DEFER_BLOCK_STATE];
if (renderedState !== DeferBlockInternalState.Initial && renderedState !== DeferBlockState.Placeholder) {
return;
}
const triggerLView = getTriggerLView(initialLView, tNode, walkUpTimes);
if (!triggerLView) {
internalAfterNextRender(pollDomTrigger, { injector });
return;
}
if (isDestroyed(triggerLView)) {
return;
}
const element = getTriggerElement(triggerLView, triggerIndex);
const cleanup = registerFn(element, () => {
if (initialLView !== triggerLView) {
removeLViewOnDestroy(triggerLView, cleanup);
}
callback();
}, injector);
if (initialLView !== triggerLView) {
storeLViewOnDestroy(triggerLView, cleanup);
}
storeTriggerCleanupFn(type, lDetails, cleanup);
}
internalAfterNextRender(pollDomTrigger, { injector });
}
function onIdle(callback, lView) {
const injector = lView[INJECTOR];
const scheduler = injector.get(IdleScheduler);
const cleanupFn = () => scheduler.remove(callback);
scheduler.add(callback);
return cleanupFn;
}
var _requestIdleCallback = () => typeof requestIdleCallback !== "undefined" ? requestIdleCallback : setTimeout;
var _cancelIdleCallback = () => typeof requestIdleCallback !== "undefined" ? cancelIdleCallback : clearTimeout;
var _IdleScheduler = class _IdleScheduler {
constructor() {
this.executingCallbacks = false;
this.idleId = null;
this.current = /* @__PURE__ */ new Set();
this.deferred = /* @__PURE__ */ new Set();
this.ngZone = inject(NgZone);
this.requestIdleCallbackFn = _requestIdleCallback().bind(globalThis);
this.cancelIdleCallbackFn = _cancelIdleCallback().bind(globalThis);
}
add(callback) {
const target = this.executingCallbacks ? this.deferred : this.current;
target.add(callback);
if (this.idleId === null) {
this.scheduleIdleCallback();
}
}
remove(callback) {
const { current, deferred } = this;
current.delete(callback);
deferred.delete(callback);
if (current.size === 0 && deferred.size === 0) {
this.cancelIdleCallback();
}
}
scheduleIdleCallback() {
const callback = () => {
this.cancelIdleCallback();
this.executingCallbacks = true;
for (const callback2 of this.current) {
callback2();
}
this.current.clear();
this.executingCallbacks = false;
if (this.deferred.size > 0) {
for (const callback2 of this.deferred) {
this.current.add(callback2);
}
this.deferred.clear();
this.scheduleIdleCallback();
}
};
this.idleId = this.requestIdleCallbackFn(() => this.ngZone.run(callback));
}
cancelIdleCallback() {
if (this.idleId !== null) {
this.cancelIdleCallbackFn(this.idleId);
this.idleId = null;
}
}
ngOnDestroy() {
this.cancelIdleCallback();
this.current.clear();
this.deferred.clear();
}
};
_IdleScheduler.\u0275prov = \u0275\u0275defineInjectable({
token: _IdleScheduler,
providedIn: "root",
factory: () => new _IdleScheduler()
});
var IdleScheduler = _IdleScheduler;
function onTimer(delay) {
return (callback, lView) => scheduleTimerTrigger(delay, callback, lView);
}
function scheduleTimerTrigger(delay, callback, lView) {
const injector = lView[INJECTOR];
const scheduler = injector.get(TimerScheduler);
const cleanupFn = () => scheduler.remove(callback);
scheduler.add(delay, callback);
return cleanupFn;
}
var _TimerScheduler = class _TimerScheduler {
constructor() {
this.executingCallbacks = false;
this.timeoutId = null;
this.invokeTimerAt = null;
this.current = [];
this.deferred = [];
}
add(delay, callback) {
const target = this.executingCallbacks ? this.deferred : this.current;
this.addToQueue(target, Date.now() + delay, callback);
this.scheduleTimer();
}
remove(callback) {
const { current, deferred } = this;
const callbackIndex = this.removeFromQueue(current, callback);
if (callbackIndex === -1) {
this.removeFromQueue(deferred, callback);
}
if (current.length === 0 && deferred.length === 0) {
this.clearTimeout();
}
}
addToQueue(target, invokeAt, callback) {
let insertAtIndex = target.length;
for (let i = 0; i < target.length; i += 2) {
const invokeQueuedCallbackAt = target[i];
if (invokeQueuedCallbackAt > invokeAt) {
insertAtIndex = i;
break;
}
}
arrayInsert2(target, insertAtIndex, invokeAt, callback);
}
removeFromQueue(target, callback) {
let index2 = -1;
for (let i = 0; i < target.length; i += 2) {
const queuedCallback = target[i + 1];
if (queuedCallback === callback) {
index2 = i;
break;
}
}
if (index2 > -1) {
arraySplice(target, index2, 2);
}
return index2;
}
scheduleTimer() {
const callback = () => {
this.clearTimeout();
this.executingCallbacks = true;
const current = [...this.current];
const now = Date.now();
for (let i = 0; i < current.length; i += 2) {
const invokeAt = current[i];
const callback2 = current[i + 1];
if (invokeAt <= now) {
callback2();
} else {
break;
}
}
let lastCallbackIndex = -1;
for (let i = 0; i < this.current.length; i += 2) {
const invokeAt = this.current[i];
if (invokeAt <= now) {
lastCallbackIndex = i + 1;
} else {
break;
}
}
if (lastCallbackIndex >= 0) {
arraySplice(this.current, 0, lastCallbackIndex + 1);
}
this.executingCallbacks = false;
if (this.deferred.length > 0) {
for (let i = 0; i < this.deferred.length; i += 2) {
const invokeAt = this.deferred[i];
const callback2 = this.deferred[i + 1];
this.addToQueue(this.current, invokeAt, callback2);
}
this.deferred.length = 0;
}
this.scheduleTimer();
};
const FRAME_DURATION_MS = 16;
if (this.current.length > 0) {
const now = Date.now();
const invokeAt = this.current[0];
if (this.timeoutId === null || // Reschedule a timer in case a queue contains an item with
// an earlier timestamp and the delta is more than an average
// frame duration.
this.invokeTimerAt && this.invokeTimerAt - invokeAt > FRAME_DURATION_MS) {
this.clearTimeout();
const timeout = Math.max(invokeAt - now, FRAME_DURATION_MS);
this.invokeTimerAt = invokeAt;
this.timeoutId = setTimeout(callback, timeout);
}
}
}
clearTimeout() {
if (this.timeoutId !== null) {
clearTimeout(this.timeoutId);
this.timeoutId = null;
}
}
ngOnDestroy() {
this.clearTimeout();
this.current.length = 0;
this.deferred.length = 0;
}
};
_TimerScheduler.\u0275prov = \u0275\u0275defineInjectable({
token: _TimerScheduler,
providedIn: "root",
factory: () => new _TimerScheduler()
});
var TimerScheduler = _TimerScheduler;
var DEFER_BLOCK_DEPENDENCY_INTERCEPTOR = new InjectionToken("DEFER_BLOCK_DEPENDENCY_INTERCEPTOR");
var DEFER_BLOCK_CONFIG = new InjectionToken(ngDevMode ? "DEFER_BLOCK_CONFIG" : "");
function shouldTriggerDeferBlock(injector) {
const config2 = injector.get(DEFER_BLOCK_CONFIG, null, { optional: true });
if (config2?.behavior === DeferBlockBehavior.Manual) {
return false;
}
return isPlatformBrowser(injector);
}
var applyDeferBlockStateWithSchedulingImpl = null;
function \u0275\u0275deferEnableTimerScheduling(tView, tDetails, placeholderConfigIndex, loadingConfigIndex) {
const tViewConsts = tView.consts;
if (placeholderConfigIndex != null) {
tDetails.placeholderBlockConfig = getConstant(tViewConsts, placeholderConfigIndex);
}
if (loadingConfigIndex != null) {
tDetails.loadingBlockConfig = getConstant(tViewConsts, loadingConfigIndex);
}
if (applyDeferBlockStateWithSchedulingImpl === null) {
applyDeferBlockStateWithSchedulingImpl = applyDeferBlockStateWithScheduling;
}
}
function \u0275\u0275defer(index2, primaryTmplIndex, dependencyResolverFn, loadingTmplIndex, placeholderTmplIndex, errorTmplIndex, loadingConfigIndex, placeholderConfigIndex, enableTimerScheduling) {
const lView = getLView();
const tView = getTView();
const adjustedIndex = index2 + HEADER_OFFSET;
\u0275\u0275template(index2, null, 0, 0);
if (tView.firstCreatePass) {
performanceMarkFeature("NgDefer");
const tDetails = {
primaryTmplIndex,
loadingTmplIndex: loadingTmplIndex ?? null,
placeholderTmplIndex: placeholderTmplIndex ?? null,
errorTmplIndex: errorTmplIndex ?? null,
placeholderBlockConfig: null,
loadingBlockConfig: null,
dependencyResolverFn: dependencyResolverFn ?? null,
loadingState: DeferDependenciesLoadingState.NOT_STARTED,
loadingPromise: null,
providers: null
};
enableTimerScheduling?.(tView, tDetails, placeholderConfigIndex, loadingConfigIndex);
setTDeferBlockDetails(tView, adjustedIndex, tDetails);
}
const tNode = getCurrentTNode();
const lContainer = lView[adjustedIndex];
populateDehydratedViewsInLContainer(lContainer, tNode, lView);
const lDetails = [
null,
// NEXT_DEFER_BLOCK_STATE
DeferBlockInternalState.Initial,
// DEFER_BLOCK_STATE
null,
// STATE_IS_FROZEN_UNTIL
null,
// LOADING_AFTER_CLEANUP_FN
null,
// TRIGGER_CLEANUP_FNS
null
// PREFETCH_TRIGGER_CLEANUP_FNS
];
setLDeferBlockDetails(lView, adjustedIndex, lDetails);
const cleanupTriggersFn = () => invokeAllTriggerCleanupFns(lDetails);
storeTriggerCleanupFn(0, lDetails, () => removeLViewOnDestroy(lView, cleanupTriggersFn));
storeLViewOnDestroy(lView, cleanupTriggersFn);
}
function \u0275\u0275deferWhen(rawValue) {
const lView = getLView();
const bindingIndex = nextBindingIndex();
if (bindingUpdated(lView, bindingIndex, rawValue)) {
const prevConsumer = setActiveConsumer(null);
try {
const value2 = Boolean(rawValue);
const tNode = getSelectedTNode();
const lDetails = getLDeferBlockDetails(lView, tNode);
const renderedState = lDetails[DEFER_BLOCK_STATE];
if (value2 === false && renderedState === DeferBlockInternalState.Initial) {
renderPlaceholder(lView, tNode);
} else if (value2 === true && (renderedState === DeferBlockInternalState.Initial || renderedState === DeferBlockState.Placeholder)) {
triggerDeferBlock(lView, tNode);
}
} finally {
setActiveConsumer(prevConsumer);
}
}
}
function \u0275\u0275deferPrefetchWhen(rawValue) {
const lView = getLView();
const bindingIndex = nextBindingIndex();
if (bindingUpdated(lView, bindingIndex, rawValue)) {
const prevConsumer = setActiveConsumer(null);
try {
const value2 = Boolean(rawValue);
const tView = lView[TVIEW];
const tNode = getSelectedTNode();
const tDetails = getTDeferBlockDetails(tView, tNode);
if (value2 === true && tDetails.loadingState === DeferDependenciesLoadingState.NOT_STARTED) {
triggerPrefetching(tDetails, lView, tNode);
}
} finally {
setActiveConsumer(prevConsumer);
}
}
}
function \u0275\u0275deferOnIdle() {
scheduleDelayedTrigger(onIdle);
}
function \u0275\u0275deferPrefetchOnIdle() {
scheduleDelayedPrefetching(onIdle);
}
function \u0275\u0275deferOnImmediate() {
const lView = getLView();
const tNode = getCurrentTNode();
const tView = lView[TVIEW];
const injector = lView[INJECTOR];
const tDetails = getTDeferBlockDetails(tView, tNode);
if (!shouldTriggerDeferBlock(injector) || tDetails.loadingTmplIndex === null) {
renderPlaceholder(lView, tNode);
}
triggerDeferBlock(lView, tNode);
}
function \u0275\u0275deferPrefetchOnImmediate() {
const lView = getLView();
const tNode = getCurrentTNode();
const tView = lView[TVIEW];
const tDetails = getTDeferBlockDetails(tView, tNode);
if (tDetails.loadingState === DeferDependenciesLoadingState.NOT_STARTED) {
triggerResourceLoading(tDetails, lView, tNode);
}
}
function \u0275\u0275deferOnTimer(delay) {
scheduleDelayedTrigger(onTimer(delay));
}
function \u0275\u0275deferPrefetchOnTimer(delay) {
scheduleDelayedPrefetching(onTimer(delay));
}
function \u0275\u0275deferOnHover(triggerIndex, walkUpTimes) {
const lView = getLView();
const tNode = getCurrentTNode();
renderPlaceholder(lView, tNode);
registerDomTrigger(
lView,
tNode,
triggerIndex,
walkUpTimes,
onHover,
() => triggerDeferBlock(lView, tNode),
0
/* TriggerType.Regular */
);
}
function \u0275\u0275deferPrefetchOnHover(triggerIndex, walkUpTimes) {
const lView = getLView();
const tNode = getCurrentTNode();
const tView = lView[TVIEW];
const tDetails = getTDeferBlockDetails(tView, tNode);
if (tDetails.loadingState === DeferDependenciesLoadingState.NOT_STARTED) {
registerDomTrigger(
lView,
tNode,
triggerIndex,
walkUpTimes,
onHover,
() => triggerPrefetching(tDetails, lView, tNode),
1
/* TriggerType.Prefetch */
);
}
}
function \u0275\u0275deferOnInteraction(triggerIndex, walkUpTimes) {
const lView = getLView();
const tNode = getCurrentTNode();
renderPlaceholder(lView, tNode);
registerDomTrigger(
lView,
tNode,
triggerIndex,
walkUpTimes,
onInteraction,
() => triggerDeferBlock(lView, tNode),
0
/* TriggerType.Regular */
);
}
function \u0275\u0275deferPrefetchOnInteraction(triggerIndex, walkUpTimes) {
const lView = getLView();
const tNode = getCurrentTNode();
const tView = lView[TVIEW];
const tDetails = getTDeferBlockDetails(tView, tNode);
if (tDetails.loadingState === DeferDependenciesLoadingState.NOT_STARTED) {
registerDomTrigger(
lView,
tNode,
triggerIndex,
walkUpTimes,
onInteraction,
() => triggerPrefetching(tDetails, lView, tNode),
1
/* TriggerType.Prefetch */
);
}
}
function \u0275\u0275deferOnViewport(triggerIndex, walkUpTimes) {
const lView = getLView();
const tNode = getCurrentTNode();
renderPlaceholder(lView, tNode);
registerDomTrigger(
lView,
tNode,
triggerIndex,
walkUpTimes,
onViewport,
() => triggerDeferBlock(lView, tNode),
0
/* TriggerType.Regular */
);
}
function \u0275\u0275deferPrefetchOnViewport(triggerIndex, walkUpTimes) {
const lView = getLView();
const tNode = getCurrentTNode();
const tView = lView[TVIEW];
const tDetails = getTDeferBlockDetails(tView, tNode);
if (tDetails.loadingState === DeferDependenciesLoadingState.NOT_STARTED) {
registerDomTrigger(
lView,
tNode,
triggerIndex,
walkUpTimes,
onViewport,
() => triggerPrefetching(tDetails, lView, tNode),
1
/* TriggerType.Prefetch */
);
}
}
function scheduleDelayedTrigger(scheduleFn) {
const lView = getLView();
const tNode = getCurrentTNode();
renderPlaceholder(lView, tNode);
if (isPlatformBrowser(lView[INJECTOR])) {
const cleanupFn = scheduleFn(() => triggerDeferBlock(lView, tNode), lView);
const lDetails = getLDeferBlockDetails(lView, tNode);
storeTriggerCleanupFn(0, lDetails, cleanupFn);
}
}
function scheduleDelayedPrefetching(scheduleFn) {
const lView = getLView();
if (isPlatformBrowser(lView[INJECTOR])) {
const tNode = getCurrentTNode();
const tView = lView[TVIEW];
const tDetails = getTDeferBlockDetails(tView, tNode);
if (tDetails.loadingState === DeferDependenciesLoadingState.NOT_STARTED) {
const lDetails = getLDeferBlockDetails(lView, tNode);
const prefetch = () => triggerPrefetching(tDetails, lView, tNode);
const cleanupFn = scheduleFn(prefetch, lView);
storeTriggerCleanupFn(1, lDetails, cleanupFn);
}
}
}
function renderDeferBlockState(newState, tNode, lContainer, skipTimerScheduling = false) {
const hostLView = lContainer[PARENT];
const hostTView = hostLView[TVIEW];
if (isDestroyed(hostLView))
return;
ngDevMode && assertTNodeForLView(tNode, hostLView);
const lDetails = getLDeferBlockDetails(hostLView, tNode);
ngDevMode && assertDefined(lDetails, "Expected a defer block state defined");
const currentState = lDetails[DEFER_BLOCK_STATE];
if (isValidStateChange(currentState, newState) && isValidStateChange(lDetails[NEXT_DEFER_BLOCK_STATE] ?? -1, newState)) {
const injector = hostLView[INJECTOR];
const tDetails = getTDeferBlockDetails(hostTView, tNode);
const needsScheduling = !skipTimerScheduling && isPlatformBrowser(injector) && (getLoadingBlockAfter(tDetails) !== null || getMinimumDurationForState(tDetails, DeferBlockState.Loading) !== null || getMinimumDurationForState(tDetails, DeferBlockState.Placeholder));
if (ngDevMode && needsScheduling) {
assertDefined(applyDeferBlockStateWithSchedulingImpl, "Expected scheduling function to be defined");
}
const applyStateFn = needsScheduling ? applyDeferBlockStateWithSchedulingImpl : applyDeferBlockState;
try {
applyStateFn(newState, lDetails, lContainer, tNode, hostLView);
} catch (error) {
handleError(hostLView, error);
}
}
}
function isRouterOutletInjector(currentInjector) {
return currentInjector instanceof ChainedInjector && typeof currentInjector.injector.__ngOutletInjector === "function";
}
function createRouterOutletInjector(parentOutletInjector, parentInjector) {
const outletInjector = parentOutletInjector.injector;
return outletInjector.__ngOutletInjector(parentInjector);
}
function applyDeferBlockState(newState, lDetails, lContainer, tNode, hostLView) {
const stateTmplIndex = getTemplateIndexForState(newState, hostLView, tNode);
if (stateTmplIndex !== null) {
lDetails[DEFER_BLOCK_STATE] = newState;
const hostTView = hostLView[TVIEW];
const adjustedIndex = stateTmplIndex + HEADER_OFFSET;
const activeBlockTNode = getTNode(hostTView, adjustedIndex);
const viewIndex = 0;
removeLViewFromLContainer(lContainer, viewIndex);
let injector;
if (newState === DeferBlockState.Complete) {
const tDetails = getTDeferBlockDetails(hostTView, tNode);
const providers = tDetails.providers;
if (providers && providers.length > 0) {
const parentInjector = hostLView[INJECTOR];
const isParentOutletInjector = isRouterOutletInjector(parentInjector);
const parentEnvInjector = isParentOutletInjector ? parentInjector : parentInjector.get(EnvironmentInjector);
injector = parentEnvInjector.get(CachedInjectorService).getOrCreateInjector(tDetails, parentEnvInjector, providers, ngDevMode ? "DeferBlock Injector" : "");
if (isParentOutletInjector) {
injector = createRouterOutletInjector(parentInjector, injector);
}
}
}
const dehydratedView = findMatchingDehydratedView(lContainer, activeBlockTNode.tView.ssrId);
const embeddedLView = createAndRenderEmbeddedLView(hostLView, activeBlockTNode, null, { dehydratedView, injector });
addLViewToLContainer(lContainer, embeddedLView, viewIndex, shouldAddViewToDom(activeBlockTNode, dehydratedView));
markViewDirty(embeddedLView);
}
}
function applyDeferBlockStateWithScheduling(newState, lDetails, lContainer, tNode, hostLView) {
const now = Date.now();
const hostTView = hostLView[TVIEW];
const tDetails = getTDeferBlockDetails(hostTView, tNode);
if (lDetails[STATE_IS_FROZEN_UNTIL] === null || lDetails[STATE_IS_FROZEN_UNTIL] <= now) {
lDetails[STATE_IS_FROZEN_UNTIL] = null;
const loadingAfter = getLoadingBlockAfter(tDetails);
const inLoadingAfterPhase = lDetails[LOADING_AFTER_CLEANUP_FN] !== null;
if (newState === DeferBlockState.Loading && loadingAfter !== null && !inLoadingAfterPhase) {
lDetails[NEXT_DEFER_BLOCK_STATE] = newState;
const cleanupFn = scheduleDeferBlockUpdate(loadingAfter, lDetails, tNode, lContainer, hostLView);
lDetails[LOADING_AFTER_CLEANUP_FN] = cleanupFn;
} else {
if (newState > DeferBlockState.Loading && inLoadingAfterPhase) {
lDetails[LOADING_AFTER_CLEANUP_FN]();
lDetails[LOADING_AFTER_CLEANUP_FN] = null;
lDetails[NEXT_DEFER_BLOCK_STATE] = null;
}
applyDeferBlockState(newState, lDetails, lContainer, tNode, hostLView);
const duration = getMinimumDurationForState(tDetails, newState);
if (duration !== null) {
lDetails[STATE_IS_FROZEN_UNTIL] = now + duration;
scheduleDeferBlockUpdate(duration, lDetails, tNode, lContainer, hostLView);
}
}
} else {
lDetails[NEXT_DEFER_BLOCK_STATE] = newState;
}
}
function scheduleDeferBlockUpdate(timeout, lDetails, tNode, lContainer, hostLView) {
const callback = () => {
const nextState = lDetails[NEXT_DEFER_BLOCK_STATE];
lDetails[STATE_IS_FROZEN_UNTIL] = null;
lDetails[NEXT_DEFER_BLOCK_STATE] = null;
if (nextState !== null) {
renderDeferBlockState(nextState, tNode, lContainer);
}
};
return scheduleTimerTrigger(timeout, callback, hostLView);
}
function isValidStateChange(currentState, newState) {
return currentState < newState;
}
function triggerPrefetching(tDetails, lView, tNode) {
if (lView[INJECTOR] && shouldTriggerDeferBlock(lView[INJECTOR])) {
triggerResourceLoading(tDetails, lView, tNode);
}
}
function triggerResourceLoading(tDetails, lView, tNode) {
const injector = lView[INJECTOR];
const tView = lView[TVIEW];
if (tDetails.loadingState !== DeferDependenciesLoadingState.NOT_STARTED) {
return tDetails.loadingPromise ?? Promise.resolve();
}
const lDetails = getLDeferBlockDetails(lView, tNode);
const primaryBlockTNode = getPrimaryBlockTNode(tView, tDetails);
tDetails.loadingState = DeferDependenciesLoadingState.IN_PROGRESS;
invokeTriggerCleanupFns(1, lDetails);
let dependenciesFn = tDetails.dependencyResolverFn;
if (ngDevMode) {
const deferDependencyInterceptor = injector.get(DEFER_BLOCK_DEPENDENCY_INTERCEPTOR, null, { optional: true });
if (deferDependencyInterceptor) {
dependenciesFn = deferDependencyInterceptor.intercept(dependenciesFn);
}
}
const pendingTasks = injector.get(PendingTasks);
const taskId = pendingTasks.add();
if (!dependenciesFn) {
tDetails.loadingPromise = Promise.resolve().then(() => {
tDetails.loadingPromise = null;
tDetails.loadingState = DeferDependenciesLoadingState.COMPLETE;
pendingTasks.remove(taskId);
});
return tDetails.loadingPromise;
}
tDetails.loadingPromise = Promise.allSettled(dependenciesFn()).then((results) => {
let failed = false;
const directiveDefs = [];
const pipeDefs = [];
for (const result of results) {
if (result.status === "fulfilled") {
const dependency = result.value;
const directiveDef = getComponentDef(dependency) || getDirectiveDef(dependency);
if (directiveDef) {
directiveDefs.push(directiveDef);
} else {
const pipeDef = getPipeDef$1(dependency);
if (pipeDef) {
pipeDefs.push(pipeDef);
}
}
} else {
failed = true;
break;
}
}
tDetails.loadingPromise = null;
pendingTasks.remove(taskId);
if (failed) {
tDetails.loadingState = DeferDependenciesLoadingState.FAILED;
if (tDetails.errorTmplIndex === null) {
const templateLocation = getTemplateLocationDetails(lView);
const error = new RuntimeError(750, ngDevMode && `Loading dependencies for \`@defer\` block failed, but no \`@error\` block was configured${templateLocation}. Consider using the \`@error\` block to render an error state.`);
handleError(lView, error);
}
} else {
tDetails.loadingState = DeferDependenciesLoadingState.COMPLETE;
const primaryBlockTView = primaryBlockTNode.tView;
if (directiveDefs.length > 0) {
primaryBlockTView.directiveRegistry = addDepsToRegistry(primaryBlockTView.directiveRegistry, directiveDefs);
const directiveTypes = directiveDefs.map((def) => def.type);
const providers = internalImportProvidersFrom(false, ...directiveTypes);
tDetails.providers = providers;
}
if (pipeDefs.length > 0) {
primaryBlockTView.pipeRegistry = addDepsToRegistry(primaryBlockTView.pipeRegistry, pipeDefs);
}
}
});
return tDetails.loadingPromise;
}
function renderPlaceholder(lView, tNode) {
const lContainer = lView[tNode.index];
ngDevMode && assertLContainer(lContainer);
renderDeferBlockState(DeferBlockState.Placeholder, tNode, lContainer);
}
function renderDeferStateAfterResourceLoading(tDetails, tNode, lContainer) {
ngDevMode && assertDefined(tDetails.loadingPromise, "Expected loading Promise to exist on this defer block");
tDetails.loadingPromise.then(() => {
if (tDetails.loadingState === DeferDependenciesLoadingState.COMPLETE) {
ngDevMode && assertDeferredDependenciesLoaded(tDetails);
renderDeferBlockState(DeferBlockState.Complete, tNode, lContainer);
} else if (tDetails.loadingState === DeferDependenciesLoadingState.FAILED) {
renderDeferBlockState(DeferBlockState.Error, tNode, lContainer);
}
});
}
function triggerDeferBlock(lView, tNode) {
const tView = lView[TVIEW];
const lContainer = lView[tNode.index];
const injector = lView[INJECTOR];
ngDevMode && assertLContainer(lContainer);
if (!shouldTriggerDeferBlock(injector))
return;
const lDetails = getLDeferBlockDetails(lView, tNode);
const tDetails = getTDeferBlockDetails(tView, tNode);
invokeAllTriggerCleanupFns(lDetails);
switch (tDetails.loadingState) {
case DeferDependenciesLoadingState.NOT_STARTED:
renderDeferBlockState(DeferBlockState.Loading, tNode, lContainer);
triggerResourceLoading(tDetails, lView, tNode);
if (tDetails.loadingState === DeferDependenciesLoadingState.IN_PROGRESS) {
renderDeferStateAfterResourceLoading(tDetails, tNode, lContainer);
}
break;
case DeferDependenciesLoadingState.IN_PROGRESS:
renderDeferBlockState(DeferBlockState.Loading, tNode, lContainer);
renderDeferStateAfterResourceLoading(tDetails, tNode, lContainer);
break;
case DeferDependenciesLoadingState.COMPLETE:
ngDevMode && assertDeferredDependenciesLoaded(tDetails);
renderDeferBlockState(DeferBlockState.Complete, tNode, lContainer);
break;
case DeferDependenciesLoadingState.FAILED:
renderDeferBlockState(DeferBlockState.Error, tNode, lContainer);
break;
default:
if (ngDevMode) {
throwError2("Unknown defer block state");
}
}
}
function \u0275\u0275attribute(name2, value2, sanitizer, namespace) {
const lView = getLView();
const bindingIndex = nextBindingIndex();
if (bindingUpdated(lView, bindingIndex, value2)) {
const tView = getTView();
const tNode = getSelectedTNode();
elementAttributeInternal(tNode, lView, name2, value2, sanitizer, namespace);
ngDevMode && storePropertyBindingMetadata(tView.data, tNode, "attr." + name2, bindingIndex);
}
return \u0275\u0275attribute;
}
function interpolationV(lView, values) {
ngDevMode && assertLessThan(2, values.length, "should have at least 3 values");
ngDevMode && assertEqual(values.length % 2, 1, "should have an odd number of values");
let isBindingUpdated = false;
let bindingIndex = getBindingIndex();
for (let i = 1; i < values.length; i += 2) {
isBindingUpdated = bindingUpdated(lView, bindingIndex++, values[i]) || isBindingUpdated;
}
setBindingIndex(bindingIndex);
if (!isBindingUpdated) {
return NO_CHANGE;
}
let content2 = values[0];
for (let i = 1; i < values.length; i += 2) {
content2 += renderStringify(values[i]) + values[i + 1];
}
return content2;
}
function interpolation1(lView, prefix, v0, suffix) {
const different = bindingUpdated(lView, nextBindingIndex(), v0);
return different ? prefix + renderStringify(v0) + suffix : NO_CHANGE;
}
function interpolation2(lView, prefix, v0, i0, v1, suffix) {
const bindingIndex = getBindingIndex();
const different = bindingUpdated2(lView, bindingIndex, v0, v1);
incrementBindingIndex(2);
return different ? prefix + renderStringify(v0) + i0 + renderStringify(v1) + suffix : NO_CHANGE;
}
function interpolation3(lView, prefix, v0, i0, v1, i1, v2, suffix) {
const bindingIndex = getBindingIndex();
const different = bindingUpdated3(lView, bindingIndex, v0, v1, v2);
incrementBindingIndex(3);
return different ? prefix + renderStringify(v0) + i0 + renderStringify(v1) + i1 + renderStringify(v2) + suffix : NO_CHANGE;
}
function interpolation4(lView, prefix, v0, i0, v1, i1, v2, i2, v3, suffix) {
const bindingIndex = getBindingIndex();
const different = bindingUpdated4(lView, bindingIndex, v0, v1, v2, v3);
incrementBindingIndex(4);
return different ? prefix + renderStringify(v0) + i0 + renderStringify(v1) + i1 + renderStringify(v2) + i2 + renderStringify(v3) + suffix : NO_CHANGE;
}
function interpolation5(lView, prefix, v0, i0, v1, i1, v2, i2, v3, i3, v42, suffix) {
const bindingIndex = getBindingIndex();
let different = bindingUpdated4(lView, bindingIndex, v0, v1, v2, v3);
different = bindingUpdated(lView, bindingIndex + 4, v42) || different;
incrementBindingIndex(5);
return different ? prefix + renderStringify(v0) + i0 + renderStringify(v1) + i1 + renderStringify(v2) + i2 + renderStringify(v3) + i3 + renderStringify(v42) + suffix : NO_CHANGE;
}
function interpolation6(lView, prefix, v0, i0, v1, i1, v2, i2, v3, i3, v42, i4, v5, suffix) {
const bindingIndex = getBindingIndex();
let different = bindingUpdated4(lView, bindingIndex, v0, v1, v2, v3);
different = bindingUpdated2(lView, bindingIndex + 4, v42, v5) || different;
incrementBindingIndex(6);
return different ? prefix + renderStringify(v0) + i0 + renderStringify(v1) + i1 + renderStringify(v2) + i2 + renderStringify(v3) + i3 + renderStringify(v42) + i4 + renderStringify(v5) + suffix : NO_CHANGE;
}
function interpolation7(lView, prefix, v0, i0, v1, i1, v2, i2, v3, i3, v42, i4, v5, i5, v6, suffix) {
const bindingIndex = getBindingIndex();
let different = bindingUpdated4(lView, bindingIndex, v0, v1, v2, v3);
different = bindingUpdated3(lView, bindingIndex + 4, v42, v5, v6) || different;
incrementBindingIndex(7);
return different ? prefix + renderStringify(v0) + i0 + renderStringify(v1) + i1 + renderStringify(v2) + i2 + renderStringify(v3) + i3 + renderStringify(v42) + i4 + renderStringify(v5) + i5 + renderStringify(v6) + suffix : NO_CHANGE;
}
function interpolation8(lView, prefix, v0, i0, v1, i1, v2, i2, v3, i3, v42, i4, v5, i5, v6, i6, v7, suffix) {
const bindingIndex = getBindingIndex();
let different = bindingUpdated4(lView, bindingIndex, v0, v1, v2, v3);
different = bindingUpdated4(lView, bindingIndex + 4, v42, v5, v6, v7) || different;
incrementBindingIndex(8);
return different ? prefix + renderStringify(v0) + i0 + renderStringify(v1) + i1 + renderStringify(v2) + i2 + renderStringify(v3) + i3 + renderStringify(v42) + i4 + renderStringify(v5) + i5 + renderStringify(v6) + i6 + renderStringify(v7) + suffix : NO_CHANGE;
}
function \u0275\u0275attributeInterpolate1(attrName, prefix, v0, suffix, sanitizer, namespace) {
const lView = getLView();
const interpolatedValue = interpolation1(lView, prefix, v0, suffix);
if (interpolatedValue !== NO_CHANGE) {
const tNode = getSelectedTNode();
elementAttributeInternal(tNode, lView, attrName, interpolatedValue, sanitizer, namespace);
ngDevMode && storePropertyBindingMetadata(getTView().data, tNode, "attr." + attrName, getBindingIndex() - 1, prefix, suffix);
}
return \u0275\u0275attributeInterpolate1;
}
function \u0275\u0275attributeInterpolate2(attrName, prefix, v0, i0, v1, suffix, sanitizer, namespace) {
const lView = getLView();
const interpolatedValue = interpolation2(lView, prefix, v0, i0, v1, suffix);
if (interpolatedValue !== NO_CHANGE) {
const tNode = getSelectedTNode();
elementAttributeInternal(tNode, lView, attrName, interpolatedValue, sanitizer, namespace);
ngDevMode && storePropertyBindingMetadata(getTView().data, tNode, "attr." + attrName, getBindingIndex() - 2, prefix, i0, suffix);
}
return \u0275\u0275attributeInterpolate2;
}
function \u0275\u0275attributeInterpolate3(attrName, prefix, v0, i0, v1, i1, v2, suffix, sanitizer, namespace) {
const lView = getLView();
const interpolatedValue = interpolation3(lView, prefix, v0, i0, v1, i1, v2, suffix);
if (interpolatedValue !== NO_CHANGE) {
const tNode = getSelectedTNode();
elementAttributeInternal(tNode, lView, attrName, interpolatedValue, sanitizer, namespace);
ngDevMode && storePropertyBindingMetadata(getTView().data, tNode, "attr." + attrName, getBindingIndex() - 3, prefix, i0, i1, suffix);
}
return \u0275\u0275attributeInterpolate3;
}
function \u0275\u0275attributeInterpolate4(attrName, prefix, v0, i0, v1, i1, v2, i2, v3, suffix, sanitizer, namespace) {
const lView = getLView();
const interpolatedValue = interpolation4(lView, prefix, v0, i0, v1, i1, v2, i2, v3, suffix);
if (interpolatedValue !== NO_CHANGE) {
const tNode = getSelectedTNode();
elementAttributeInternal(tNode, lView, attrName, interpolatedValue, sanitizer, namespace);
ngDevMode && storePropertyBindingMetadata(getTView().data, tNode, "attr." + attrName, getBindingIndex() - 4, prefix, i0, i1, i2, suffix);
}
return \u0275\u0275attributeInterpolate4;
}
function \u0275\u0275attributeInterpolate5(attrName, prefix, v0, i0, v1, i1, v2, i2, v3, i3, v42, suffix, sanitizer, namespace) {
const lView = getLView();
const interpolatedValue = interpolation5(lView, prefix, v0, i0, v1, i1, v2, i2, v3, i3, v42, suffix);
if (interpolatedValue !== NO_CHANGE) {
const tNode = getSelectedTNode();
elementAttributeInternal(tNode, lView, attrName, interpolatedValue, sanitizer, namespace);
ngDevMode && storePropertyBindingMetadata(getTView().data, tNode, "attr." + attrName, getBindingIndex() - 5, prefix, i0, i1, i2, i3, suffix);
}
return \u0275\u0275attributeInterpolate5;
}
function \u0275\u0275attributeInterpolate6(attrName, prefix, v0, i0, v1, i1, v2, i2, v3, i3, v42, i4, v5, suffix, sanitizer, namespace) {
const lView = getLView();
const interpolatedValue = interpolation6(lView, prefix, v0, i0, v1, i1, v2, i2, v3, i3, v42, i4, v5, suffix);
if (interpolatedValue !== NO_CHANGE) {
const tNode = getSelectedTNode();
elementAttributeInternal(tNode, lView, attrName, interpolatedValue, sanitizer, namespace);
ngDevMode && storePropertyBindingMetadata(getTView().data, tNode, "attr." + attrName, getBindingIndex() - 6, prefix, i0, i1, i2, i3, i4, suffix);
}
return \u0275\u0275attributeInterpolate6;
}
function \u0275\u0275attributeInterpolate7(attrName, prefix, v0, i0, v1, i1, v2, i2, v3, i3, v42, i4, v5, i5, v6, suffix, sanitizer, namespace) {
const lView = getLView();
const interpolatedValue = interpolation7(lView, prefix, v0, i0, v1, i1, v2, i2, v3, i3, v42, i4, v5, i5, v6, suffix);
if (interpolatedValue !== NO_CHANGE) {
const tNode = getSelectedTNode();
elementAttributeInternal(tNode, lView, attrName, interpolatedValue, sanitizer, namespace);
ngDevMode && storePropertyBindingMetadata(getTView().data, tNode, "attr." + attrName, getBindingIndex() - 7, prefix, i0, i1, i2, i3, i4, i5, suffix);
}
return \u0275\u0275attributeInterpolate7;
}
function \u0275\u0275attributeInterpolate8(attrName, prefix, v0, i0, v1, i1, v2, i2, v3, i3, v42, i4, v5, i5, v6, i6, v7, suffix, sanitizer, namespace) {
const lView = getLView();
const interpolatedValue = interpolation8(lView, prefix, v0, i0, v1, i1, v2, i2, v3, i3, v42, i4, v5, i5, v6, i6, v7, suffix);
if (interpolatedValue !== NO_CHANGE) {
const tNode = getSelectedTNode();
elementAttributeInternal(tNode, lView, attrName, interpolatedValue, sanitizer, namespace);
ngDevMode && storePropertyBindingMetadata(getTView().data, tNode, "attr." + attrName, getBindingIndex() - 8, prefix, i0, i1, i2, i3, i4, i5, i6, suffix);
}
return \u0275\u0275attributeInterpolate8;
}
function \u0275\u0275attributeInterpolateV(attrName, values, sanitizer, namespace) {
const lView = getLView();
const interpolated = interpolationV(lView, values);
if (interpolated !== NO_CHANGE) {
const tNode = getSelectedTNode();
elementAttributeInternal(tNode, lView, attrName, interpolated, sanitizer, namespace);
if (ngDevMode) {
const interpolationInBetween = [values[0]];
for (let i = 2; i < values.length; i += 2) {
interpolationInBetween.push(values[i]);
}
storePropertyBindingMetadata(getTView().data, tNode, "attr." + attrName, getBindingIndex() - interpolationInBetween.length + 1, ...interpolationInBetween);
}
}
return \u0275\u0275attributeInterpolateV;
}
function toTStylingRange(prev, next) {
ngDevMode && assertNumberInRange(
prev,
0,
32767
/* StylingRange.UNSIGNED_MASK */
);
ngDevMode && assertNumberInRange(
next,
0,
32767
/* StylingRange.UNSIGNED_MASK */
);
return prev << 17 | next << 2;
}
function getTStylingRangePrev(tStylingRange) {
ngDevMode && assertNumber(tStylingRange, "expected number");
return tStylingRange >> 17 & 32767;
}
function getTStylingRangePrevDuplicate(tStylingRange) {
ngDevMode && assertNumber(tStylingRange, "expected number");
return (tStylingRange & 2) == 2;
}
function setTStylingRangePrev(tStylingRange, previous) {
ngDevMode && assertNumber(tStylingRange, "expected number");
ngDevMode && assertNumberInRange(
previous,
0,
32767
/* StylingRange.UNSIGNED_MASK */
);
return tStylingRange & ~4294836224 | previous << 17;
}
function setTStylingRangePrevDuplicate(tStylingRange) {
ngDevMode && assertNumber(tStylingRange, "expected number");
return tStylingRange | 2;
}
function getTStylingRangeNext(tStylingRange) {
ngDevMode && assertNumber(tStylingRange, "expected number");
return (tStylingRange & 131068) >> 2;
}
function setTStylingRangeNext(tStylingRange, next) {
ngDevMode && assertNumber(tStylingRange, "expected number");
ngDevMode && assertNumberInRange(
next,
0,
32767
/* StylingRange.UNSIGNED_MASK */
);
return tStylingRange & ~131068 | //
next << 2;
}
function getTStylingRangeNextDuplicate(tStylingRange) {
ngDevMode && assertNumber(tStylingRange, "expected number");
return (tStylingRange & 1) === 1;
}
function setTStylingRangeNextDuplicate(tStylingRange) {
ngDevMode && assertNumber(tStylingRange, "expected number");
return tStylingRange | 1;
}
function insertTStylingBinding(tData, tNode, tStylingKeyWithStatic, index2, isHostBinding, isClassBinding) {
ngDevMode && assertFirstUpdatePass(getTView());
let tBindings = isClassBinding ? tNode.classBindings : tNode.styleBindings;
let tmplHead = getTStylingRangePrev(tBindings);
let tmplTail = getTStylingRangeNext(tBindings);
tData[index2] = tStylingKeyWithStatic;
let isKeyDuplicateOfStatic = false;
let tStylingKey;
if (Array.isArray(tStylingKeyWithStatic)) {
const staticKeyValueArray = tStylingKeyWithStatic;
tStylingKey = staticKeyValueArray[1];
if (tStylingKey === null || keyValueArrayIndexOf(staticKeyValueArray, tStylingKey) > 0) {
isKeyDuplicateOfStatic = true;
}
} else {
tStylingKey = tStylingKeyWithStatic;
}
if (isHostBinding) {
const hasTemplateBindings = tmplTail !== 0;
if (hasTemplateBindings) {
const previousNode = getTStylingRangePrev(tData[tmplHead + 1]);
tData[index2 + 1] = toTStylingRange(previousNode, tmplHead);
if (previousNode !== 0) {
tData[previousNode + 1] = setTStylingRangeNext(tData[previousNode + 1], index2);
}
tData[tmplHead + 1] = setTStylingRangePrev(tData[tmplHead + 1], index2);
} else {
tData[index2 + 1] = toTStylingRange(tmplHead, 0);
if (tmplHead !== 0) {
tData[tmplHead + 1] = setTStylingRangeNext(tData[tmplHead + 1], index2);
}
tmplHead = index2;
}
} else {
tData[index2 + 1] = toTStylingRange(tmplTail, 0);
ngDevMode && assertEqual(tmplHead !== 0 && tmplTail === 0, false, "Adding template bindings after hostBindings is not allowed.");
if (tmplHead === 0) {
tmplHead = index2;
} else {
tData[tmplTail + 1] = setTStylingRangeNext(tData[tmplTail + 1], index2);
}
tmplTail = index2;
}
if (isKeyDuplicateOfStatic) {
tData[index2 + 1] = setTStylingRangePrevDuplicate(tData[index2 + 1]);
}
markDuplicates(tData, tStylingKey, index2, true);
markDuplicates(tData, tStylingKey, index2, false);
markDuplicateOfResidualStyling(tNode, tStylingKey, tData, index2, isClassBinding);
tBindings = toTStylingRange(tmplHead, tmplTail);
if (isClassBinding) {
tNode.classBindings = tBindings;
} else {
tNode.styleBindings = tBindings;
}
}
function markDuplicateOfResidualStyling(tNode, tStylingKey, tData, index2, isClassBinding) {
const residual = isClassBinding ? tNode.residualClasses : tNode.residualStyles;
if (residual != null && typeof tStylingKey == "string" && keyValueArrayIndexOf(residual, tStylingKey) >= 0) {
tData[index2 + 1] = setTStylingRangeNextDuplicate(tData[index2 + 1]);
}
}
function markDuplicates(tData, tStylingKey, index2, isPrevDir) {
const tStylingAtIndex = tData[index2 + 1];
const isMap = tStylingKey === null;
let cursor = isPrevDir ? getTStylingRangePrev(tStylingAtIndex) : getTStylingRangeNext(tStylingAtIndex);
let foundDuplicate = false;
while (cursor !== 0 && (foundDuplicate === false || isMap)) {
ngDevMode && assertIndexInRange(tData, cursor);
const tStylingValueAtCursor = tData[cursor];
const tStyleRangeAtCursor = tData[cursor + 1];
if (isStylingMatch(tStylingValueAtCursor, tStylingKey)) {
foundDuplicate = true;
tData[cursor + 1] = isPrevDir ? setTStylingRangeNextDuplicate(tStyleRangeAtCursor) : setTStylingRangePrevDuplicate(tStyleRangeAtCursor);
}
cursor = isPrevDir ? getTStylingRangePrev(tStyleRangeAtCursor) : getTStylingRangeNext(tStyleRangeAtCursor);
}
if (foundDuplicate) {
tData[index2 + 1] = isPrevDir ? setTStylingRangePrevDuplicate(tStylingAtIndex) : setTStylingRangeNextDuplicate(tStylingAtIndex);
}
}
function isStylingMatch(tStylingKeyCursor, tStylingKey) {
ngDevMode && assertNotEqual(Array.isArray(tStylingKey), true, "Expected that 'tStylingKey' has been unwrapped");
if (tStylingKeyCursor === null || // If the cursor is `null` it means that we have map at that
// location so we must assume that we have a match.
tStylingKey == null || // If `tStylingKey` is `null` then it is a map therefor assume that it
// contains a match.
(Array.isArray(tStylingKeyCursor) ? tStylingKeyCursor[1] : tStylingKeyCursor) === tStylingKey) {
return true;
} else if (Array.isArray(tStylingKeyCursor) && typeof tStylingKey === "string") {
return keyValueArrayIndexOf(tStylingKeyCursor, tStylingKey) >= 0;
}
return false;
}
var parserState = {
textEnd: 0,
key: 0,
keyEnd: 0,
value: 0,
valueEnd: 0
};
function getLastParsedKey(text2) {
return text2.substring(parserState.key, parserState.keyEnd);
}
function getLastParsedValue(text2) {
return text2.substring(parserState.value, parserState.valueEnd);
}
function parseClassName(text2) {
resetParserState(text2);
return parseClassNameNext(text2, consumeWhitespace(text2, 0, parserState.textEnd));
}
function parseClassNameNext(text2, index2) {
const end = parserState.textEnd;
if (end === index2) {
return -1;
}
index2 = parserState.keyEnd = consumeClassToken(text2, parserState.key = index2, end);
return consumeWhitespace(text2, index2, end);
}
function parseStyle(text2) {
resetParserState(text2);
return parseStyleNext(text2, consumeWhitespace(text2, 0, parserState.textEnd));
}
function parseStyleNext(text2, startIndex) {
const end = parserState.textEnd;
let index2 = parserState.key = consumeWhitespace(text2, startIndex, end);
if (end === index2) {
return -1;
}
index2 = parserState.keyEnd = consumeStyleKey(text2, index2, end);
index2 = consumeSeparator(
text2,
index2,
end,
58
/* CharCode.COLON */
);
index2 = parserState.value = consumeWhitespace(text2, index2, end);
index2 = parserState.valueEnd = consumeStyleValue(text2, index2, end);
return consumeSeparator(
text2,
index2,
end,
59
/* CharCode.SEMI_COLON */
);
}
function resetParserState(text2) {
parserState.key = 0;
parserState.keyEnd = 0;
parserState.value = 0;
parserState.valueEnd = 0;
parserState.textEnd = text2.length;
}
function consumeWhitespace(text2, startIndex, endIndex) {
while (startIndex < endIndex && text2.charCodeAt(startIndex) <= 32) {
startIndex++;
}
return startIndex;
}
function consumeClassToken(text2, startIndex, endIndex) {
while (startIndex < endIndex && text2.charCodeAt(startIndex) > 32) {
startIndex++;
}
return startIndex;
}
function consumeStyleKey(text2, startIndex, endIndex) {
let ch;
while (startIndex < endIndex && ((ch = text2.charCodeAt(startIndex)) === 45 || ch === 95 || (ch & -33) >= 65 && (ch & -33) <= 90 || ch >= 48 && ch <= 57)) {
startIndex++;
}
return startIndex;
}
function consumeSeparator(text2, startIndex, endIndex, separator) {
startIndex = consumeWhitespace(text2, startIndex, endIndex);
if (startIndex < endIndex) {
if (ngDevMode && text2.charCodeAt(startIndex) !== separator) {
malformedStyleError(text2, String.fromCharCode(separator), startIndex);
}
startIndex++;
}
return startIndex;
}
function consumeStyleValue(text2, startIndex, endIndex) {
let ch1 = -1;
let ch2 = -1;
let ch3 = -1;
let i = startIndex;
let lastChIndex = i;
while (i < endIndex) {
const ch = text2.charCodeAt(i++);
if (ch === 59) {
return lastChIndex;
} else if (ch === 34 || ch === 39) {
lastChIndex = i = consumeQuotedText(text2, ch, i, endIndex);
} else if (startIndex === i - 4 && // We have seen only 4 characters so far "URL(" (Ignore "foo_URL()")
ch3 === 85 && ch2 === 82 && ch1 === 76 && ch === 40) {
lastChIndex = i = consumeQuotedText(text2, 41, i, endIndex);
} else if (ch > 32) {
lastChIndex = i;
}
ch3 = ch2;
ch2 = ch1;
ch1 = ch & -33;
}
return lastChIndex;
}
function consumeQuotedText(text2, quoteCharCode, startIndex, endIndex) {
let ch1 = -1;
let index2 = startIndex;
while (index2 < endIndex) {
const ch = text2.charCodeAt(index2++);
if (ch == quoteCharCode && ch1 !== 92) {
return index2;
}
if (ch == 92 && ch1 === 92) {
ch1 = 0;
} else {
ch1 = ch;
}
}
throw ngDevMode ? malformedStyleError(text2, String.fromCharCode(quoteCharCode), endIndex) : new Error();
}
function malformedStyleError(text2, expecting, index2) {
ngDevMode && assertEqual(typeof text2 === "string", true, "String expected here");
throw throwError2(`Malformed style at location ${index2} in string '` + text2.substring(0, index2) + "[>>" + text2.substring(index2, index2 + 1) + "<<]" + text2.slice(index2 + 1) + `'. Expecting '${expecting}'.`);
}
function \u0275\u0275property(propName, value2, sanitizer) {
const lView = getLView();
const bindingIndex = nextBindingIndex();
if (bindingUpdated(lView, bindingIndex, value2)) {
const tView = getTView();
const tNode = getSelectedTNode();
elementPropertyInternal(tView, tNode, lView, propName, value2, lView[RENDERER], sanitizer, false);
ngDevMode && storePropertyBindingMetadata(tView.data, tNode, propName, bindingIndex);
}
return \u0275\u0275property;
}
function setDirectiveInputsWhichShadowsStyling(tView, tNode, lView, value2, isClassBased) {
const inputs = tNode.inputs;
const property2 = isClassBased ? "class" : "style";
setInputsForProperty(tView, lView, inputs[property2], property2, value2);
}
function \u0275\u0275styleProp(prop, value2, suffix) {
checkStylingProperty(prop, value2, suffix, false);
return \u0275\u0275styleProp;
}
function \u0275\u0275classProp(className, value2) {
checkStylingProperty(className, value2, null, true);
return \u0275\u0275classProp;
}
function \u0275\u0275styleMap(styles) {
checkStylingMap(styleKeyValueArraySet, styleStringParser, styles, false);
}
function styleStringParser(keyValueArray, text2) {
for (let i = parseStyle(text2); i >= 0; i = parseStyleNext(text2, i)) {
styleKeyValueArraySet(keyValueArray, getLastParsedKey(text2), getLastParsedValue(text2));
}
}
function \u0275\u0275classMap(classes) {
checkStylingMap(classKeyValueArraySet, classStringParser, classes, true);
}
function classStringParser(keyValueArray, text2) {
for (let i = parseClassName(text2); i >= 0; i = parseClassNameNext(text2, i)) {
keyValueArraySet(keyValueArray, getLastParsedKey(text2), true);
}
}
function checkStylingProperty(prop, value2, suffix, isClassBased) {
const lView = getLView();
const tView = getTView();
const bindingIndex = incrementBindingIndex(2);
if (tView.firstUpdatePass) {
stylingFirstUpdatePass(tView, prop, bindingIndex, isClassBased);
}
if (value2 !== NO_CHANGE && bindingUpdated(lView, bindingIndex, value2)) {
const tNode = tView.data[getSelectedIndex()];
updateStyling(tView, tNode, lView, lView[RENDERER], prop, lView[bindingIndex + 1] = normalizeSuffix(value2, suffix), isClassBased, bindingIndex);
}
}
function checkStylingMap(keyValueArraySet2, stringParser, value2, isClassBased) {
const tView = getTView();
const bindingIndex = incrementBindingIndex(2);
if (tView.firstUpdatePass) {
stylingFirstUpdatePass(tView, null, bindingIndex, isClassBased);
}
const lView = getLView();
if (value2 !== NO_CHANGE && bindingUpdated(lView, bindingIndex, value2)) {
const tNode = tView.data[getSelectedIndex()];
if (hasStylingInputShadow(tNode, isClassBased) && !isInHostBindings(tView, bindingIndex)) {
if (ngDevMode) {
const tStylingKey = tView.data[bindingIndex];
assertEqual(Array.isArray(tStylingKey) ? tStylingKey[1] : tStylingKey, false, "Styling linked list shadow input should be marked as 'false'");
}
let staticPrefix = isClassBased ? tNode.classesWithoutHost : tNode.stylesWithoutHost;
ngDevMode && isClassBased === false && staticPrefix !== null && assertEqual(staticPrefix.endsWith(";"), true, "Expecting static portion to end with ';'");
if (staticPrefix !== null) {
value2 = concatStringsWithSpace(staticPrefix, value2 ? value2 : "");
}
setDirectiveInputsWhichShadowsStyling(tView, tNode, lView, value2, isClassBased);
} else {
updateStylingMap(tView, tNode, lView, lView[RENDERER], lView[bindingIndex + 1], lView[bindingIndex + 1] = toStylingKeyValueArray(keyValueArraySet2, stringParser, value2), isClassBased, bindingIndex);
}
}
}
function isInHostBindings(tView, bindingIndex) {
return bindingIndex >= tView.expandoStartIndex;
}
function stylingFirstUpdatePass(tView, tStylingKey, bindingIndex, isClassBased) {
ngDevMode && assertFirstUpdatePass(tView);
const tData = tView.data;
if (tData[bindingIndex + 1] === null) {
const tNode = tData[getSelectedIndex()];
ngDevMode && assertDefined(tNode, "TNode expected");
const isHostBindings = isInHostBindings(tView, bindingIndex);
if (hasStylingInputShadow(tNode, isClassBased) && tStylingKey === null && !isHostBindings) {
tStylingKey = false;
}
tStylingKey = wrapInStaticStylingKey(tData, tNode, tStylingKey, isClassBased);
insertTStylingBinding(tData, tNode, tStylingKey, bindingIndex, isHostBindings, isClassBased);
}
}
function wrapInStaticStylingKey(tData, tNode, stylingKey, isClassBased) {
const hostDirectiveDef = getCurrentDirectiveDef(tData);
let residual = isClassBased ? tNode.residualClasses : tNode.residualStyles;
if (hostDirectiveDef === null) {
const isFirstStylingInstructionInTemplate = (isClassBased ? tNode.classBindings : tNode.styleBindings) === 0;
if (isFirstStylingInstructionInTemplate) {
stylingKey = collectStylingFromDirectives(null, tData, tNode, stylingKey, isClassBased);
stylingKey = collectStylingFromTAttrs(stylingKey, tNode.attrs, isClassBased);
residual = null;
}
} else {
const directiveStylingLast = tNode.directiveStylingLast;
const isFirstStylingInstructionInHostBinding = directiveStylingLast === -1 || tData[directiveStylingLast] !== hostDirectiveDef;
if (isFirstStylingInstructionInHostBinding) {
stylingKey = collectStylingFromDirectives(hostDirectiveDef, tData, tNode, stylingKey, isClassBased);
if (residual === null) {
let templateStylingKey = getTemplateHeadTStylingKey(tData, tNode, isClassBased);
if (templateStylingKey !== void 0 && Array.isArray(templateStylingKey)) {
templateStylingKey = collectStylingFromDirectives(null, tData, tNode, templateStylingKey[1], isClassBased);
templateStylingKey = collectStylingFromTAttrs(templateStylingKey, tNode.attrs, isClassBased);
setTemplateHeadTStylingKey(tData, tNode, isClassBased, templateStylingKey);
}
} else {
residual = collectResidual(tData, tNode, isClassBased);
}
}
}
if (residual !== void 0) {
isClassBased ? tNode.residualClasses = residual : tNode.residualStyles = residual;
}
return stylingKey;
}
function getTemplateHeadTStylingKey(tData, tNode, isClassBased) {
const bindings = isClassBased ? tNode.classBindings : tNode.styleBindings;
if (getTStylingRangeNext(bindings) === 0) {
return void 0;
}
return tData[getTStylingRangePrev(bindings)];
}
function setTemplateHeadTStylingKey(tData, tNode, isClassBased, tStylingKey) {
const bindings = isClassBased ? tNode.classBindings : tNode.styleBindings;
ngDevMode && assertNotEqual(getTStylingRangeNext(bindings), 0, "Expecting to have at least one template styling binding.");
tData[getTStylingRangePrev(bindings)] = tStylingKey;
}
function collectResidual(tData, tNode, isClassBased) {
let residual = void 0;
const directiveEnd = tNode.directiveEnd;
ngDevMode && assertNotEqual(tNode.directiveStylingLast, -1, "By the time this function gets called at least one hostBindings-node styling instruction must have executed.");
for (let i = 1 + tNode.directiveStylingLast; i < directiveEnd; i++) {
const attrs = tData[i].hostAttrs;
residual = collectStylingFromTAttrs(residual, attrs, isClassBased);
}
return collectStylingFromTAttrs(residual, tNode.attrs, isClassBased);
}
function collectStylingFromDirectives(hostDirectiveDef, tData, tNode, stylingKey, isClassBased) {
let currentDirective = null;
const directiveEnd = tNode.directiveEnd;
let directiveStylingLast = tNode.directiveStylingLast;
if (directiveStylingLast === -1) {
directiveStylingLast = tNode.directiveStart;
} else {
directiveStylingLast++;
}
while (directiveStylingLast < directiveEnd) {
currentDirective = tData[directiveStylingLast];
ngDevMode && assertDefined(currentDirective, "expected to be defined");
stylingKey = collectStylingFromTAttrs(stylingKey, currentDirective.hostAttrs, isClassBased);
if (currentDirective === hostDirectiveDef)
break;
directiveStylingLast++;
}
if (hostDirectiveDef !== null) {
tNode.directiveStylingLast = directiveStylingLast;
}
return stylingKey;
}
function collectStylingFromTAttrs(stylingKey, attrs, isClassBased) {
const desiredMarker = isClassBased ? 1 : 2;
let currentMarker = -1;
if (attrs !== null) {
for (let i = 0; i < attrs.length; i++) {
const item = attrs[i];
if (typeof item === "number") {
currentMarker = item;
} else {
if (currentMarker === desiredMarker) {
if (!Array.isArray(stylingKey)) {
stylingKey = stylingKey === void 0 ? [] : ["", stylingKey];
}
keyValueArraySet(stylingKey, item, isClassBased ? true : attrs[++i]);
}
}
}
}
return stylingKey === void 0 ? null : stylingKey;
}
function toStylingKeyValueArray(keyValueArraySet2, stringParser, value2) {
if (value2 == null || value2 === "")
return EMPTY_ARRAY;
const styleKeyValueArray = [];
const unwrappedValue = unwrapSafeValue(value2);
if (Array.isArray(unwrappedValue)) {
for (let i = 0; i < unwrappedValue.length; i++) {
keyValueArraySet2(styleKeyValueArray, unwrappedValue[i], true);
}
} else if (typeof unwrappedValue === "object") {
for (const key2 in unwrappedValue) {
if (unwrappedValue.hasOwnProperty(key2)) {
keyValueArraySet2(styleKeyValueArray, key2, unwrappedValue[key2]);
}
}
} else if (typeof unwrappedValue === "string") {
stringParser(styleKeyValueArray, unwrappedValue);
} else {
ngDevMode && throwError2("Unsupported styling type " + typeof unwrappedValue + ": " + unwrappedValue);
}
return styleKeyValueArray;
}
function styleKeyValueArraySet(keyValueArray, key2, value2) {
keyValueArraySet(keyValueArray, key2, unwrapSafeValue(value2));
}
function classKeyValueArraySet(keyValueArray, key2, value2) {
const stringKey = String(key2);
if (stringKey !== "" && !stringKey.includes(" ")) {
keyValueArraySet(keyValueArray, stringKey, value2);
}
}
function updateStylingMap(tView, tNode, lView, renderer2, oldKeyValueArray, newKeyValueArray, isClassBased, bindingIndex) {
if (oldKeyValueArray === NO_CHANGE) {
oldKeyValueArray = EMPTY_ARRAY;
}
let oldIndex = 0;
let newIndex = 0;
let oldKey = 0 < oldKeyValueArray.length ? oldKeyValueArray[0] : null;
let newKey = 0 < newKeyValueArray.length ? newKeyValueArray[0] : null;
while (oldKey !== null || newKey !== null) {
ngDevMode && assertLessThan(oldIndex, 999, "Are we stuck in infinite loop?");
ngDevMode && assertLessThan(newIndex, 999, "Are we stuck in infinite loop?");
const oldValue = oldIndex < oldKeyValueArray.length ? oldKeyValueArray[oldIndex + 1] : void 0;
const newValue = newIndex < newKeyValueArray.length ? newKeyValueArray[newIndex + 1] : void 0;
let setKey = null;
let setValue = void 0;
if (oldKey === newKey) {
oldIndex += 2;
newIndex += 2;
if (oldValue !== newValue) {
setKey = newKey;
setValue = newValue;
}
} else if (newKey === null || oldKey !== null && oldKey < newKey) {
oldIndex += 2;
setKey = oldKey;
} else {
ngDevMode && assertDefined(newKey, "Expecting to have a valid key");
newIndex += 2;
setKey = newKey;
setValue = newValue;
}
if (setKey !== null) {
updateStyling(tView, tNode, lView, renderer2, setKey, setValue, isClassBased, bindingIndex);
}
oldKey = oldIndex < oldKeyValueArray.length ? oldKeyValueArray[oldIndex] : null;
newKey = newIndex < newKeyValueArray.length ? newKeyValueArray[newIndex] : null;
}
}
function updateStyling(tView, tNode, lView, renderer2, prop, value2, isClassBased, bindingIndex) {
if (!(tNode.type & 3)) {
return;
}
const tData = tView.data;
const tRange = tData[bindingIndex + 1];
const higherPriorityValue = getTStylingRangeNextDuplicate(tRange) ? findStylingValue(tData, tNode, lView, prop, getTStylingRangeNext(tRange), isClassBased) : void 0;
if (!isStylingValuePresent(higherPriorityValue)) {
if (!isStylingValuePresent(value2)) {
if (getTStylingRangePrevDuplicate(tRange)) {
value2 = findStylingValue(tData, null, lView, prop, bindingIndex, isClassBased);
}
}
const rNode = getNativeByIndex(getSelectedIndex(), lView);
applyStyling(renderer2, isClassBased, rNode, prop, value2);
}
}
function findStylingValue(tData, tNode, lView, prop, index2, isClassBased) {
const isPrevDirection = tNode === null;
let value2 = void 0;
while (index2 > 0) {
const rawKey = tData[index2];
const containsStatics = Array.isArray(rawKey);
const key2 = containsStatics ? rawKey[1] : rawKey;
const isStylingMap = key2 === null;
let valueAtLViewIndex = lView[index2 + 1];
if (valueAtLViewIndex === NO_CHANGE) {
valueAtLViewIndex = isStylingMap ? EMPTY_ARRAY : void 0;
}
let currentValue = isStylingMap ? keyValueArrayGet(valueAtLViewIndex, prop) : key2 === prop ? valueAtLViewIndex : void 0;
if (containsStatics && !isStylingValuePresent(currentValue)) {
currentValue = keyValueArrayGet(rawKey, prop);
}
if (isStylingValuePresent(currentValue)) {
value2 = currentValue;
if (isPrevDirection) {
return value2;
}
}
const tRange = tData[index2 + 1];
index2 = isPrevDirection ? getTStylingRangePrev(tRange) : getTStylingRangeNext(tRange);
}
if (tNode !== null) {
let residual = isClassBased ? tNode.residualClasses : tNode.residualStyles;
if (residual != null) {
value2 = keyValueArrayGet(residual, prop);
}
}
return value2;
}
function isStylingValuePresent(value2) {
return value2 !== void 0;
}
function normalizeSuffix(value2, suffix) {
if (value2 == null || value2 === "") {
} else if (typeof suffix === "string") {
value2 = value2 + suffix;
} else if (typeof value2 === "object") {
value2 = stringify(unwrapSafeValue(value2));
}
return value2;
}
function hasStylingInputShadow(tNode, isClassBased) {
return (tNode.flags & (isClassBased ? 8 : 16)) !== 0;
}
function \u0275\u0275classMapInterpolate1(prefix, v0, suffix) {
const lView = getLView();
const interpolatedValue = interpolation1(lView, prefix, v0, suffix);
checkStylingMap(keyValueArraySet, classStringParser, interpolatedValue, true);
}
function \u0275\u0275classMapInterpolate2(prefix, v0, i0, v1, suffix) {
const lView = getLView();
const interpolatedValue = interpolation2(lView, prefix, v0, i0, v1, suffix);
checkStylingMap(keyValueArraySet, classStringParser, interpolatedValue, true);
}
function \u0275\u0275classMapInterpolate3(prefix, v0, i0, v1, i1, v2, suffix) {
const lView = getLView();
const interpolatedValue = interpolation3(lView, prefix, v0, i0, v1, i1, v2, suffix);
checkStylingMap(keyValueArraySet, classStringParser, interpolatedValue, true);
}
function \u0275\u0275classMapInterpolate4(prefix, v0, i0, v1, i1, v2, i2, v3, suffix) {
const lView = getLView();
const interpolatedValue = interpolation4(lView, prefix, v0, i0, v1, i1, v2, i2, v3, suffix);
checkStylingMap(keyValueArraySet, classStringParser, interpolatedValue, true);
}
function \u0275\u0275classMapInterpolate5(prefix, v0, i0, v1, i1, v2, i2, v3, i3, v42, suffix) {
const lView = getLView();
const interpolatedValue = interpolation5(lView, prefix, v0, i0, v1, i1, v2, i2, v3, i3, v42, suffix);
checkStylingMap(keyValueArraySet, classStringParser, interpolatedValue, true);
}
function \u0275\u0275classMapInterpolate6(prefix, v0, i0, v1, i1, v2, i2, v3, i3, v42, i4, v5, suffix) {
const lView = getLView();
const interpolatedValue = interpolation6(lView, prefix, v0, i0, v1, i1, v2, i2, v3, i3, v42, i4, v5, suffix);
checkStylingMap(keyValueArraySet, classStringParser, interpolatedValue, true);
}
function \u0275\u0275classMapInterpolate7(prefix, v0, i0, v1, i1, v2, i2, v3, i3, v42, i4, v5, i5, v6, suffix) {
const lView = getLView();
const interpolatedValue = interpolation7(lView, prefix, v0, i0, v1, i1, v2, i2, v3, i3, v42, i4, v5, i5, v6, suffix);
checkStylingMap(keyValueArraySet, classStringParser, interpolatedValue, true);
}
function \u0275\u0275classMapInterpolate8(prefix, v0, i0, v1, i1, v2, i2, v3, i3, v42, i4, v5, i5, v6, i6, v7, suffix) {
const lView = getLView();
const interpolatedValue = interpolation8(lView, prefix, v0, i0, v1, i1, v2, i2, v3, i3, v42, i4, v5, i5, v6, i6, v7, suffix);
checkStylingMap(keyValueArraySet, classStringParser, interpolatedValue, true);
}
function \u0275\u0275classMapInterpolateV(values) {
const lView = getLView();
const interpolatedValue = interpolationV(lView, values);
checkStylingMap(keyValueArraySet, classStringParser, interpolatedValue, true);
}
function \u0275\u0275componentInstance() {
const instance = getLView()[DECLARATION_COMPONENT_VIEW][CONTEXT];
ngDevMode && assertDefined(instance, "Expected component instance to be defined");
return instance;
}
var LiveCollection = class {
destroy(item) {
}
updateValue(index2, value2) {
}
// operations below could be implemented on top of the operations defined so far, but having
// them explicitly allow clear expression of intent and potentially more performant
// implementations
swap(index1, index2) {
const startIdx = Math.min(index1, index2);
const endIdx = Math.max(index1, index2);
const endItem = this.detach(endIdx);
if (endIdx - startIdx > 1) {
const startItem = this.detach(startIdx);
this.attach(startIdx, endItem);
this.attach(endIdx, startItem);
} else {
this.attach(startIdx, endItem);
}
}
move(prevIndex, newIdx) {
this.attach(newIdx, this.detach(prevIndex));
}
};
function valuesMatching(liveIdx, liveValue, newIdx, newValue, trackBy) {
if (liveIdx === newIdx && Object.is(liveValue, newValue)) {
return 1;
} else if (Object.is(trackBy(liveIdx, liveValue), trackBy(newIdx, newValue))) {
return -1;
}
return 0;
}
function reconcile(liveCollection, newCollection, trackByFn) {
let detachedItems = void 0;
let liveKeysInTheFuture = void 0;
let liveStartIdx = 0;
let liveEndIdx = liveCollection.length - 1;
if (Array.isArray(newCollection)) {
let newEndIdx = newCollection.length - 1;
while (liveStartIdx <= liveEndIdx && liveStartIdx <= newEndIdx) {
const liveStartValue = liveCollection.at(liveStartIdx);
const newStartValue = newCollection[liveStartIdx];
const isStartMatching = valuesMatching(liveStartIdx, liveStartValue, liveStartIdx, newStartValue, trackByFn);
if (isStartMatching !== 0) {
if (isStartMatching < 0) {
liveCollection.updateValue(liveStartIdx, newStartValue);
}
liveStartIdx++;
continue;
}
const liveEndValue = liveCollection.at(liveEndIdx);
const newEndValue = newCollection[newEndIdx];
const isEndMatching = valuesMatching(liveEndIdx, liveEndValue, newEndIdx, newEndValue, trackByFn);
if (isEndMatching !== 0) {
if (isEndMatching < 0) {
liveCollection.updateValue(liveEndIdx, newEndValue);
}
liveEndIdx--;
newEndIdx--;
continue;
}
const liveStartKey = trackByFn(liveStartIdx, liveStartValue);
const liveEndKey = trackByFn(liveEndIdx, liveEndValue);
const newStartKey = trackByFn(liveStartIdx, newStartValue);
if (Object.is(newStartKey, liveEndKey)) {
const newEndKey = trackByFn(newEndIdx, newEndValue);
if (Object.is(newEndKey, liveStartKey)) {
liveCollection.swap(liveStartIdx, liveEndIdx);
liveCollection.updateValue(liveEndIdx, newEndValue);
newEndIdx--;
liveEndIdx--;
} else {
liveCollection.move(liveEndIdx, liveStartIdx);
}
liveCollection.updateValue(liveStartIdx, newStartValue);
liveStartIdx++;
continue;
}
detachedItems ??= new UniqueValueMultiKeyMap();
liveKeysInTheFuture ??= initLiveItemsInTheFuture(liveCollection, liveStartIdx, liveEndIdx, trackByFn);
if (attachPreviouslyDetached(liveCollection, detachedItems, liveStartIdx, newStartKey)) {
liveCollection.updateValue(liveStartIdx, newStartValue);
liveStartIdx++;
liveEndIdx++;
} else if (!liveKeysInTheFuture.has(newStartKey)) {
const newItem = liveCollection.create(liveStartIdx, newCollection[liveStartIdx]);
liveCollection.attach(liveStartIdx, newItem);
liveStartIdx++;
liveEndIdx++;
} else {
detachedItems.set(liveStartKey, liveCollection.detach(liveStartIdx));
liveEndIdx--;
}
}
while (liveStartIdx <= newEndIdx) {
createOrAttach(liveCollection, detachedItems, trackByFn, liveStartIdx, newCollection[liveStartIdx]);
liveStartIdx++;
}
} else if (newCollection != null) {
const newCollectionIterator = newCollection[Symbol.iterator]();
let newIterationResult = newCollectionIterator.next();
while (!newIterationResult.done && liveStartIdx <= liveEndIdx) {
const liveValue = liveCollection.at(liveStartIdx);
const newValue = newIterationResult.value;
const isStartMatching = valuesMatching(liveStartIdx, liveValue, liveStartIdx, newValue, trackByFn);
if (isStartMatching !== 0) {
if (isStartMatching < 0) {
liveCollection.updateValue(liveStartIdx, newValue);
}
liveStartIdx++;
newIterationResult = newCollectionIterator.next();
} else {
detachedItems ??= new UniqueValueMultiKeyMap();
liveKeysInTheFuture ??= initLiveItemsInTheFuture(liveCollection, liveStartIdx, liveEndIdx, trackByFn);
const newKey = trackByFn(liveStartIdx, newValue);
if (attachPreviouslyDetached(liveCollection, detachedItems, liveStartIdx, newKey)) {
liveCollection.updateValue(liveStartIdx, newValue);
liveStartIdx++;
liveEndIdx++;
newIterationResult = newCollectionIterator.next();
} else if (!liveKeysInTheFuture.has(newKey)) {
liveCollection.attach(liveStartIdx, liveCollection.create(liveStartIdx, newValue));
liveStartIdx++;
liveEndIdx++;
newIterationResult = newCollectionIterator.next();
} else {
const liveKey = trackByFn(liveStartIdx, liveValue);
detachedItems.set(liveKey, liveCollection.detach(liveStartIdx));
liveEndIdx--;
}
}
}
while (!newIterationResult.done) {
createOrAttach(liveCollection, detachedItems, trackByFn, liveCollection.length, newIterationResult.value);
newIterationResult = newCollectionIterator.next();
}
}
while (liveStartIdx <= liveEndIdx) {
liveCollection.destroy(liveCollection.detach(liveEndIdx--));
}
detachedItems?.forEach((item) => {
liveCollection.destroy(item);
});
}
function attachPreviouslyDetached(prevCollection, detachedItems, index2, key2) {
if (detachedItems !== void 0 && detachedItems.has(key2)) {
prevCollection.attach(index2, detachedItems.get(key2));
detachedItems.delete(key2);
return true;
}
return false;
}
function createOrAttach(liveCollection, detachedItems, trackByFn, index2, value2) {
if (!attachPreviouslyDetached(liveCollection, detachedItems, index2, trackByFn(index2, value2))) {
const newItem = liveCollection.create(index2, value2);
liveCollection.attach(index2, newItem);
} else {
liveCollection.updateValue(index2, value2);
}
}
function initLiveItemsInTheFuture(liveCollection, start, end, trackByFn) {
const keys = /* @__PURE__ */ new Set();
for (let i = start; i <= end; i++) {
keys.add(trackByFn(i, liveCollection.at(i)));
}
return keys;
}
var UniqueValueMultiKeyMap = class {
constructor() {
this.kvMap = /* @__PURE__ */ new Map();
this._vMap = void 0;
}
has(key2) {
return this.kvMap.has(key2);
}
delete(key2) {
if (!this.has(key2))
return false;
const value2 = this.kvMap.get(key2);
if (this._vMap !== void 0 && this._vMap.has(value2)) {
this.kvMap.set(key2, this._vMap.get(value2));
this._vMap.delete(value2);
} else {
this.kvMap.delete(key2);
}
return true;
}
get(key2) {
return this.kvMap.get(key2);
}
set(key2, value2) {
if (this.kvMap.has(key2)) {
let prevValue = this.kvMap.get(key2);
ngDevMode && assertNotSame(prevValue, value2, `Detected a duplicated value ${value2} for the key ${key2}`);
if (this._vMap === void 0) {
this._vMap = /* @__PURE__ */ new Map();
}
const vMap = this._vMap;
while (vMap.has(prevValue)) {
prevValue = vMap.get(prevValue);
}
vMap.set(prevValue, value2);
} else {
this.kvMap.set(key2, value2);
}
}
forEach(cb) {
for (let [key2, value2] of this.kvMap) {
cb(value2, key2);
if (this._vMap !== void 0) {
const vMap = this._vMap;
while (vMap.has(value2)) {
value2 = vMap.get(value2);
cb(value2, key2);
}
}
}
}
};
function \u0275\u0275conditional(containerIndex, matchingTemplateIndex, value2) {
performanceMarkFeature("NgControlFlow");
const hostLView = getLView();
const bindingIndex = nextBindingIndex();
const lContainer = getLContainer(hostLView, HEADER_OFFSET + containerIndex);
const viewInContainerIdx = 0;
if (bindingUpdated(hostLView, bindingIndex, matchingTemplateIndex)) {
const prevConsumer = setActiveConsumer(null);
try {
removeLViewFromLContainer(lContainer, viewInContainerIdx);
if (matchingTemplateIndex !== -1) {
const templateTNode = getExistingTNode(hostLView[TVIEW], HEADER_OFFSET + matchingTemplateIndex);
const dehydratedView = findMatchingDehydratedView(lContainer, templateTNode.tView.ssrId);
const embeddedLView = createAndRenderEmbeddedLView(hostLView, templateTNode, value2, { dehydratedView });
addLViewToLContainer(lContainer, embeddedLView, viewInContainerIdx, shouldAddViewToDom(templateTNode, dehydratedView));
}
} finally {
setActiveConsumer(prevConsumer);
}
} else {
const lView = getLViewFromLContainer(lContainer, viewInContainerIdx);
if (lView !== void 0) {
lView[CONTEXT] = value2;
}
}
}
var RepeaterContext = class {
constructor(lContainer, $implicit, $index) {
this.lContainer = lContainer;
this.$implicit = $implicit;
this.$index = $index;
}
get $count() {
return this.lContainer.length - CONTAINER_HEADER_OFFSET;
}
};
function \u0275\u0275repeaterTrackByIndex(index2) {
return index2;
}
function \u0275\u0275repeaterTrackByIdentity(_, value2) {
return value2;
}
var RepeaterMetadata = class {
constructor(hasEmptyBlock, trackByFn, liveCollection) {
this.hasEmptyBlock = hasEmptyBlock;
this.trackByFn = trackByFn;
this.liveCollection = liveCollection;
}
};
function \u0275\u0275repeaterCreate(index2, templateFn, decls, vars, tagName, attrsIndex, trackByFn, trackByUsesComponentInstance, emptyTemplateFn, emptyDecls, emptyVars, emptyTagName, emptyAttrsIndex) {
performanceMarkFeature("NgControlFlow");
ngDevMode && assertFunction(trackByFn, `A track expression must be a function, was ${typeof trackByFn} instead.`);
const hasEmptyBlock = emptyTemplateFn !== void 0;
const hostLView = getLView();
const boundTrackBy = trackByUsesComponentInstance ? (
// We only want to bind when necessary, because it produces a
// new function. For pure functions it's not necessary.
trackByFn.bind(hostLView[DECLARATION_COMPONENT_VIEW][CONTEXT])
) : trackByFn;
const metadata = new RepeaterMetadata(hasEmptyBlock, boundTrackBy);
hostLView[HEADER_OFFSET + index2] = metadata;
\u0275\u0275template(index2 + 1, templateFn, decls, vars, tagName, attrsIndex);
if (hasEmptyBlock) {
ngDevMode && assertDefined(emptyDecls, "Missing number of declarations for the empty repeater block.");
ngDevMode && assertDefined(emptyVars, "Missing number of bindings for the empty repeater block.");
\u0275\u0275template(index2 + 2, emptyTemplateFn, emptyDecls, emptyVars, emptyTagName, emptyAttrsIndex);
}
}
var LiveCollectionLContainerImpl = class extends LiveCollection {
constructor(lContainer, hostLView, templateTNode) {
super();
this.lContainer = lContainer;
this.hostLView = hostLView;
this.templateTNode = templateTNode;
this.needsIndexUpdate = false;
}
get length() {
return this.lContainer.length - CONTAINER_HEADER_OFFSET;
}
at(index2) {
return this.getLView(index2)[CONTEXT].$implicit;
}
attach(index2, lView) {
const dehydratedView = lView[HYDRATION];
this.needsIndexUpdate ||= index2 !== this.length;
addLViewToLContainer(this.lContainer, lView, index2, shouldAddViewToDom(this.templateTNode, dehydratedView));
}
detach(index2) {
this.needsIndexUpdate ||= index2 !== this.length - 1;
return detachExistingView(this.lContainer, index2);
}
create(index2, value2) {
const dehydratedView = findMatchingDehydratedView(this.lContainer, this.templateTNode.tView.ssrId);
const embeddedLView = createAndRenderEmbeddedLView(this.hostLView, this.templateTNode, new RepeaterContext(this.lContainer, value2, index2), { dehydratedView });
return embeddedLView;
}
destroy(lView) {
destroyLView(lView[TVIEW], lView);
}
updateValue(index2, value2) {
this.getLView(index2)[CONTEXT].$implicit = value2;
}
reset() {
this.needsIndexUpdate = false;
}
updateIndexes() {
if (this.needsIndexUpdate) {
for (let i = 0; i < this.length; i++) {
this.getLView(i)[CONTEXT].$index = i;
}
}
}
getLView(index2) {
return getExistingLViewFromLContainer(this.lContainer, index2);
}
};
function \u0275\u0275repeater(collection) {
const prevConsumer = setActiveConsumer(null);
const metadataSlotIdx = getSelectedIndex();
try {
const hostLView = getLView();
const hostTView = hostLView[TVIEW];
const metadata = hostLView[metadataSlotIdx];
if (metadata.liveCollection === void 0) {
const containerIndex = metadataSlotIdx + 1;
const lContainer = getLContainer(hostLView, containerIndex);
const itemTemplateTNode = getExistingTNode(hostTView, containerIndex);
metadata.liveCollection = new LiveCollectionLContainerImpl(lContainer, hostLView, itemTemplateTNode);
} else {
metadata.liveCollection.reset();
}
const liveCollection = metadata.liveCollection;
reconcile(liveCollection, collection, metadata.trackByFn);
liveCollection.updateIndexes();
if (metadata.hasEmptyBlock) {
const bindingIndex = nextBindingIndex();
const isCollectionEmpty = liveCollection.length === 0;
if (bindingUpdated(hostLView, bindingIndex, isCollectionEmpty)) {
const emptyTemplateIndex = metadataSlotIdx + 2;
const lContainerForEmpty = getLContainer(hostLView, emptyTemplateIndex);
if (isCollectionEmpty) {
const emptyTemplateTNode = getExistingTNode(hostTView, emptyTemplateIndex);
const dehydratedView = findMatchingDehydratedView(lContainerForEmpty, emptyTemplateTNode.tView.ssrId);
const embeddedLView = createAndRenderEmbeddedLView(hostLView, emptyTemplateTNode, void 0, { dehydratedView });
addLViewToLContainer(lContainerForEmpty, embeddedLView, 0, shouldAddViewToDom(emptyTemplateTNode, dehydratedView));
} else {
removeLViewFromLContainer(lContainerForEmpty, 0);
}
}
}
} finally {
setActiveConsumer(prevConsumer);
}
}
function getLContainer(lView, index2) {
const lContainer = lView[index2];
ngDevMode && assertLContainer(lContainer);
return lContainer;
}
function detachExistingView(lContainer, index2) {
const existingLView = detachView(lContainer, index2);
ngDevMode && assertLView(existingLView);
return existingLView;
}
function getExistingLViewFromLContainer(lContainer, index2) {
const existingLView = getLViewFromLContainer(lContainer, index2);
ngDevMode && assertLView(existingLView);
return existingLView;
}
function getExistingTNode(tView, index2) {
const tNode = getTNode(tView, index2);
ngDevMode && assertTNode(tNode);
return tNode;
}
function elementStartFirstCreatePass(index2, tView, lView, name2, attrsIndex, localRefsIndex) {
ngDevMode && assertFirstCreatePass(tView);
ngDevMode && ngDevMode.firstCreatePass++;
const tViewConsts = tView.consts;
const attrs = getConstant(tViewConsts, attrsIndex);
const tNode = getOrCreateTNode(tView, index2, 2, name2, attrs);
resolveDirectives(tView, lView, tNode, getConstant(tViewConsts, localRefsIndex));
if (tNode.attrs !== null) {
computeStaticStyling(tNode, tNode.attrs, false);
}
if (tNode.mergedAttrs !== null) {
computeStaticStyling(tNode, tNode.mergedAttrs, true);
}
if (tView.queries !== null) {
tView.queries.elementStart(tView, tNode);
}
return tNode;
}
function \u0275\u0275elementStart(index2, name2, attrsIndex, localRefsIndex) {
const lView = getLView();
const tView = getTView();
const adjustedIndex = HEADER_OFFSET + index2;
ngDevMode && assertEqual(getBindingIndex(), tView.bindingStartIndex, "elements should be created before any bindings");
ngDevMode && assertIndexInRange(lView, adjustedIndex);
const renderer2 = lView[RENDERER];
const tNode = tView.firstCreatePass ? elementStartFirstCreatePass(adjustedIndex, tView, lView, name2, attrsIndex, localRefsIndex) : tView.data[adjustedIndex];
const native = _locateOrCreateElementNode(tView, lView, tNode, renderer2, name2, index2);
lView[adjustedIndex] = native;
const hasDirectives = isDirectiveHost(tNode);
if (ngDevMode && tView.firstCreatePass) {
validateElementIsKnown(native, lView, tNode.value, tView.schemas, hasDirectives);
}
setCurrentTNode(tNode, true);
setupStaticAttributes(renderer2, native, tNode);
if (!isDetachedByI18n(tNode) && wasLastNodeCreated()) {
appendChild(tView, lView, native, tNode);
}
if (getElementDepthCount() === 0) {
attachPatchData(native, lView);
}
increaseElementDepthCount();
if (hasDirectives) {
createDirectivesInstances(tView, lView, tNode);
executeContentQueries(tView, tNode, lView);
}
if (localRefsIndex !== null) {
saveResolvedLocalsInData(lView, tNode);
}
return \u0275\u0275elementStart;
}
function \u0275\u0275elementEnd() {
let currentTNode = getCurrentTNode();
ngDevMode && assertDefined(currentTNode, "No parent node to close.");
if (isCurrentTNodeParent()) {
setCurrentTNodeAsNotParent();
} else {
ngDevMode && assertHasParent(getCurrentTNode());
currentTNode = currentTNode.parent;
setCurrentTNode(currentTNode, false);
}
const tNode = currentTNode;
ngDevMode && assertTNodeType(
tNode,
3
/* TNodeType.AnyRNode */
);
if (isSkipHydrationRootTNode(tNode)) {
leaveSkipHydrationBlock();
}
decreaseElementDepthCount();
const tView = getTView();
if (tView.firstCreatePass) {
registerPostOrderHooks(tView, currentTNode);
if (isContentQueryHost(currentTNode)) {
tView.queries.elementEnd(currentTNode);
}
}
if (tNode.classesWithoutHost != null && hasClassInput(tNode)) {
setDirectiveInputsWhichShadowsStyling(tView, tNode, getLView(), tNode.classesWithoutHost, true);
}
if (tNode.stylesWithoutHost != null && hasStyleInput(tNode)) {
setDirectiveInputsWhichShadowsStyling(tView, tNode, getLView(), tNode.stylesWithoutHost, false);
}
return \u0275\u0275elementEnd;
}
function \u0275\u0275element(index2, name2, attrsIndex, localRefsIndex) {
\u0275\u0275elementStart(index2, name2, attrsIndex, localRefsIndex);
\u0275\u0275elementEnd();
return \u0275\u0275element;
}
var _locateOrCreateElementNode = (tView, lView, tNode, renderer2, name2, index2) => {
lastNodeWasCreated(true);
return createElementNode(renderer2, name2, getNamespace$1());
};
function elementContainerStartFirstCreatePass(index2, tView, lView, attrsIndex, localRefsIndex) {
ngDevMode && ngDevMode.firstCreatePass++;
const tViewConsts = tView.consts;
const attrs = getConstant(tViewConsts, attrsIndex);
const tNode = getOrCreateTNode(tView, index2, 8, "ng-container", attrs);
if (attrs !== null) {
computeStaticStyling(tNode, attrs, true);
}
const localRefs = getConstant(tViewConsts, localRefsIndex);
resolveDirectives(tView, lView, tNode, localRefs);
if (tView.queries !== null) {
tView.queries.elementStart(tView, tNode);
}
return tNode;
}
function \u0275\u0275elementContainerStart(index2, attrsIndex, localRefsIndex) {
const lView = getLView();
const tView = getTView();
const adjustedIndex = index2 + HEADER_OFFSET;
ngDevMode && assertIndexInRange(lView, adjustedIndex);
ngDevMode && assertEqual(getBindingIndex(), tView.bindingStartIndex, "element containers should be created before any bindings");
const tNode = tView.firstCreatePass ? elementContainerStartFirstCreatePass(adjustedIndex, tView, lView, attrsIndex, localRefsIndex) : tView.data[adjustedIndex];
setCurrentTNode(tNode, true);
const comment = _locateOrCreateElementContainerNode(tView, lView, tNode, index2);
lView[adjustedIndex] = comment;
if (wasLastNodeCreated()) {
appendChild(tView, lView, comment, tNode);
}
attachPatchData(comment, lView);
if (isDirectiveHost(tNode)) {
createDirectivesInstances(tView, lView, tNode);
executeContentQueries(tView, tNode, lView);
}
if (localRefsIndex != null) {
saveResolvedLocalsInData(lView, tNode);
}
return \u0275\u0275elementContainerStart;
}
function \u0275\u0275elementContainerEnd() {
let currentTNode = getCurrentTNode();
const tView = getTView();
if (isCurrentTNodeParent()) {
setCurrentTNodeAsNotParent();
} else {
ngDevMode && assertHasParent(currentTNode);
currentTNode = currentTNode.parent;
setCurrentTNode(currentTNode, false);
}
ngDevMode && assertTNodeType(
currentTNode,
8
/* TNodeType.ElementContainer */
);
if (tView.firstCreatePass) {
registerPostOrderHooks(tView, currentTNode);
if (isContentQueryHost(currentTNode)) {
tView.queries.elementEnd(currentTNode);
}
}
return \u0275\u0275elementContainerEnd;
}
function \u0275\u0275elementContainer(index2, attrsIndex, localRefsIndex) {
\u0275\u0275elementContainerStart(index2, attrsIndex, localRefsIndex);
\u0275\u0275elementContainerEnd();
return \u0275\u0275elementContainer;
}
var _locateOrCreateElementContainerNode = (tView, lView, tNode, index2) => {
lastNodeWasCreated(true);
return createCommentNode(lView[RENDERER], ngDevMode ? "ng-container" : "");
};
function \u0275\u0275getCurrentView() {
return getLView();
}
function \u0275\u0275hostProperty(propName, value2, sanitizer) {
const lView = getLView();
const bindingIndex = nextBindingIndex();
if (bindingUpdated(lView, bindingIndex, value2)) {
const tView = getTView();
const tNode = getSelectedTNode();
elementPropertyInternal(tView, tNode, lView, propName, value2, lView[RENDERER], sanitizer, true);
ngDevMode && storePropertyBindingMetadata(tView.data, tNode, propName, bindingIndex);
}
return \u0275\u0275hostProperty;
}
function \u0275\u0275syntheticHostProperty(propName, value2, sanitizer) {
const lView = getLView();
const bindingIndex = nextBindingIndex();
if (bindingUpdated(lView, bindingIndex, value2)) {
const tView = getTView();
const tNode = getSelectedTNode();
const currentDef = getCurrentDirectiveDef(tView.data);
const renderer2 = loadComponentRenderer(currentDef, tNode, lView);
elementPropertyInternal(tView, tNode, lView, propName, value2, renderer2, sanitizer, true);
ngDevMode && storePropertyBindingMetadata(tView.data, tNode, propName, bindingIndex);
}
return \u0275\u0275syntheticHostProperty;
}
if (false) {
(function() {
_global["ngI18nClosureMode"] = // TODO(FW-1250): validate that this actually, you know, works.
// tslint:disable-next-line:no-toplevel-property-access
typeof goog !== "undefined" && typeof goog.getMsg === "function";
})();
}
var u = void 0;
function plural(val2) {
const n = val2, i = Math.floor(Math.abs(val2)), v = val2.toString().replace(/^[^.]*\.?/, "").length;
if (i === 1 && v === 0)
return 1;
return 5;
}
var localeEn = ["en", [["a", "p"], ["AM", "PM"], u], [["AM", "PM"], u, u], [["S", "M", "T", "W", "T", "F", "S"], ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"], ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"], ["Su", "Mo", "Tu", "We", "Th", "Fr", "Sa"]], u, [["J", "F", "M", "A", "M", "J", "J", "A", "S", "O", "N", "D"], ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"], ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"]], u, [["B", "A"], ["BC", "AD"], ["Before Christ", "Anno Domini"]], 0, [6, 0], ["M/d/yy", "MMM d, y", "MMMM d, y", "EEEE, MMMM d, y"], ["h:mm a", "h:mm:ss a", "h:mm:ss a z", "h:mm:ss a zzzz"], ["{1}, {0}", u, "{1} 'at' {0}", u], [".", ",", ";", "%", "+", "-", "E", "\xD7", "\u2030", "\u221E", "NaN", ":"], ["#,##0.###", "#,##0%", "\xA4#,##0.00", "#E0"], "USD", "$", "US Dollar", {}, "ltr", plural];
var LOCALE_DATA = {};
function findLocaleData(locale) {
const normalizedLocale = normalizeLocale(locale);
let match2 = getLocaleData(normalizedLocale);
if (match2) {
return match2;
}
const parentLocale = normalizedLocale.split("-")[0];
match2 = getLocaleData(parentLocale);
if (match2) {
return match2;
}
if (parentLocale === "en") {
return localeEn;
}
throw new RuntimeError(701, ngDevMode && `Missing locale data for the locale "${locale}".`);
}
function getLocalePluralCase(locale) {
const data2 = findLocaleData(locale);
return data2[LocaleDataIndex.PluralCase];
}
function getLocaleData(normalizedLocale) {
if (!(normalizedLocale in LOCALE_DATA)) {
LOCALE_DATA[normalizedLocale] = _global.ng && _global.ng.common && _global.ng.common.locales && _global.ng.common.locales[normalizedLocale];
}
return LOCALE_DATA[normalizedLocale];
}
var LocaleDataIndex;
(function(LocaleDataIndex2) {
LocaleDataIndex2[LocaleDataIndex2["LocaleId"] = 0] = "LocaleId";
LocaleDataIndex2[LocaleDataIndex2["DayPeriodsFormat"] = 1] = "DayPeriodsFormat";
LocaleDataIndex2[LocaleDataIndex2["DayPeriodsStandalone"] = 2] = "DayPeriodsStandalone";
LocaleDataIndex2[LocaleDataIndex2["DaysFormat"] = 3] = "DaysFormat";
LocaleDataIndex2[LocaleDataIndex2["DaysStandalone"] = 4] = "DaysStandalone";
LocaleDataIndex2[LocaleDataIndex2["MonthsFormat"] = 5] = "MonthsFormat";
LocaleDataIndex2[LocaleDataIndex2["MonthsStandalone"] = 6] = "MonthsStandalone";
LocaleDataIndex2[LocaleDataIndex2["Eras"] = 7] = "Eras";
LocaleDataIndex2[LocaleDataIndex2["FirstDayOfWeek"] = 8] = "FirstDayOfWeek";
LocaleDataIndex2[LocaleDataIndex2["WeekendRange"] = 9] = "WeekendRange";
LocaleDataIndex2[LocaleDataIndex2["DateFormat"] = 10] = "DateFormat";
LocaleDataIndex2[LocaleDataIndex2["TimeFormat"] = 11] = "TimeFormat";
LocaleDataIndex2[LocaleDataIndex2["DateTimeFormat"] = 12] = "DateTimeFormat";
LocaleDataIndex2[LocaleDataIndex2["NumberSymbols"] = 13] = "NumberSymbols";
LocaleDataIndex2[LocaleDataIndex2["NumberFormats"] = 14] = "NumberFormats";
LocaleDataIndex2[LocaleDataIndex2["CurrencyCode"] = 15] = "CurrencyCode";
LocaleDataIndex2[LocaleDataIndex2["CurrencySymbol"] = 16] = "CurrencySymbol";
LocaleDataIndex2[LocaleDataIndex2["CurrencyName"] = 17] = "CurrencyName";
LocaleDataIndex2[LocaleDataIndex2["Currencies"] = 18] = "Currencies";
LocaleDataIndex2[LocaleDataIndex2["Directionality"] = 19] = "Directionality";
LocaleDataIndex2[LocaleDataIndex2["PluralCase"] = 20] = "PluralCase";
LocaleDataIndex2[LocaleDataIndex2["ExtraData"] = 21] = "ExtraData";
})(LocaleDataIndex || (LocaleDataIndex = {}));
function normalizeLocale(locale) {
return locale.toLowerCase().replace(/_/g, "-");
}
var pluralMapping = ["zero", "one", "two", "few", "many"];
function getPluralCase(value2, locale) {
const plural2 = getLocalePluralCase(locale)(parseInt(value2, 10));
const result = pluralMapping[plural2];
return result !== void 0 ? result : "other";
}
var DEFAULT_LOCALE_ID = "en-US";
var USD_CURRENCY_CODE = "USD";
var ELEMENT_MARKER = {
marker: "element"
};
var ICU_MARKER = {
marker: "ICU"
};
var I18nCreateOpCode;
(function(I18nCreateOpCode2) {
I18nCreateOpCode2[I18nCreateOpCode2["SHIFT"] = 2] = "SHIFT";
I18nCreateOpCode2[I18nCreateOpCode2["APPEND_EAGERLY"] = 1] = "APPEND_EAGERLY";
I18nCreateOpCode2[I18nCreateOpCode2["COMMENT"] = 2] = "COMMENT";
})(I18nCreateOpCode || (I18nCreateOpCode = {}));
var LOCALE_ID$1 = DEFAULT_LOCALE_ID;
function setLocaleId(localeId) {
ngDevMode && assertDefined(localeId, `Expected localeId to be defined`);
if (typeof localeId === "string") {
LOCALE_ID$1 = localeId.toLowerCase().replace(/_/g, "-");
}
}
function getLocaleId() {
return LOCALE_ID$1;
}
function getInsertInFrontOfRNodeWithI18n(parentTNode, currentTNode, lView) {
const tNodeInsertBeforeIndex = currentTNode.insertBeforeIndex;
const insertBeforeIndex = Array.isArray(tNodeInsertBeforeIndex) ? tNodeInsertBeforeIndex[0] : tNodeInsertBeforeIndex;
if (insertBeforeIndex === null) {
return getInsertInFrontOfRNodeWithNoI18n(parentTNode, currentTNode, lView);
} else {
ngDevMode && assertIndexInRange(lView, insertBeforeIndex);
return unwrapRNode(lView[insertBeforeIndex]);
}
}
function processI18nInsertBefore(renderer2, childTNode, lView, childRNode, parentRElement) {
const tNodeInsertBeforeIndex = childTNode.insertBeforeIndex;
if (Array.isArray(tNodeInsertBeforeIndex)) {
ngDevMode && assertDomNode(childRNode);
let i18nParent = childRNode;
let anchorRNode = null;
if (!(childTNode.type & 3)) {
anchorRNode = i18nParent;
i18nParent = parentRElement;
}
if (i18nParent !== null && childTNode.componentOffset === -1) {
for (let i = 1; i < tNodeInsertBeforeIndex.length; i++) {
const i18nChild = lView[tNodeInsertBeforeIndex[i]];
nativeInsertBefore(renderer2, i18nParent, i18nChild, anchorRNode, false);
}
}
}
}
function addTNodeAndUpdateInsertBeforeIndex(previousTNodes, newTNode) {
ngDevMode && assertEqual(newTNode.insertBeforeIndex, null, "We expect that insertBeforeIndex is not set");
previousTNodes.push(newTNode);
if (previousTNodes.length > 1) {
for (let i = previousTNodes.length - 2; i >= 0; i--) {
const existingTNode = previousTNodes[i];
if (!isI18nText(existingTNode)) {
if (isNewTNodeCreatedBefore(existingTNode, newTNode) && getInsertBeforeIndex(existingTNode) === null) {
setInsertBeforeIndex(existingTNode, newTNode.index);
}
}
}
}
}
function isI18nText(tNode) {
return !(tNode.type & 64);
}
function isNewTNodeCreatedBefore(existingTNode, newTNode) {
return isI18nText(newTNode) || existingTNode.index > newTNode.index;
}
function getInsertBeforeIndex(tNode) {
const index2 = tNode.insertBeforeIndex;
return Array.isArray(index2) ? index2[0] : index2;
}
function setInsertBeforeIndex(tNode, value2) {
const index2 = tNode.insertBeforeIndex;
if (Array.isArray(index2)) {
index2[0] = value2;
} else {
setI18nHandling(getInsertInFrontOfRNodeWithI18n, processI18nInsertBefore);
tNode.insertBeforeIndex = value2;
}
}
function getTIcu(tView, index2) {
const value2 = tView.data[index2];
if (value2 === null || typeof value2 === "string")
return null;
if (ngDevMode && !(value2.hasOwnProperty("tView") || value2.hasOwnProperty("currentCaseLViewIndex"))) {
throwError2("We expect to get 'null'|'TIcu'|'TIcuContainer', but got: " + value2);
}
const tIcu = value2.hasOwnProperty("currentCaseLViewIndex") ? value2 : value2.value;
ngDevMode && assertTIcu(tIcu);
return tIcu;
}
function setTIcu(tView, index2, tIcu) {
const tNode = tView.data[index2];
ngDevMode && assertEqual(tNode === null || tNode.hasOwnProperty("tView"), true, "We expect to get 'null'|'TIcuContainer'");
if (tNode === null) {
tView.data[index2] = tIcu;
} else {
ngDevMode && assertTNodeType(
tNode,
32
/* TNodeType.Icu */
);
tNode.value = tIcu;
}
}
function setTNodeInsertBeforeIndex(tNode, index2) {
ngDevMode && assertTNode(tNode);
let insertBeforeIndex = tNode.insertBeforeIndex;
if (insertBeforeIndex === null) {
setI18nHandling(getInsertInFrontOfRNodeWithI18n, processI18nInsertBefore);
insertBeforeIndex = tNode.insertBeforeIndex = [null, index2];
} else {
assertEqual(Array.isArray(insertBeforeIndex), true, "Expecting array here");
insertBeforeIndex.push(index2);
}
}
function createTNodePlaceholder(tView, previousTNodes, index2) {
const tNode = createTNodeAtIndex(tView, index2, 64, null, null);
addTNodeAndUpdateInsertBeforeIndex(previousTNodes, tNode);
return tNode;
}
function getCurrentICUCaseIndex(tIcu, lView) {
const currentCase = lView[tIcu.currentCaseLViewIndex];
return currentCase === null ? currentCase : currentCase < 0 ? ~currentCase : currentCase;
}
function getParentFromIcuCreateOpCode(mergedCode) {
return mergedCode >>> 17;
}
function getRefFromIcuCreateOpCode(mergedCode) {
return (mergedCode & 131070) >>> 1;
}
function getInstructionFromIcuCreateOpCode(mergedCode) {
return mergedCode & 1;
}
function icuCreateOpCode(opCode, parentIdx, refIdx) {
ngDevMode && assertGreaterThanOrEqual(parentIdx, 0, "Missing parent index");
ngDevMode && assertGreaterThan(refIdx, 0, "Missing ref index");
return opCode | parentIdx << 17 | refIdx << 1;
}
var changeMask = 0;
var changeMaskCounter = 0;
function setMaskBit(hasChange) {
if (hasChange) {
changeMask = changeMask | 1 << Math.min(changeMaskCounter, 31);
}
changeMaskCounter++;
}
function applyI18n(tView, lView, index2) {
if (changeMaskCounter > 0) {
ngDevMode && assertDefined(tView, `tView should be defined`);
const tI18n = tView.data[index2];
const updateOpCodes = Array.isArray(tI18n) ? tI18n : tI18n.update;
const bindingsStartIndex = getBindingIndex() - changeMaskCounter - 1;
applyUpdateOpCodes(tView, lView, updateOpCodes, bindingsStartIndex, changeMask);
}
changeMask = 0;
changeMaskCounter = 0;
}
function createNodeWithoutHydration(lView, textOrName, nodeType) {
const renderer2 = lView[RENDERER];
switch (nodeType) {
case Node.COMMENT_NODE:
return createCommentNode(renderer2, textOrName);
case Node.TEXT_NODE:
return createTextNode(renderer2, textOrName);
case Node.ELEMENT_NODE:
return createElementNode(renderer2, textOrName, null);
}
}
var _locateOrCreateNode = (lView, index2, textOrName, nodeType) => {
lastNodeWasCreated(true);
return createNodeWithoutHydration(lView, textOrName, nodeType);
};
function applyCreateOpCodes(lView, createOpCodes, parentRNode, insertInFrontOf) {
const renderer2 = lView[RENDERER];
for (let i = 0; i < createOpCodes.length; i++) {
const opCode = createOpCodes[i++];
const text2 = createOpCodes[i];
const isComment = (opCode & I18nCreateOpCode.COMMENT) === I18nCreateOpCode.COMMENT;
const appendNow = (opCode & I18nCreateOpCode.APPEND_EAGERLY) === I18nCreateOpCode.APPEND_EAGERLY;
const index2 = opCode >>> I18nCreateOpCode.SHIFT;
let rNode = lView[index2];
let lastNodeWasCreated2 = false;
if (rNode === null) {
rNode = lView[index2] = _locateOrCreateNode(lView, index2, text2, isComment ? Node.COMMENT_NODE : Node.TEXT_NODE);
lastNodeWasCreated2 = wasLastNodeCreated();
}
if (appendNow && parentRNode !== null && lastNodeWasCreated2) {
nativeInsertBefore(renderer2, parentRNode, rNode, insertInFrontOf, false);
}
}
}
function applyMutableOpCodes(tView, mutableOpCodes, lView, anchorRNode) {
ngDevMode && assertDomNode(anchorRNode);
const renderer2 = lView[RENDERER];
let rootIdx = null;
let rootRNode;
for (let i = 0; i < mutableOpCodes.length; i++) {
const opCode = mutableOpCodes[i];
if (typeof opCode == "string") {
const textNodeIndex = mutableOpCodes[++i];
if (lView[textNodeIndex] === null) {
ngDevMode && ngDevMode.rendererCreateTextNode++;
ngDevMode && assertIndexInRange(lView, textNodeIndex);
lView[textNodeIndex] = _locateOrCreateNode(lView, textNodeIndex, opCode, Node.TEXT_NODE);
}
} else if (typeof opCode == "number") {
switch (opCode & 1) {
case 0:
const parentIdx = getParentFromIcuCreateOpCode(opCode);
if (rootIdx === null) {
rootIdx = parentIdx;
rootRNode = nativeParentNode(renderer2, anchorRNode);
}
let insertInFrontOf;
let parentRNode;
if (parentIdx === rootIdx) {
insertInFrontOf = anchorRNode;
parentRNode = rootRNode;
} else {
insertInFrontOf = null;
parentRNode = unwrapRNode(lView[parentIdx]);
}
if (parentRNode !== null) {
ngDevMode && assertDomNode(parentRNode);
const refIdx = getRefFromIcuCreateOpCode(opCode);
ngDevMode && assertGreaterThan(refIdx, HEADER_OFFSET, "Missing ref");
const child = lView[refIdx];
ngDevMode && assertDomNode(child);
nativeInsertBefore(renderer2, parentRNode, child, insertInFrontOf, false);
const tIcu = getTIcu(tView, refIdx);
if (tIcu !== null && typeof tIcu === "object") {
ngDevMode && assertTIcu(tIcu);
const caseIndex = getCurrentICUCaseIndex(tIcu, lView);
if (caseIndex !== null) {
applyMutableOpCodes(tView, tIcu.create[caseIndex], lView, lView[tIcu.anchorIdx]);
}
}
}
break;
case 1:
const elementNodeIndex = opCode >>> 1;
const attrName = mutableOpCodes[++i];
const attrValue = mutableOpCodes[++i];
setElementAttribute(renderer2, getNativeByIndex(elementNodeIndex, lView), null, null, attrName, attrValue, null);
break;
default:
if (ngDevMode) {
throw new RuntimeError(700, `Unable to determine the type of mutate operation for "${opCode}"`);
}
}
} else {
switch (opCode) {
case ICU_MARKER:
const commentValue = mutableOpCodes[++i];
const commentNodeIndex = mutableOpCodes[++i];
if (lView[commentNodeIndex] === null) {
ngDevMode && assertEqual(typeof commentValue, "string", `Expected "${commentValue}" to be a comment node value`);
ngDevMode && ngDevMode.rendererCreateComment++;
ngDevMode && assertIndexInExpandoRange(lView, commentNodeIndex);
const commentRNode = lView[commentNodeIndex] = _locateOrCreateNode(lView, commentNodeIndex, commentValue, Node.COMMENT_NODE);
attachPatchData(commentRNode, lView);
}
break;
case ELEMENT_MARKER:
const tagName = mutableOpCodes[++i];
const elementNodeIndex = mutableOpCodes[++i];
if (lView[elementNodeIndex] === null) {
ngDevMode && assertEqual(typeof tagName, "string", `Expected "${tagName}" to be an element node tag name`);
ngDevMode && ngDevMode.rendererCreateElement++;
ngDevMode && assertIndexInExpandoRange(lView, elementNodeIndex);
const elementRNode = lView[elementNodeIndex] = _locateOrCreateNode(lView, elementNodeIndex, tagName, Node.ELEMENT_NODE);
attachPatchData(elementRNode, lView);
}
break;
default:
ngDevMode && throwError2(`Unable to determine the type of mutate operation for "${opCode}"`);
}
}
}
}
function applyUpdateOpCodes(tView, lView, updateOpCodes, bindingsStartIndex, changeMask2) {
for (let i = 0; i < updateOpCodes.length; i++) {
const checkBit = updateOpCodes[i];
const skipCodes = updateOpCodes[++i];
if (checkBit & changeMask2) {
let value2 = "";
for (let j = i + 1; j <= i + skipCodes; j++) {
const opCode = updateOpCodes[j];
if (typeof opCode == "string") {
value2 += opCode;
} else if (typeof opCode == "number") {
if (opCode < 0) {
value2 += renderStringify(lView[bindingsStartIndex - opCode]);
} else {
const nodeIndex = opCode >>> 2;
switch (opCode & 3) {
case 1:
const propName = updateOpCodes[++j];
const sanitizeFn = updateOpCodes[++j];
const tNodeOrTagName = tView.data[nodeIndex];
ngDevMode && assertDefined(tNodeOrTagName, "Experting TNode or string");
if (typeof tNodeOrTagName === "string") {
setElementAttribute(lView[RENDERER], lView[nodeIndex], null, tNodeOrTagName, propName, value2, sanitizeFn);
} else {
elementPropertyInternal(tView, tNodeOrTagName, lView, propName, value2, lView[RENDERER], sanitizeFn, false);
}
break;
case 0:
const rText = lView[nodeIndex];
rText !== null && updateTextNode(lView[RENDERER], rText, value2);
break;
case 2:
applyIcuSwitchCase(tView, getTIcu(tView, nodeIndex), lView, value2);
break;
case 3:
applyIcuUpdateCase(tView, getTIcu(tView, nodeIndex), bindingsStartIndex, lView);
break;
}
}
}
}
} else {
const opCode = updateOpCodes[i + 1];
if (opCode > 0 && (opCode & 3) === 3) {
const nodeIndex = opCode >>> 2;
const tIcu = getTIcu(tView, nodeIndex);
const currentIndex = lView[tIcu.currentCaseLViewIndex];
if (currentIndex < 0) {
applyIcuUpdateCase(tView, tIcu, bindingsStartIndex, lView);
}
}
}
i += skipCodes;
}
}
function applyIcuUpdateCase(tView, tIcu, bindingsStartIndex, lView) {
ngDevMode && assertIndexInRange(lView, tIcu.currentCaseLViewIndex);
let activeCaseIndex = lView[tIcu.currentCaseLViewIndex];
if (activeCaseIndex !== null) {
let mask2 = changeMask;
if (activeCaseIndex < 0) {
activeCaseIndex = lView[tIcu.currentCaseLViewIndex] = ~activeCaseIndex;
mask2 = -1;
}
applyUpdateOpCodes(tView, lView, tIcu.update[activeCaseIndex], bindingsStartIndex, mask2);
}
}
function applyIcuSwitchCase(tView, tIcu, lView, value2) {
const caseIndex = getCaseIndex(tIcu, value2);
let activeCaseIndex = getCurrentICUCaseIndex(tIcu, lView);
if (activeCaseIndex !== caseIndex) {
applyIcuSwitchCaseRemove(tView, tIcu, lView);
lView[tIcu.currentCaseLViewIndex] = caseIndex === null ? null : ~caseIndex;
if (caseIndex !== null) {
const anchorRNode = lView[tIcu.anchorIdx];
if (anchorRNode) {
ngDevMode && assertDomNode(anchorRNode);
applyMutableOpCodes(tView, tIcu.create[caseIndex], lView, anchorRNode);
}
}
}
}
function applyIcuSwitchCaseRemove(tView, tIcu, lView) {
let activeCaseIndex = getCurrentICUCaseIndex(tIcu, lView);
if (activeCaseIndex !== null) {
const removeCodes = tIcu.remove[activeCaseIndex];
for (let i = 0; i < removeCodes.length; i++) {
const nodeOrIcuIndex = removeCodes[i];
if (nodeOrIcuIndex > 0) {
const rNode = getNativeByIndex(nodeOrIcuIndex, lView);
rNode !== null && nativeRemoveNode(lView[RENDERER], rNode);
} else {
applyIcuSwitchCaseRemove(tView, getTIcu(tView, ~nodeOrIcuIndex), lView);
}
}
}
}
function getCaseIndex(icuExpression, bindingValue) {
let index2 = icuExpression.cases.indexOf(bindingValue);
if (index2 === -1) {
switch (icuExpression.type) {
case 1: {
const resolvedCase = getPluralCase(bindingValue, getLocaleId());
index2 = icuExpression.cases.indexOf(resolvedCase);
if (index2 === -1 && resolvedCase !== "other") {
index2 = icuExpression.cases.indexOf("other");
}
break;
}
case 0: {
index2 = icuExpression.cases.indexOf("other");
break;
}
}
}
return index2 === -1 ? null : index2;
}
function loadIcuContainerVisitor() {
const _stack = [];
let _index = -1;
let _lView;
let _removes;
function icuContainerIteratorStart(tIcuContainerNode, lView) {
_lView = lView;
while (_stack.length)
_stack.pop();
ngDevMode && assertTNodeForLView(tIcuContainerNode, lView);
enterIcu(tIcuContainerNode.value, lView);
return icuContainerIteratorNext;
}
function enterIcu(tIcu, lView) {
_index = 0;
const currentCase = getCurrentICUCaseIndex(tIcu, lView);
if (currentCase !== null) {
ngDevMode && assertNumberInRange(currentCase, 0, tIcu.cases.length - 1);
_removes = tIcu.remove[currentCase];
} else {
_removes = EMPTY_ARRAY;
}
}
function icuContainerIteratorNext() {
if (_index < _removes.length) {
const removeOpCode = _removes[_index++];
ngDevMode && assertNumber(removeOpCode, "Expecting OpCode number");
if (removeOpCode > 0) {
const rNode = _lView[removeOpCode];
ngDevMode && assertDomNode(rNode);
return rNode;
} else {
_stack.push(_index, _removes);
const tIcuIndex = ~removeOpCode;
const tIcu = _lView[TVIEW].data[tIcuIndex];
ngDevMode && assertTIcu(tIcu);
enterIcu(tIcu, _lView);
return icuContainerIteratorNext();
}
} else {
if (_stack.length === 0) {
return null;
} else {
_removes = _stack.pop();
_index = _stack.pop();
return icuContainerIteratorNext();
}
}
}
return icuContainerIteratorStart;
}
function i18nCreateOpCodesToString(opcodes) {
const createOpCodes = opcodes || (Array.isArray(this) ? this : []);
let lines = [];
for (let i = 0; i < createOpCodes.length; i++) {
const opCode = createOpCodes[i++];
const text2 = createOpCodes[i];
const isComment = (opCode & I18nCreateOpCode.COMMENT) === I18nCreateOpCode.COMMENT;
const appendNow = (opCode & I18nCreateOpCode.APPEND_EAGERLY) === I18nCreateOpCode.APPEND_EAGERLY;
const index2 = opCode >>> I18nCreateOpCode.SHIFT;
lines.push(`lView[${index2}] = document.${isComment ? "createComment" : "createText"}(${JSON.stringify(text2)});`);
if (appendNow) {
lines.push(`parent.appendChild(lView[${index2}]);`);
}
}
return lines;
}
function i18nUpdateOpCodesToString(opcodes) {
const parser = new OpCodeParser(opcodes || (Array.isArray(this) ? this : []));
let lines = [];
function consumeOpCode(value2) {
const ref = value2 >>> 2;
const opCode = value2 & 3;
switch (opCode) {
case 0:
return `(lView[${ref}] as Text).textContent = $$$`;
case 1:
const attrName = parser.consumeString();
const sanitizationFn = parser.consumeFunction();
const value3 = sanitizationFn ? `(${sanitizationFn})($$$)` : "$$$";
return `(lView[${ref}] as Element).setAttribute('${attrName}', ${value3})`;
case 2:
return `icuSwitchCase(${ref}, $$$)`;
case 3:
return `icuUpdateCase(${ref})`;
}
throw new Error("unexpected OpCode");
}
while (parser.hasMore()) {
let mask2 = parser.consumeNumber();
let size = parser.consumeNumber();
const end = parser.i + size;
const statements = [];
let statement = "";
while (parser.i < end) {
let value2 = parser.consumeNumberOrString();
if (typeof value2 === "string") {
statement += value2;
} else if (value2 < 0) {
statement += "${lView[i" + value2 + "]}";
} else {
const opCodeText = consumeOpCode(value2);
statements.push(opCodeText.replace("$$$", "`" + statement + "`") + ";");
statement = "";
}
}
lines.push(`if (mask & 0b${mask2.toString(2)}) { ${statements.join(" ")} }`);
}
return lines;
}
function icuCreateOpCodesToString(opcodes) {
const parser = new OpCodeParser(opcodes || (Array.isArray(this) ? this : []));
let lines = [];
function consumeOpCode(opCode) {
const parent2 = getParentFromIcuCreateOpCode(opCode);
const ref = getRefFromIcuCreateOpCode(opCode);
switch (getInstructionFromIcuCreateOpCode(opCode)) {
case 0:
return `(lView[${parent2}] as Element).appendChild(lView[${lastRef}])`;
case 1:
return `(lView[${ref}] as Element).setAttribute("${parser.consumeString()}", "${parser.consumeString()}")`;
}
throw new Error("Unexpected OpCode: " + getInstructionFromIcuCreateOpCode(opCode));
}
let lastRef = -1;
while (parser.hasMore()) {
let value2 = parser.consumeNumberStringOrMarker();
if (value2 === ICU_MARKER) {
const text2 = parser.consumeString();
lastRef = parser.consumeNumber();
lines.push(`lView[${lastRef}] = document.createComment("${text2}")`);
} else if (value2 === ELEMENT_MARKER) {
const text2 = parser.consumeString();
lastRef = parser.consumeNumber();
lines.push(`lView[${lastRef}] = document.createElement("${text2}")`);
} else if (typeof value2 === "string") {
lastRef = parser.consumeNumber();
lines.push(`lView[${lastRef}] = document.createTextNode("${value2}")`);
} else if (typeof value2 === "number") {
const line = consumeOpCode(value2);
line && lines.push(line);
} else {
throw new Error("Unexpected value");
}
}
return lines;
}
function i18nRemoveOpCodesToString(opcodes) {
const removeCodes = opcodes || (Array.isArray(this) ? this : []);
let lines = [];
for (let i = 0; i < removeCodes.length; i++) {
const nodeOrIcuIndex = removeCodes[i];
if (nodeOrIcuIndex > 0) {
lines.push(`remove(lView[${nodeOrIcuIndex}])`);
} else {
lines.push(`removeNestedICU(${~nodeOrIcuIndex})`);
}
}
return lines;
}
var OpCodeParser = class {
constructor(codes) {
this.i = 0;
this.codes = codes;
}
hasMore() {
return this.i < this.codes.length;
}
consumeNumber() {
let value2 = this.codes[this.i++];
assertNumber(value2, "expecting number in OpCode");
return value2;
}
consumeString() {
let value2 = this.codes[this.i++];
assertString(value2, "expecting string in OpCode");
return value2;
}
consumeFunction() {
let value2 = this.codes[this.i++];
if (value2 === null || typeof value2 === "function") {
return value2;
}
throw new Error("expecting function in OpCode");
}
consumeNumberOrString() {
let value2 = this.codes[this.i++];
if (typeof value2 === "string") {
return value2;
}
assertNumber(value2, "expecting number or string in OpCode");
return value2;
}
consumeNumberStringOrMarker() {
let value2 = this.codes[this.i++];
if (typeof value2 === "string" || typeof value2 === "number" || value2 == ICU_MARKER || value2 == ELEMENT_MARKER) {
return value2;
}
assertNumber(value2, "expecting number, string, ICU_MARKER or ELEMENT_MARKER in OpCode");
return value2;
}
};
var BINDING_REGEXP = /�(\d+):?\d*�/gi;
var ICU_REGEXP = /({\s*�\d+:?\d*�\s*,\s*\S{6}\s*,[\s\S]*})/gi;
var NESTED_ICU = /�(\d+)�/;
var ICU_BLOCK_REGEXP = /^\s*(�\d+:?\d*�)\s*,\s*(select|plural)\s*,/;
var MARKER = `\uFFFD`;
var SUBTEMPLATE_REGEXP = /�\/?\*(\d+:\d+)�/gi;
var PH_REGEXP = /�(\/?[#*]\d+):?\d*�/gi;
var NGSP_UNICODE_REGEXP = /\uE500/g;
function replaceNgsp(value2) {
return value2.replace(NGSP_UNICODE_REGEXP, " ");
}
function attachDebugGetter(obj, debugGetter) {
if (ngDevMode) {
Object.defineProperty(obj, "debug", { get: debugGetter, enumerable: false });
} else {
throw new Error("This method should be guarded with `ngDevMode` so that it can be tree shaken in production!");
}
}
function i18nStartFirstCreatePass(tView, parentTNodeIndex, lView, index2, message, subTemplateIndex) {
const rootTNode = getCurrentParentTNode();
const createOpCodes = [];
const updateOpCodes = [];
const existingTNodeStack = [[]];
const astStack = [[]];
if (ngDevMode) {
attachDebugGetter(createOpCodes, i18nCreateOpCodesToString);
attachDebugGetter(updateOpCodes, i18nUpdateOpCodesToString);
}
message = getTranslationForTemplate(message, subTemplateIndex);
const msgParts = replaceNgsp(message).split(PH_REGEXP);
for (let i = 0; i < msgParts.length; i++) {
let value2 = msgParts[i];
if ((i & 1) === 0) {
const parts = i18nParseTextIntoPartsAndICU(value2);
for (let j = 0; j < parts.length; j++) {
let part = parts[j];
if ((j & 1) === 0) {
const text2 = part;
ngDevMode && assertString(text2, "Parsed ICU part should be string");
if (text2 !== "") {
i18nStartFirstCreatePassProcessTextNode(astStack[0], tView, rootTNode, existingTNodeStack[0], createOpCodes, updateOpCodes, lView, text2);
}
} else {
const icuExpression = part;
if (typeof icuExpression !== "object") {
throw new Error(`Unable to parse ICU expression in "${message}" message.`);
}
const icuContainerTNode = createTNodeAndAddOpCode(tView, rootTNode, existingTNodeStack[0], lView, createOpCodes, ngDevMode ? `ICU ${index2}:${icuExpression.mainBinding}` : "", true);
const icuNodeIndex = icuContainerTNode.index;
ngDevMode && assertGreaterThanOrEqual(icuNodeIndex, HEADER_OFFSET, "Index must be in absolute LView offset");
icuStart(astStack[0], tView, lView, updateOpCodes, parentTNodeIndex, icuExpression, icuNodeIndex);
}
}
} else {
const isClosing = value2.charCodeAt(0) === 47;
const type = value2.charCodeAt(isClosing ? 1 : 0);
ngDevMode && assertOneOf(
type,
42,
35
/* CharCode.HASH */
);
const index3 = HEADER_OFFSET + Number.parseInt(value2.substring(isClosing ? 2 : 1));
if (isClosing) {
existingTNodeStack.shift();
astStack.shift();
setCurrentTNode(getCurrentParentTNode(), false);
} else {
const tNode = createTNodePlaceholder(tView, existingTNodeStack[0], index3);
existingTNodeStack.unshift([]);
setCurrentTNode(tNode, true);
const placeholderNode = {
kind: 2,
index: index3,
children: [],
type: type === 35 ? 0 : 1
};
astStack[0].push(placeholderNode);
astStack.unshift(placeholderNode.children);
}
}
}
tView.data[index2] = {
create: createOpCodes,
update: updateOpCodes,
ast: astStack[0]
};
}
function createTNodeAndAddOpCode(tView, rootTNode, existingTNodes, lView, createOpCodes, text2, isICU) {
const i18nNodeIdx = allocExpando(tView, lView, 1, null);
let opCode = i18nNodeIdx << I18nCreateOpCode.SHIFT;
let parentTNode = getCurrentParentTNode();
if (rootTNode === parentTNode) {
parentTNode = null;
}
if (parentTNode === null) {
opCode |= I18nCreateOpCode.APPEND_EAGERLY;
}
if (isICU) {
opCode |= I18nCreateOpCode.COMMENT;
ensureIcuContainerVisitorLoaded(loadIcuContainerVisitor);
}
createOpCodes.push(opCode, text2 === null ? "" : text2);
const tNode = createTNodeAtIndex(tView, i18nNodeIdx, isICU ? 32 : 1, text2 === null ? ngDevMode ? "{{?}}" : "" : text2, null);
addTNodeAndUpdateInsertBeforeIndex(existingTNodes, tNode);
const tNodeIdx = tNode.index;
setCurrentTNode(
tNode,
false
/* Text nodes are self closing */
);
if (parentTNode !== null && rootTNode !== parentTNode) {
setTNodeInsertBeforeIndex(parentTNode, tNodeIdx);
}
return tNode;
}
function i18nStartFirstCreatePassProcessTextNode(ast, tView, rootTNode, existingTNodes, createOpCodes, updateOpCodes, lView, text2) {
const hasBinding = text2.match(BINDING_REGEXP);
const tNode = createTNodeAndAddOpCode(tView, rootTNode, existingTNodes, lView, createOpCodes, hasBinding ? null : text2, false);
const index2 = tNode.index;
if (hasBinding) {
generateBindingUpdateOpCodes(updateOpCodes, text2, index2, null, 0, null);
}
ast.push({ kind: 0, index: index2 });
}
function i18nAttributesFirstPass(tView, index2, values) {
const previousElement = getCurrentTNode();
const previousElementIndex = previousElement.index;
const updateOpCodes = [];
if (ngDevMode) {
attachDebugGetter(updateOpCodes, i18nUpdateOpCodesToString);
}
if (tView.firstCreatePass && tView.data[index2] === null) {
for (let i = 0; i < values.length; i += 2) {
const attrName = values[i];
const message = values[i + 1];
if (message !== "") {
if (ICU_REGEXP.test(message)) {
throw new Error(`ICU expressions are not supported in attributes. Message: "${message}".`);
}
generateBindingUpdateOpCodes(updateOpCodes, message, previousElementIndex, attrName, countBindings(updateOpCodes), null);
}
}
tView.data[index2] = updateOpCodes;
}
}
function generateBindingUpdateOpCodes(updateOpCodes, str, destinationNode, attrName, bindingStart, sanitizeFn) {
ngDevMode && assertGreaterThanOrEqual(destinationNode, HEADER_OFFSET, "Index must be in absolute LView offset");
const maskIndex = updateOpCodes.length;
const sizeIndex = maskIndex + 1;
updateOpCodes.push(null, null);
const startIndex = maskIndex + 2;
if (ngDevMode) {
attachDebugGetter(updateOpCodes, i18nUpdateOpCodesToString);
}
const textParts = str.split(BINDING_REGEXP);
let mask2 = 0;
for (let j = 0; j < textParts.length; j++) {
const textValue = textParts[j];
if (j & 1) {
const bindingIndex = bindingStart + parseInt(textValue, 10);
updateOpCodes.push(-1 - bindingIndex);
mask2 = mask2 | toMaskBit(bindingIndex);
} else if (textValue !== "") {
updateOpCodes.push(textValue);
}
}
updateOpCodes.push(destinationNode << 2 | (attrName ? 1 : 0));
if (attrName) {
updateOpCodes.push(attrName, sanitizeFn);
}
updateOpCodes[maskIndex] = mask2;
updateOpCodes[sizeIndex] = updateOpCodes.length - startIndex;
return mask2;
}
function countBindings(opCodes) {
let count = 0;
for (let i = 0; i < opCodes.length; i++) {
const opCode = opCodes[i];
if (typeof opCode === "number" && opCode < 0) {
count++;
}
}
return count;
}
function toMaskBit(bindingIndex) {
return 1 << Math.min(bindingIndex, 31);
}
function isRootTemplateMessage(subTemplateIndex) {
return subTemplateIndex === -1;
}
function removeInnerTemplateTranslation(message) {
let match2;
let res = "";
let index2 = 0;
let inTemplate = false;
let tagMatched;
while ((match2 = SUBTEMPLATE_REGEXP.exec(message)) !== null) {
if (!inTemplate) {
res += message.substring(index2, match2.index + match2[0].length);
tagMatched = match2[1];
inTemplate = true;
} else {
if (match2[0] === `${MARKER}/*${tagMatched}${MARKER}`) {
index2 = match2.index;
inTemplate = false;
}
}
}
ngDevMode && assertEqual(inTemplate, false, `Tag mismatch: unable to find the end of the sub-template in the translation "${message}"`);
res += message.slice(index2);
return res;
}
function getTranslationForTemplate(message, subTemplateIndex) {
if (isRootTemplateMessage(subTemplateIndex)) {
return removeInnerTemplateTranslation(message);
} else {
const start = message.indexOf(`:${subTemplateIndex}${MARKER}`) + 2 + subTemplateIndex.toString().length;
const end = message.search(new RegExp(`${MARKER}\\/\\*\\d+:${subTemplateIndex}${MARKER}`));
return removeInnerTemplateTranslation(message.substring(start, end));
}
}
function icuStart(ast, tView, lView, updateOpCodes, parentIdx, icuExpression, anchorIdx) {
ngDevMode && assertDefined(icuExpression, "ICU expression must be defined");
let bindingMask = 0;
const tIcu = {
type: icuExpression.type,
currentCaseLViewIndex: allocExpando(tView, lView, 1, null),
anchorIdx,
cases: [],
create: [],
remove: [],
update: []
};
addUpdateIcuSwitch(updateOpCodes, icuExpression, anchorIdx);
setTIcu(tView, anchorIdx, tIcu);
const values = icuExpression.values;
const cases = [];
for (let i = 0; i < values.length; i++) {
const valueArr = values[i];
const nestedIcus = [];
for (let j = 0; j < valueArr.length; j++) {
const value2 = valueArr[j];
if (typeof value2 !== "string") {
const icuIndex = nestedIcus.push(value2) - 1;
valueArr[j] = `<!--\uFFFD${icuIndex}\uFFFD-->`;
}
}
const caseAst = [];
cases.push(caseAst);
bindingMask = parseIcuCase(caseAst, tView, tIcu, lView, updateOpCodes, parentIdx, icuExpression.cases[i], valueArr.join(""), nestedIcus) | bindingMask;
}
if (bindingMask) {
addUpdateIcuUpdate(updateOpCodes, bindingMask, anchorIdx);
}
ast.push({
kind: 3,
index: anchorIdx,
cases,
currentCaseLViewIndex: tIcu.currentCaseLViewIndex
});
}
function parseICUBlock(pattern) {
const cases = [];
const values = [];
let icuType = 1;
let mainBinding = 0;
pattern = pattern.replace(ICU_BLOCK_REGEXP, function(str, binding, type) {
if (type === "select") {
icuType = 0;
} else {
icuType = 1;
}
mainBinding = parseInt(binding.slice(1), 10);
return "";
});
const parts = i18nParseTextIntoPartsAndICU(pattern);
for (let pos = 0; pos < parts.length; ) {
let key2 = parts[pos++].trim();
if (icuType === 1) {
key2 = key2.replace(/\s*(?:=)?(\w+)\s*/, "$1");
}
if (key2.length) {
cases.push(key2);
}
const blocks = i18nParseTextIntoPartsAndICU(parts[pos++]);
if (cases.length > values.length) {
values.push(blocks);
}
}
return { type: icuType, mainBinding, cases, values };
}
function i18nParseTextIntoPartsAndICU(pattern) {
if (!pattern) {
return [];
}
let prevPos = 0;
const braceStack = [];
const results = [];
const braces = /[{}]/g;
braces.lastIndex = 0;
let match2;
while (match2 = braces.exec(pattern)) {
const pos = match2.index;
if (match2[0] == "}") {
braceStack.pop();
if (braceStack.length == 0) {
const block = pattern.substring(prevPos, pos);
if (ICU_BLOCK_REGEXP.test(block)) {
results.push(parseICUBlock(block));
} else {
results.push(block);
}
prevPos = pos + 1;
}
} else {
if (braceStack.length == 0) {
const substring3 = pattern.substring(prevPos, pos);
results.push(substring3);
prevPos = pos + 1;
}
braceStack.push("{");
}
}
const substring2 = pattern.substring(prevPos);
results.push(substring2);
return results;
}
function parseIcuCase(ast, tView, tIcu, lView, updateOpCodes, parentIdx, caseName, unsafeCaseHtml, nestedIcus) {
const create = [];
const remove2 = [];
const update = [];
if (ngDevMode) {
attachDebugGetter(create, icuCreateOpCodesToString);
attachDebugGetter(remove2, i18nRemoveOpCodesToString);
attachDebugGetter(update, i18nUpdateOpCodesToString);
}
tIcu.cases.push(caseName);
tIcu.create.push(create);
tIcu.remove.push(remove2);
tIcu.update.push(update);
const inertBodyHelper2 = getInertBodyHelper(getDocument());
const inertBodyElement = inertBodyHelper2.getInertBodyElement(unsafeCaseHtml);
ngDevMode && assertDefined(inertBodyElement, "Unable to generate inert body element");
const inertRootNode = getTemplateContent(inertBodyElement) || inertBodyElement;
if (inertRootNode) {
return walkIcuTree(ast, tView, tIcu, lView, updateOpCodes, create, remove2, update, inertRootNode, parentIdx, nestedIcus, 0);
} else {
return 0;
}
}
function walkIcuTree(ast, tView, tIcu, lView, sharedUpdateOpCodes, create, remove2, update, parentNode, parentIdx, nestedIcus, depth) {
let bindingMask = 0;
let currentNode = parentNode.firstChild;
while (currentNode) {
const newIndex = allocExpando(tView, lView, 1, null);
switch (currentNode.nodeType) {
case Node.ELEMENT_NODE:
const element = currentNode;
const tagName = element.tagName.toLowerCase();
if (VALID_ELEMENTS.hasOwnProperty(tagName)) {
addCreateNodeAndAppend(create, ELEMENT_MARKER, tagName, parentIdx, newIndex);
tView.data[newIndex] = tagName;
const elAttrs = element.attributes;
for (let i = 0; i < elAttrs.length; i++) {
const attr = elAttrs.item(i);
const lowerAttrName = attr.name.toLowerCase();
const hasBinding2 = !!attr.value.match(BINDING_REGEXP);
if (hasBinding2) {
if (VALID_ATTRS.hasOwnProperty(lowerAttrName)) {
if (URI_ATTRS[lowerAttrName]) {
generateBindingUpdateOpCodes(update, attr.value, newIndex, attr.name, 0, _sanitizeUrl);
} else {
generateBindingUpdateOpCodes(update, attr.value, newIndex, attr.name, 0, null);
}
} else {
ngDevMode && console.warn(`WARNING: ignoring unsafe attribute value ${lowerAttrName} on element ${tagName} (see ${XSS_SECURITY_URL})`);
}
} else {
addCreateAttribute(create, newIndex, attr);
}
}
const elementNode = {
kind: 1,
index: newIndex,
children: []
};
ast.push(elementNode);
bindingMask = walkIcuTree(elementNode.children, tView, tIcu, lView, sharedUpdateOpCodes, create, remove2, update, currentNode, newIndex, nestedIcus, depth + 1) | bindingMask;
addRemoveNode(remove2, newIndex, depth);
}
break;
case Node.TEXT_NODE:
const value2 = currentNode.textContent || "";
const hasBinding = value2.match(BINDING_REGEXP);
addCreateNodeAndAppend(create, null, hasBinding ? "" : value2, parentIdx, newIndex);
addRemoveNode(remove2, newIndex, depth);
if (hasBinding) {
bindingMask = generateBindingUpdateOpCodes(update, value2, newIndex, null, 0, null) | bindingMask;
}
ast.push({
kind: 0,
index: newIndex
});
break;
case Node.COMMENT_NODE:
const isNestedIcu = NESTED_ICU.exec(currentNode.textContent || "");
if (isNestedIcu) {
const nestedIcuIndex = parseInt(isNestedIcu[1], 10);
const icuExpression = nestedIcus[nestedIcuIndex];
addCreateNodeAndAppend(create, ICU_MARKER, ngDevMode ? `nested ICU ${nestedIcuIndex}` : "", parentIdx, newIndex);
icuStart(ast, tView, lView, sharedUpdateOpCodes, parentIdx, icuExpression, newIndex);
addRemoveNestedIcu(remove2, newIndex, depth);
}
break;
}
currentNode = currentNode.nextSibling;
}
return bindingMask;
}
function addRemoveNode(remove2, index2, depth) {
if (depth === 0) {
remove2.push(index2);
}
}
function addRemoveNestedIcu(remove2, index2, depth) {
if (depth === 0) {
remove2.push(~index2);
remove2.push(index2);
}
}
function addUpdateIcuSwitch(update, icuExpression, index2) {
update.push(
toMaskBit(icuExpression.mainBinding),
2,
-1 - icuExpression.mainBinding,
index2 << 2 | 2
/* I18nUpdateOpCode.IcuSwitch */
);
}
function addUpdateIcuUpdate(update, bindingMask, index2) {
update.push(
bindingMask,
1,
index2 << 2 | 3
/* I18nUpdateOpCode.IcuUpdate */
);
}
function addCreateNodeAndAppend(create, marker, text2, appendToParentIdx, createAtIdx) {
if (marker !== null) {
create.push(marker);
}
create.push(text2, createAtIdx, icuCreateOpCode(0, appendToParentIdx, createAtIdx));
}
function addCreateAttribute(create, newIndex, attr) {
create.push(newIndex << 1 | 1, attr.name, attr.value);
}
var ROOT_TEMPLATE_ID = 0;
var PP_MULTI_VALUE_PLACEHOLDERS_REGEXP = /\[(�.+?�?)\]/;
var PP_PLACEHOLDERS_REGEXP = /\[(�.+?�?)\]|(�\/?\*\d+:\d+�)/g;
var PP_ICU_VARS_REGEXP = /({\s*)(VAR_(PLURAL|SELECT)(_\d+)?)(\s*,)/g;
var PP_ICU_PLACEHOLDERS_REGEXP = /{([A-Z0-9_]+)}/g;
var PP_ICUS_REGEXP = /�I18N_EXP_(ICU(_\d+)?)�/g;
var PP_CLOSE_TEMPLATE_REGEXP = /\/\*/;
var PP_TEMPLATE_ID_REGEXP = /\d+\:(\d+)/;
function i18nPostprocess(message, replacements = {}) {
let result = message;
if (PP_MULTI_VALUE_PLACEHOLDERS_REGEXP.test(message)) {
const matches = {};
const templateIdsStack = [ROOT_TEMPLATE_ID];
result = result.replace(PP_PLACEHOLDERS_REGEXP, (m, phs, tmpl) => {
const content2 = phs || tmpl;
const placeholders = matches[content2] || [];
if (!placeholders.length) {
content2.split("|").forEach((placeholder2) => {
const match2 = placeholder2.match(PP_TEMPLATE_ID_REGEXP);
const templateId2 = match2 ? parseInt(match2[1], 10) : ROOT_TEMPLATE_ID;
const isCloseTemplateTag2 = PP_CLOSE_TEMPLATE_REGEXP.test(placeholder2);
placeholders.push([templateId2, isCloseTemplateTag2, placeholder2]);
});
matches[content2] = placeholders;
}
if (!placeholders.length) {
throw new Error(`i18n postprocess: unmatched placeholder - ${content2}`);
}
const currentTemplateId = templateIdsStack[templateIdsStack.length - 1];
let idx = 0;
for (let i = 0; i < placeholders.length; i++) {
if (placeholders[i][0] === currentTemplateId) {
idx = i;
break;
}
}
const [templateId, isCloseTemplateTag, placeholder] = placeholders[idx];
if (isCloseTemplateTag) {
templateIdsStack.pop();
} else if (currentTemplateId !== templateId) {
templateIdsStack.push(templateId);
}
placeholders.splice(idx, 1);
return placeholder;
});
}
if (!Object.keys(replacements).length) {
return result;
}
result = result.replace(PP_ICU_VARS_REGEXP, (match2, start, key2, _type, _idx, end) => {
return replacements.hasOwnProperty(key2) ? `${start}${replacements[key2]}${end}` : match2;
});
result = result.replace(PP_ICU_PLACEHOLDERS_REGEXP, (match2, key2) => {
return replacements.hasOwnProperty(key2) ? replacements[key2] : match2;
});
result = result.replace(PP_ICUS_REGEXP, (match2, key2) => {
if (replacements.hasOwnProperty(key2)) {
const list = replacements[key2];
if (!list.length) {
throw new Error(`i18n postprocess: unmatched ICU - ${match2} with key: ${key2}`);
}
return list.shift();
}
return match2;
});
return result;
}
function \u0275\u0275i18nStart(index2, messageIndex, subTemplateIndex = -1) {
const tView = getTView();
const lView = getLView();
const adjustedIndex = HEADER_OFFSET + index2;
ngDevMode && assertDefined(tView, `tView should be defined`);
const message = getConstant(tView.consts, messageIndex);
const parentTNode = getCurrentParentTNode();
if (tView.firstCreatePass) {
i18nStartFirstCreatePass(tView, parentTNode === null ? 0 : parentTNode.index, lView, adjustedIndex, message, subTemplateIndex);
}
if (tView.type === 2) {
const componentLView = lView[DECLARATION_COMPONENT_VIEW];
componentLView[FLAGS] |= 32;
} else {
lView[FLAGS] |= 32;
}
const tI18n = tView.data[adjustedIndex];
const sameViewParentTNode = parentTNode === lView[T_HOST] ? null : parentTNode;
const parentRNode = getClosestRElement(tView, sameViewParentTNode, lView);
const insertInFrontOf = parentTNode && parentTNode.type & 8 ? lView[parentTNode.index] : null;
applyCreateOpCodes(lView, tI18n.create, parentRNode, insertInFrontOf);
setInI18nBlock(true);
}
function \u0275\u0275i18nEnd() {
setInI18nBlock(false);
}
function \u0275\u0275i18n(index2, messageIndex, subTemplateIndex) {
\u0275\u0275i18nStart(index2, messageIndex, subTemplateIndex);
\u0275\u0275i18nEnd();
}
function \u0275\u0275i18nAttributes(index2, attrsIndex) {
const tView = getTView();
ngDevMode && assertDefined(tView, `tView should be defined`);
const attrs = getConstant(tView.consts, attrsIndex);
i18nAttributesFirstPass(tView, index2 + HEADER_OFFSET, attrs);
}
function \u0275\u0275i18nExp(value2) {
const lView = getLView();
setMaskBit(bindingUpdated(lView, nextBindingIndex(), value2));
return \u0275\u0275i18nExp;
}
function \u0275\u0275i18nApply(index2) {
applyI18n(getTView(), getLView(), index2 + HEADER_OFFSET);
}
function \u0275\u0275i18nPostprocess(message, replacements = {}) {
return i18nPostprocess(message, replacements);
}
function \u0275\u0275listener(eventName, listenerFn, useCapture, eventTargetResolver) {
const lView = getLView();
const tView = getTView();
const tNode = getCurrentTNode();
listenerInternal(tView, lView, lView[RENDERER], tNode, eventName, listenerFn, eventTargetResolver);
return \u0275\u0275listener;
}
function \u0275\u0275syntheticHostListener(eventName, listenerFn) {
const tNode = getCurrentTNode();
const lView = getLView();
const tView = getTView();
const currentDef = getCurrentDirectiveDef(tView.data);
const renderer2 = loadComponentRenderer(currentDef, tNode, lView);
listenerInternal(tView, lView, renderer2, tNode, eventName, listenerFn);
return \u0275\u0275syntheticHostListener;
}
function findExistingListener(tView, lView, eventName, tNodeIdx) {
const tCleanup = tView.cleanup;
if (tCleanup != null) {
for (let i = 0; i < tCleanup.length - 1; i += 2) {
const cleanupEventName = tCleanup[i];
if (cleanupEventName === eventName && tCleanup[i + 1] === tNodeIdx) {
const lCleanup = lView[CLEANUP];
const listenerIdxInLCleanup = tCleanup[i + 2];
return lCleanup.length > listenerIdxInLCleanup ? lCleanup[listenerIdxInLCleanup] : null;
}
if (typeof cleanupEventName === "string") {
i += 2;
}
}
}
return null;
}
function listenerInternal(tView, lView, renderer2, tNode, eventName, listenerFn, eventTargetResolver) {
const isTNodeDirectiveHost = isDirectiveHost(tNode);
const firstCreatePass = tView.firstCreatePass;
const tCleanup = firstCreatePass && getOrCreateTViewCleanup(tView);
const context2 = lView[CONTEXT];
const lCleanup = getOrCreateLViewCleanup(lView);
ngDevMode && assertTNodeType(
tNode,
3 | 12
/* TNodeType.AnyContainer */
);
let processOutputs = true;
if (tNode.type & 3 || eventTargetResolver) {
const native = getNativeByTNode(tNode, lView);
const target = eventTargetResolver ? eventTargetResolver(native) : native;
const lCleanupIndex = lCleanup.length;
const idxOrTargetGetter = eventTargetResolver ? (_lView) => eventTargetResolver(unwrapRNode(_lView[tNode.index])) : tNode.index;
let existingListener = null;
if (!eventTargetResolver && isTNodeDirectiveHost) {
existingListener = findExistingListener(tView, lView, eventName, tNode.index);
}
if (existingListener !== null) {
const lastListenerFn = existingListener.__ngLastListenerFn__ || existingListener;
lastListenerFn.__ngNextListenerFn__ = listenerFn;
existingListener.__ngLastListenerFn__ = listenerFn;
processOutputs = false;
} else {
listenerFn = wrapListener(
tNode,
lView,
context2,
listenerFn,
false
/** preventDefault */
);
const cleanupFn = renderer2.listen(target, eventName, listenerFn);
ngDevMode && ngDevMode.rendererAddEventListener++;
lCleanup.push(listenerFn, cleanupFn);
tCleanup && tCleanup.push(eventName, idxOrTargetGetter, lCleanupIndex, lCleanupIndex + 1);
}
} else {
listenerFn = wrapListener(
tNode,
lView,
context2,
listenerFn,
false
/** preventDefault */
);
}
const outputs = tNode.outputs;
let props;
if (processOutputs && outputs !== null && (props = outputs[eventName])) {
const propsLength = props.length;
if (propsLength) {
for (let i = 0; i < propsLength; i += 2) {
const index2 = props[i];
ngDevMode && assertIndexInRange(lView, index2);
const minifiedName = props[i + 1];
const directiveInstance = lView[index2];
const output = directiveInstance[minifiedName];
if (ngDevMode && !isOutputSubscribable(output)) {
throw new Error(`@Output ${minifiedName} not initialized in '${directiveInstance.constructor.name}'.`);
}
const subscription = output.subscribe(listenerFn);
const idx = lCleanup.length;
lCleanup.push(listenerFn, subscription);
tCleanup && tCleanup.push(eventName, tNode.index, idx, -(idx + 1));
}
}
}
}
function executeListenerWithErrorHandling(lView, context2, listenerFn, e) {
const prevConsumer = setActiveConsumer(null);
try {
profiler(6, context2, listenerFn);
return listenerFn(e) !== false;
} catch (error) {
handleError(lView, error);
return false;
} finally {
profiler(7, context2, listenerFn);
setActiveConsumer(prevConsumer);
}
}
function wrapListener(tNode, lView, context2, listenerFn, wrapWithPreventDefault) {
return function wrapListenerIn_markDirtyAndPreventDefault(e) {
if (e === Function) {
return listenerFn;
}
const startView = tNode.componentOffset > -1 ? getComponentLViewByIndex(tNode.index, lView) : lView;
markViewDirty(startView);
let result = executeListenerWithErrorHandling(lView, context2, listenerFn, e);
let nextListenerFn = wrapListenerIn_markDirtyAndPreventDefault.__ngNextListenerFn__;
while (nextListenerFn) {
result = executeListenerWithErrorHandling(lView, context2, nextListenerFn, e) && result;
nextListenerFn = nextListenerFn.__ngNextListenerFn__;
}
if (wrapWithPreventDefault && result === false) {
e.preventDefault();
}
return result;
};
}
function isOutputSubscribable(value2) {
return value2 != null && typeof value2.subscribe === "function";
}
function \u0275\u0275nextContext(level = 1) {
return nextContextImpl(level);
}
function matchingProjectionSlotIndex(tNode, projectionSlots) {
let wildcardNgContentIndex = null;
const ngProjectAsAttrVal = getProjectAsAttrValue(tNode);
for (let i = 0; i < projectionSlots.length; i++) {
const slotValue = projectionSlots[i];
if (slotValue === "*") {
wildcardNgContentIndex = i;
continue;
}
if (ngProjectAsAttrVal === null ? isNodeMatchingSelectorList(
tNode,
slotValue,
/* isProjectionMode */
true
) : isSelectorInSelectorList(ngProjectAsAttrVal, slotValue)) {
return i;
}
}
return wildcardNgContentIndex;
}
function \u0275\u0275projectionDef(projectionSlots) {
const componentNode = getLView()[DECLARATION_COMPONENT_VIEW][T_HOST];
if (!componentNode.projection) {
const numProjectionSlots = projectionSlots ? projectionSlots.length : 1;
const projectionHeads = componentNode.projection = newArray(numProjectionSlots, null);
const tails = projectionHeads.slice();
let componentChild = componentNode.child;
while (componentChild !== null) {
const slotIndex = projectionSlots ? matchingProjectionSlotIndex(componentChild, projectionSlots) : 0;
if (slotIndex !== null) {
if (tails[slotIndex]) {
tails[slotIndex].projectionNext = componentChild;
} else {
projectionHeads[slotIndex] = componentChild;
}
tails[slotIndex] = componentChild;
}
componentChild = componentChild.next;
}
}
}
function \u0275\u0275projection(nodeIndex, selectorIndex = 0, attrs) {
const lView = getLView();
const tView = getTView();
const tProjectionNode = getOrCreateTNode(tView, HEADER_OFFSET + nodeIndex, 16, null, attrs || null);
if (tProjectionNode.projection === null)
tProjectionNode.projection = selectorIndex;
setCurrentTNodeAsNotParent();
const hydrationInfo = lView[HYDRATION];
const isNodeCreationMode = !hydrationInfo || isInSkipHydrationBlock$1();
if (isNodeCreationMode && (tProjectionNode.flags & 32) !== 32) {
applyProjection(tView, lView, tProjectionNode);
}
}
function \u0275\u0275propertyInterpolate(propName, v0, sanitizer) {
\u0275\u0275propertyInterpolate1(propName, "", v0, "", sanitizer);
return \u0275\u0275propertyInterpolate;
}
function \u0275\u0275propertyInterpolate1(propName, prefix, v0, suffix, sanitizer) {
const lView = getLView();
const interpolatedValue = interpolation1(lView, prefix, v0, suffix);
if (interpolatedValue !== NO_CHANGE) {
const tView = getTView();
const tNode = getSelectedTNode();
elementPropertyInternal(tView, tNode, lView, propName, interpolatedValue, lView[RENDERER], sanitizer, false);
ngDevMode && storePropertyBindingMetadata(tView.data, tNode, propName, getBindingIndex() - 1, prefix, suffix);
}
return \u0275\u0275propertyInterpolate1;
}
function \u0275\u0275propertyInterpolate2(propName, prefix, v0, i0, v1, suffix, sanitizer) {
const lView = getLView();
const interpolatedValue = interpolation2(lView, prefix, v0, i0, v1, suffix);
if (interpolatedValue !== NO_CHANGE) {
const tView = getTView();
const tNode = getSelectedTNode();
elementPropertyInternal(tView, tNode, lView, propName, interpolatedValue, lView[RENDERER], sanitizer, false);
ngDevMode && storePropertyBindingMetadata(tView.data, tNode, propName, getBindingIndex() - 2, prefix, i0, suffix);
}
return \u0275\u0275propertyInterpolate2;
}
function \u0275\u0275propertyInterpolate3(propName, prefix, v0, i0, v1, i1, v2, suffix, sanitizer) {
const lView = getLView();
const interpolatedValue = interpolation3(lView, prefix, v0, i0, v1, i1, v2, suffix);
if (interpolatedValue !== NO_CHANGE) {
const tView = getTView();
const tNode = getSelectedTNode();
elementPropertyInternal(tView, tNode, lView, propName, interpolatedValue, lView[RENDERER], sanitizer, false);
ngDevMode && storePropertyBindingMetadata(tView.data, tNode, propName, getBindingIndex() - 3, prefix, i0, i1, suffix);
}
return \u0275\u0275propertyInterpolate3;
}
function \u0275\u0275propertyInterpolate4(propName, prefix, v0, i0, v1, i1, v2, i2, v3, suffix, sanitizer) {
const lView = getLView();
const interpolatedValue = interpolation4(lView, prefix, v0, i0, v1, i1, v2, i2, v3, suffix);
if (interpolatedValue !== NO_CHANGE) {
const tView = getTView();
const tNode = getSelectedTNode();
elementPropertyInternal(tView, tNode, lView, propName, interpolatedValue, lView[RENDERER], sanitizer, false);
ngDevMode && storePropertyBindingMetadata(tView.data, tNode, propName, getBindingIndex() - 4, prefix, i0, i1, i2, suffix);
}
return \u0275\u0275propertyInterpolate4;
}
function \u0275\u0275propertyInterpolate5(propName, prefix, v0, i0, v1, i1, v2, i2, v3, i3, v42, suffix, sanitizer) {
const lView = getLView();
const interpolatedValue = interpolation5(lView, prefix, v0, i0, v1, i1, v2, i2, v3, i3, v42, suffix);
if (interpolatedValue !== NO_CHANGE) {
const tView = getTView();
const tNode = getSelectedTNode();
elementPropertyInternal(tView, tNode, lView, propName, interpolatedValue, lView[RENDERER], sanitizer, false);
ngDevMode && storePropertyBindingMetadata(tView.data, tNode, propName, getBindingIndex() - 5, prefix, i0, i1, i2, i3, suffix);
}
return \u0275\u0275propertyInterpolate5;
}
function \u0275\u0275propertyInterpolate6(propName, prefix, v0, i0, v1, i1, v2, i2, v3, i3, v42, i4, v5, suffix, sanitizer) {
const lView = getLView();
const interpolatedValue = interpolation6(lView, prefix, v0, i0, v1, i1, v2, i2, v3, i3, v42, i4, v5, suffix);
if (interpolatedValue !== NO_CHANGE) {
const tView = getTView();
const tNode = getSelectedTNode();
elementPropertyInternal(tView, tNode, lView, propName, interpolatedValue, lView[RENDERER], sanitizer, false);
ngDevMode && storePropertyBindingMetadata(tView.data, tNode, propName, getBindingIndex() - 6, prefix, i0, i1, i2, i3, i4, suffix);
}
return \u0275\u0275propertyInterpolate6;
}
function \u0275\u0275propertyInterpolate7(propName, prefix, v0, i0, v1, i1, v2, i2, v3, i3, v42, i4, v5, i5, v6, suffix, sanitizer) {
const lView = getLView();
const interpolatedValue = interpolation7(lView, prefix, v0, i0, v1, i1, v2, i2, v3, i3, v42, i4, v5, i5, v6, suffix);
if (interpolatedValue !== NO_CHANGE) {
const tView = getTView();
const tNode = getSelectedTNode();
elementPropertyInternal(tView, tNode, lView, propName, interpolatedValue, lView[RENDERER], sanitizer, false);
ngDevMode && storePropertyBindingMetadata(tView.data, tNode, propName, getBindingIndex() - 7, prefix, i0, i1, i2, i3, i4, i5, suffix);
}
return \u0275\u0275propertyInterpolate7;
}
function \u0275\u0275propertyInterpolate8(propName, prefix, v0, i0, v1, i1, v2, i2, v3, i3, v42, i4, v5, i5, v6, i6, v7, suffix, sanitizer) {
const lView = getLView();
const interpolatedValue = interpolation8(lView, prefix, v0, i0, v1, i1, v2, i2, v3, i3, v42, i4, v5, i5, v6, i6, v7, suffix);
if (interpolatedValue !== NO_CHANGE) {
const tView = getTView();
const tNode = getSelectedTNode();
elementPropertyInternal(tView, tNode, lView, propName, interpolatedValue, lView[RENDERER], sanitizer, false);
ngDevMode && storePropertyBindingMetadata(tView.data, tNode, propName, getBindingIndex() - 8, prefix, i0, i1, i2, i3, i4, i5, i6, suffix);
}
return \u0275\u0275propertyInterpolate8;
}
function \u0275\u0275propertyInterpolateV(propName, values, sanitizer) {
const lView = getLView();
const interpolatedValue = interpolationV(lView, values);
if (interpolatedValue !== NO_CHANGE) {
const tView = getTView();
const tNode = getSelectedTNode();
elementPropertyInternal(tView, tNode, lView, propName, interpolatedValue, lView[RENDERER], sanitizer, false);
if (ngDevMode) {
const interpolationInBetween = [values[0]];
for (let i = 2; i < values.length; i += 2) {
interpolationInBetween.push(values[i]);
}
storePropertyBindingMetadata(tView.data, tNode, propName, getBindingIndex() - interpolationInBetween.length + 1, ...interpolationInBetween);
}
}
return \u0275\u0275propertyInterpolateV;
}
function \u0275\u0275contentQuery(directiveIndex, predicate, flags, read) {
createContentQuery(directiveIndex, predicate, flags, read);
}
function \u0275\u0275viewQuery(predicate, flags, read) {
createViewQuery(predicate, flags, read);
}
function \u0275\u0275queryRefresh(queryList) {
const lView = getLView();
const tView = getTView();
const queryIndex = getCurrentQueryIndex();
setCurrentQueryIndex(queryIndex + 1);
const tQuery = getTQuery(tView, queryIndex);
if (queryList.dirty && isCreationMode(lView) === ((tQuery.metadata.flags & 2) === 2)) {
if (tQuery.matches === null) {
queryList.reset([]);
} else {
const result = getQueryResults(lView, queryIndex);
queryList.reset(result, unwrapElementRef);
queryList.notifyOnChanges();
}
return true;
}
return false;
}
function \u0275\u0275loadQuery() {
return loadQueryInternal(getLView(), getCurrentQueryIndex());
}
function \u0275\u0275contentQuerySignal(directiveIndex, target, predicate, flags, read) {
bindQueryToSignal(target, createContentQuery(directiveIndex, predicate, flags, read));
}
function \u0275\u0275viewQuerySignal(target, predicate, flags, read) {
bindQueryToSignal(target, createViewQuery(predicate, flags, read));
}
function \u0275\u0275queryAdvance(indexOffset = 1) {
setCurrentQueryIndex(getCurrentQueryIndex() + indexOffset);
}
function store(tView, lView, index2, value2) {
if (index2 >= tView.data.length) {
tView.data[index2] = null;
tView.blueprint[index2] = null;
}
lView[index2] = value2;
}
function \u0275\u0275reference(index2) {
const contextLView = getContextLView();
return load(contextLView, HEADER_OFFSET + index2);
}
function \u0275\u0275styleMapInterpolate1(prefix, v0, suffix) {
const lView = getLView();
const interpolatedValue = interpolation1(lView, prefix, v0, suffix);
\u0275\u0275styleMap(interpolatedValue);
}
function \u0275\u0275styleMapInterpolate2(prefix, v0, i0, v1, suffix) {
const lView = getLView();
const interpolatedValue = interpolation2(lView, prefix, v0, i0, v1, suffix);
\u0275\u0275styleMap(interpolatedValue);
}
function \u0275\u0275styleMapInterpolate3(prefix, v0, i0, v1, i1, v2, suffix) {
const lView = getLView();
const interpolatedValue = interpolation3(lView, prefix, v0, i0, v1, i1, v2, suffix);
\u0275\u0275styleMap(interpolatedValue);
}
function \u0275\u0275styleMapInterpolate4(prefix, v0, i0, v1, i1, v2, i2, v3, suffix) {
const lView = getLView();
const interpolatedValue = interpolation4(lView, prefix, v0, i0, v1, i1, v2, i2, v3, suffix);
\u0275\u0275styleMap(interpolatedValue);
}
function \u0275\u0275styleMapInterpolate5(prefix, v0, i0, v1, i1, v2, i2, v3, i3, v42, suffix) {
const lView = getLView();
const interpolatedValue = interpolation5(lView, prefix, v0, i0, v1, i1, v2, i2, v3, i3, v42, suffix);
\u0275\u0275styleMap(interpolatedValue);
}
function \u0275\u0275styleMapInterpolate6(prefix, v0, i0, v1, i1, v2, i2, v3, i3, v42, i4, v5, suffix) {
const lView = getLView();
const interpolatedValue = interpolation6(lView, prefix, v0, i0, v1, i1, v2, i2, v3, i3, v42, i4, v5, suffix);
\u0275\u0275styleMap(interpolatedValue);
}
function \u0275\u0275styleMapInterpolate7(prefix, v0, i0, v1, i1, v2, i2, v3, i3, v42, i4, v5, i5, v6, suffix) {
const lView = getLView();
const interpolatedValue = interpolation7(lView, prefix, v0, i0, v1, i1, v2, i2, v3, i3, v42, i4, v5, i5, v6, suffix);
\u0275\u0275styleMap(interpolatedValue);
}
function \u0275\u0275styleMapInterpolate8(prefix, v0, i0, v1, i1, v2, i2, v3, i3, v42, i4, v5, i5, v6, i6, v7, suffix) {
const lView = getLView();
const interpolatedValue = interpolation8(lView, prefix, v0, i0, v1, i1, v2, i2, v3, i3, v42, i4, v5, i5, v6, i6, v7, suffix);
\u0275\u0275styleMap(interpolatedValue);
}
function \u0275\u0275styleMapInterpolateV(values) {
const lView = getLView();
const interpolatedValue = interpolationV(lView, values);
\u0275\u0275styleMap(interpolatedValue);
}
function \u0275\u0275stylePropInterpolate1(prop, prefix, v0, suffix, valueSuffix) {
const lView = getLView();
const interpolatedValue = interpolation1(lView, prefix, v0, suffix);
checkStylingProperty(prop, interpolatedValue, valueSuffix, false);
return \u0275\u0275stylePropInterpolate1;
}
function \u0275\u0275stylePropInterpolate2(prop, prefix, v0, i0, v1, suffix, valueSuffix) {
const lView = getLView();
const interpolatedValue = interpolation2(lView, prefix, v0, i0, v1, suffix);
checkStylingProperty(prop, interpolatedValue, valueSuffix, false);
return \u0275\u0275stylePropInterpolate2;
}
function \u0275\u0275stylePropInterpolate3(prop, prefix, v0, i0, v1, i1, v2, suffix, valueSuffix) {
const lView = getLView();
const interpolatedValue = interpolation3(lView, prefix, v0, i0, v1, i1, v2, suffix);
checkStylingProperty(prop, interpolatedValue, valueSuffix, false);
return \u0275\u0275stylePropInterpolate3;
}
function \u0275\u0275stylePropInterpolate4(prop, prefix, v0, i0, v1, i1, v2, i2, v3, suffix, valueSuffix) {
const lView = getLView();
const interpolatedValue = interpolation4(lView, prefix, v0, i0, v1, i1, v2, i2, v3, suffix);
checkStylingProperty(prop, interpolatedValue, valueSuffix, false);
return \u0275\u0275stylePropInterpolate4;
}
function \u0275\u0275stylePropInterpolate5(prop, prefix, v0, i0, v1, i1, v2, i2, v3, i3, v42, suffix, valueSuffix) {
const lView = getLView();
const interpolatedValue = interpolation5(lView, prefix, v0, i0, v1, i1, v2, i2, v3, i3, v42, suffix);
checkStylingProperty(prop, interpolatedValue, valueSuffix, false);
return \u0275\u0275stylePropInterpolate5;
}
function \u0275\u0275stylePropInterpolate6(prop, prefix, v0, i0, v1, i1, v2, i2, v3, i3, v42, i4, v5, suffix, valueSuffix) {
const lView = getLView();
const interpolatedValue = interpolation6(lView, prefix, v0, i0, v1, i1, v2, i2, v3, i3, v42, i4, v5, suffix);
checkStylingProperty(prop, interpolatedValue, valueSuffix, false);
return \u0275\u0275stylePropInterpolate6;
}
function \u0275\u0275stylePropInterpolate7(prop, prefix, v0, i0, v1, i1, v2, i2, v3, i3, v42, i4, v5, i5, v6, suffix, valueSuffix) {
const lView = getLView();
const interpolatedValue = interpolation7(lView, prefix, v0, i0, v1, i1, v2, i2, v3, i3, v42, i4, v5, i5, v6, suffix);
checkStylingProperty(prop, interpolatedValue, valueSuffix, false);
return \u0275\u0275stylePropInterpolate7;
}
function \u0275\u0275stylePropInterpolate8(prop, prefix, v0, i0, v1, i1, v2, i2, v3, i3, v42, i4, v5, i5, v6, i6, v7, suffix, valueSuffix) {
const lView = getLView();
const interpolatedValue = interpolation8(lView, prefix, v0, i0, v1, i1, v2, i2, v3, i3, v42, i4, v5, i5, v6, i6, v7, suffix);
checkStylingProperty(prop, interpolatedValue, valueSuffix, false);
return \u0275\u0275stylePropInterpolate8;
}
function \u0275\u0275stylePropInterpolateV(prop, values, valueSuffix) {
const lView = getLView();
const interpolatedValue = interpolationV(lView, values);
checkStylingProperty(prop, interpolatedValue, valueSuffix, false);
return \u0275\u0275stylePropInterpolateV;
}
function \u0275\u0275text(index2, value2 = "") {
const lView = getLView();
const tView = getTView();
const adjustedIndex = index2 + HEADER_OFFSET;
ngDevMode && assertEqual(getBindingIndex(), tView.bindingStartIndex, "text nodes should be created before any bindings");
ngDevMode && assertIndexInRange(lView, adjustedIndex);
const tNode = tView.firstCreatePass ? getOrCreateTNode(tView, adjustedIndex, 1, value2, null) : tView.data[adjustedIndex];
const textNative = _locateOrCreateTextNode(tView, lView, tNode, value2, index2);
lView[adjustedIndex] = textNative;
if (wasLastNodeCreated()) {
appendChild(tView, lView, textNative, tNode);
}
setCurrentTNode(tNode, false);
}
var _locateOrCreateTextNode = (tView, lView, tNode, value2, index2) => {
lastNodeWasCreated(true);
return createTextNode(lView[RENDERER], value2);
};
function \u0275\u0275textInterpolate(v0) {
\u0275\u0275textInterpolate1("", v0, "");
return \u0275\u0275textInterpolate;
}
function \u0275\u0275textInterpolate1(prefix, v0, suffix) {
const lView = getLView();
const interpolated = interpolation1(lView, prefix, v0, suffix);
if (interpolated !== NO_CHANGE) {
textBindingInternal(lView, getSelectedIndex(), interpolated);
}
return \u0275\u0275textInterpolate1;
}
function \u0275\u0275textInterpolate2(prefix, v0, i0, v1, suffix) {
const lView = getLView();
const interpolated = interpolation2(lView, prefix, v0, i0, v1, suffix);
if (interpolated !== NO_CHANGE) {
textBindingInternal(lView, getSelectedIndex(), interpolated);
}
return \u0275\u0275textInterpolate2;
}
function \u0275\u0275textInterpolate3(prefix, v0, i0, v1, i1, v2, suffix) {
const lView = getLView();
const interpolated = interpolation3(lView, prefix, v0, i0, v1, i1, v2, suffix);
if (interpolated !== NO_CHANGE) {
textBindingInternal(lView, getSelectedIndex(), interpolated);
}
return \u0275\u0275textInterpolate3;
}
function \u0275\u0275textInterpolate4(prefix, v0, i0, v1, i1, v2, i2, v3, suffix) {
const lView = getLView();
const interpolated = interpolation4(lView, prefix, v0, i0, v1, i1, v2, i2, v3, suffix);
if (interpolated !== NO_CHANGE) {
textBindingInternal(lView, getSelectedIndex(), interpolated);
}
return \u0275\u0275textInterpolate4;
}
function \u0275\u0275textInterpolate5(prefix, v0, i0, v1, i1, v2, i2, v3, i3, v42, suffix) {
const lView = getLView();
const interpolated = interpolation5(lView, prefix, v0, i0, v1, i1, v2, i2, v3, i3, v42, suffix);
if (interpolated !== NO_CHANGE) {
textBindingInternal(lView, getSelectedIndex(), interpolated);
}
return \u0275\u0275textInterpolate5;
}
function \u0275\u0275textInterpolate6(prefix, v0, i0, v1, i1, v2, i2, v3, i3, v42, i4, v5, suffix) {
const lView = getLView();
const interpolated = interpolation6(lView, prefix, v0, i0, v1, i1, v2, i2, v3, i3, v42, i4, v5, suffix);
if (interpolated !== NO_CHANGE) {
textBindingInternal(lView, getSelectedIndex(), interpolated);
}
return \u0275\u0275textInterpolate6;
}
function \u0275\u0275textInterpolate7(prefix, v0, i0, v1, i1, v2, i2, v3, i3, v42, i4, v5, i5, v6, suffix) {
const lView = getLView();
const interpolated = interpolation7(lView, prefix, v0, i0, v1, i1, v2, i2, v3, i3, v42, i4, v5, i5, v6, suffix);
if (interpolated !== NO_CHANGE) {
textBindingInternal(lView, getSelectedIndex(), interpolated);
}
return \u0275\u0275textInterpolate7;
}
function \u0275\u0275textInterpolate8(prefix, v0, i0, v1, i1, v2, i2, v3, i3, v42, i4, v5, i5, v6, i6, v7, suffix) {
const lView = getLView();
const interpolated = interpolation8(lView, prefix, v0, i0, v1, i1, v2, i2, v3, i3, v42, i4, v5, i5, v6, i6, v7, suffix);
if (interpolated !== NO_CHANGE) {
textBindingInternal(lView, getSelectedIndex(), interpolated);
}
return \u0275\u0275textInterpolate8;
}
function \u0275\u0275textInterpolateV(values) {
const lView = getLView();
const interpolated = interpolationV(lView, values);
if (interpolated !== NO_CHANGE) {
textBindingInternal(lView, getSelectedIndex(), interpolated);
}
return \u0275\u0275textInterpolateV;
}
function \u0275\u0275twoWayProperty(propName, value2, sanitizer) {
if (isWritableSignal(value2)) {
value2 = value2();
}
const lView = getLView();
const bindingIndex = nextBindingIndex();
if (bindingUpdated(lView, bindingIndex, value2)) {
const tView = getTView();
const tNode = getSelectedTNode();
elementPropertyInternal(tView, tNode, lView, propName, value2, lView[RENDERER], sanitizer, false);
ngDevMode && storePropertyBindingMetadata(tView.data, tNode, propName, bindingIndex);
}
return \u0275\u0275twoWayProperty;
}
function \u0275\u0275twoWayBindingSet(target, value2) {
const canWrite = isWritableSignal(target);
canWrite && target.set(value2);
return canWrite;
}
function \u0275\u0275twoWayListener(eventName, listenerFn) {
const lView = getLView();
const tView = getTView();
const tNode = getCurrentTNode();
listenerInternal(tView, lView, lView[RENDERER], tNode, eventName, listenerFn);
return \u0275\u0275twoWayListener;
}
function providersResolver(def, providers, viewProviders) {
const tView = getTView();
if (tView.firstCreatePass) {
const isComponent2 = isComponentDef(def);
resolveProvider(viewProviders, tView.data, tView.blueprint, isComponent2, true);
resolveProvider(providers, tView.data, tView.blueprint, isComponent2, false);
}
}
function resolveProvider(provider, tInjectables, lInjectablesBlueprint, isComponent2, isViewProvider) {
provider = resolveForwardRef(provider);
if (Array.isArray(provider)) {
for (let i = 0; i < provider.length; i++) {
resolveProvider(provider[i], tInjectables, lInjectablesBlueprint, isComponent2, isViewProvider);
}
} else {
const tView = getTView();
const lView = getLView();
const tNode = getCurrentTNode();
let token = isTypeProvider(provider) ? provider : resolveForwardRef(provider.provide);
const providerFactory = providerToFactory(provider);
if (ngDevMode) {
const injector = new NodeInjector(tNode, lView);
runInInjectorProfilerContext(injector, token, () => {
emitProviderConfiguredEvent(provider, isViewProvider);
});
}
const beginIndex = tNode.providerIndexes & 1048575;
const endIndex = tNode.directiveStart;
const cptViewProvidersCount = tNode.providerIndexes >> 20;
if (isTypeProvider(provider) || !provider.multi) {
const factory = new NodeInjectorFactory(providerFactory, isViewProvider, \u0275\u0275directiveInject);
const existingFactoryIndex = indexOf(token, tInjectables, isViewProvider ? beginIndex : beginIndex + cptViewProvidersCount, endIndex);
if (existingFactoryIndex === -1) {
diPublicInInjector(getOrCreateNodeInjectorForNode(tNode, lView), tView, token);
registerDestroyHooksIfSupported(tView, provider, tInjectables.length);
tInjectables.push(token);
tNode.directiveStart++;
tNode.directiveEnd++;
if (isViewProvider) {
tNode.providerIndexes += 1048576;
}
lInjectablesBlueprint.push(factory);
lView.push(factory);
} else {
lInjectablesBlueprint[existingFactoryIndex] = factory;
lView[existingFactoryIndex] = factory;
}
} else {
const existingProvidersFactoryIndex = indexOf(token, tInjectables, beginIndex + cptViewProvidersCount, endIndex);
const existingViewProvidersFactoryIndex = indexOf(token, tInjectables, beginIndex, beginIndex + cptViewProvidersCount);
const doesProvidersFactoryExist = existingProvidersFactoryIndex >= 0 && lInjectablesBlueprint[existingProvidersFactoryIndex];
const doesViewProvidersFactoryExist = existingViewProvidersFactoryIndex >= 0 && lInjectablesBlueprint[existingViewProvidersFactoryIndex];
if (isViewProvider && !doesViewProvidersFactoryExist || !isViewProvider && !doesProvidersFactoryExist) {
diPublicInInjector(getOrCreateNodeInjectorForNode(tNode, lView), tView, token);
const factory = multiFactory(isViewProvider ? multiViewProvidersFactoryResolver : multiProvidersFactoryResolver, lInjectablesBlueprint.length, isViewProvider, isComponent2, providerFactory);
if (!isViewProvider && doesViewProvidersFactoryExist) {
lInjectablesBlueprint[existingViewProvidersFactoryIndex].providerFactory = factory;
}
registerDestroyHooksIfSupported(tView, provider, tInjectables.length, 0);
tInjectables.push(token);
tNode.directiveStart++;
tNode.directiveEnd++;
if (isViewProvider) {
tNode.providerIndexes += 1048576;
}
lInjectablesBlueprint.push(factory);
lView.push(factory);
} else {
const indexInFactory = multiFactoryAdd(lInjectablesBlueprint[isViewProvider ? existingViewProvidersFactoryIndex : existingProvidersFactoryIndex], providerFactory, !isViewProvider && isComponent2);
registerDestroyHooksIfSupported(tView, provider, existingProvidersFactoryIndex > -1 ? existingProvidersFactoryIndex : existingViewProvidersFactoryIndex, indexInFactory);
}
if (!isViewProvider && isComponent2 && doesViewProvidersFactoryExist) {
lInjectablesBlueprint[existingViewProvidersFactoryIndex].componentProviders++;
}
}
}
}
function registerDestroyHooksIfSupported(tView, provider, contextIndex, indexInFactory) {
const providerIsTypeProvider = isTypeProvider(provider);
const providerIsClassProvider = isClassProvider(provider);
if (providerIsTypeProvider || providerIsClassProvider) {
const classToken = providerIsClassProvider ? resolveForwardRef(provider.useClass) : provider;
const prototype = classToken.prototype;
const ngOnDestroy = prototype.ngOnDestroy;
if (ngOnDestroy) {
const hooks = tView.destroyHooks || (tView.destroyHooks = []);
if (!providerIsTypeProvider && provider.multi) {
ngDevMode && assertDefined(indexInFactory, "indexInFactory when registering multi factory destroy hook");
const existingCallbacksIndex = hooks.indexOf(contextIndex);
if (existingCallbacksIndex === -1) {
hooks.push(contextIndex, [indexInFactory, ngOnDestroy]);
} else {
hooks[existingCallbacksIndex + 1].push(indexInFactory, ngOnDestroy);
}
} else {
hooks.push(contextIndex, ngOnDestroy);
}
}
}
}
function multiFactoryAdd(multiFactory2, factory, isComponentProvider) {
if (isComponentProvider) {
multiFactory2.componentProviders++;
}
return multiFactory2.multi.push(factory) - 1;
}
function indexOf(item, arr, begin, end) {
for (let i = begin; i < end; i++) {
if (arr[i] === item)
return i;
}
return -1;
}
function multiProvidersFactoryResolver(_, tData, lData, tNode) {
return multiResolve(this.multi, []);
}
function multiViewProvidersFactoryResolver(_, tData, lView, tNode) {
const factories = this.multi;
let result;
if (this.providerFactory) {
const componentCount = this.providerFactory.componentProviders;
const multiProviders = getNodeInjectable(lView, lView[TVIEW], this.providerFactory.index, tNode);
result = multiProviders.slice(0, componentCount);
multiResolve(factories, result);
for (let i = componentCount; i < multiProviders.length; i++) {
result.push(multiProviders[i]);
}
} else {
result = [];
multiResolve(factories, result);
}
return result;
}
function multiResolve(factories, result) {
for (let i = 0; i < factories.length; i++) {
const factory = factories[i];
result.push(factory());
}
return result;
}
function multiFactory(factoryFn, index2, isViewProvider, isComponent2, f) {
const factory = new NodeInjectorFactory(factoryFn, isViewProvider, \u0275\u0275directiveInject);
factory.multi = [];
factory.index = index2;
factory.componentProviders = 0;
multiFactoryAdd(factory, f, isComponent2 && !isViewProvider);
return factory;
}
function \u0275\u0275ProvidersFeature(providers, viewProviders = []) {
return (definition) => {
definition.providersResolver = (def, processProvidersFn) => {
return providersResolver(
def,
//
processProvidersFn ? processProvidersFn(providers) : providers,
//
viewProviders
);
};
};
}
var _StandaloneService = class _StandaloneService {
constructor(_injector) {
this._injector = _injector;
this.cachedInjectors = /* @__PURE__ */ new Map();
}
getOrCreateStandaloneInjector(componentDef) {
if (!componentDef.standalone) {
return null;
}
if (!this.cachedInjectors.has(componentDef)) {
const providers = internalImportProvidersFrom(false, componentDef.type);
const standaloneInjector = providers.length > 0 ? createEnvironmentInjector([providers], this._injector, `Standalone[${componentDef.type.name}]`) : null;
this.cachedInjectors.set(componentDef, standaloneInjector);
}
return this.cachedInjectors.get(componentDef);
}
ngOnDestroy() {
try {
for (const injector of this.cachedInjectors.values()) {
if (injector !== null) {
injector.destroy();
}
}
} finally {
this.cachedInjectors.clear();
}
}
};
_StandaloneService.\u0275prov = \u0275\u0275defineInjectable({
token: _StandaloneService,
providedIn: "environment",
factory: () => new _StandaloneService(\u0275\u0275inject(EnvironmentInjector))
});
var StandaloneService = _StandaloneService;
function \u0275\u0275StandaloneFeature(definition) {
performanceMarkFeature("NgStandalone");
definition.getStandaloneInjector = (parentInjector) => {
return parentInjector.get(StandaloneService).getOrCreateStandaloneInjector(definition);
};
}
function \u0275\u0275setComponentScope(type, directives, pipes) {
const def = type.\u0275cmp;
def.directiveDefs = extractDefListOrFactory(
directives,
/* pipeDef */
false
);
def.pipeDefs = extractDefListOrFactory(
pipes,
/* pipeDef */
true
);
}
function \u0275\u0275setNgModuleScope(type, scope) {
return noSideEffects(() => {
const ngModuleDef = getNgModuleDef(type, true);
ngModuleDef.declarations = convertToTypeArray(scope.declarations || EMPTY_ARRAY);
ngModuleDef.imports = convertToTypeArray(scope.imports || EMPTY_ARRAY);
ngModuleDef.exports = convertToTypeArray(scope.exports || EMPTY_ARRAY);
if (scope.bootstrap) {
ngModuleDef.bootstrap = convertToTypeArray(scope.bootstrap);
}
depsTracker.registerNgModule(type, scope);
});
}
function convertToTypeArray(values) {
if (typeof values === "function") {
return values;
}
const flattenValues = flatten(values);
if (flattenValues.some(isForwardRef)) {
return () => flattenValues.map(resolveForwardRef).map(maybeUnwrapModuleWithProviders);
} else {
return flattenValues.map(maybeUnwrapModuleWithProviders);
}
}
function maybeUnwrapModuleWithProviders(value2) {
return isModuleWithProviders(value2) ? value2.ngModule : value2;
}
function \u0275\u0275pureFunction0(slotOffset, pureFn, thisArg) {
const bindingIndex = getBindingRoot() + slotOffset;
const lView = getLView();
return lView[bindingIndex] === NO_CHANGE ? updateBinding(lView, bindingIndex, thisArg ? pureFn.call(thisArg) : pureFn()) : getBinding(lView, bindingIndex);
}
function \u0275\u0275pureFunction1(slotOffset, pureFn, exp, thisArg) {
return pureFunction1Internal(getLView(), getBindingRoot(), slotOffset, pureFn, exp, thisArg);
}
function \u0275\u0275pureFunction2(slotOffset, pureFn, exp1, exp2, thisArg) {
return pureFunction2Internal(getLView(), getBindingRoot(), slotOffset, pureFn, exp1, exp2, thisArg);
}
function \u0275\u0275pureFunction3(slotOffset, pureFn, exp1, exp2, exp3, thisArg) {
return pureFunction3Internal(getLView(), getBindingRoot(), slotOffset, pureFn, exp1, exp2, exp3, thisArg);
}
function \u0275\u0275pureFunction4(slotOffset, pureFn, exp1, exp2, exp3, exp4, thisArg) {
return pureFunction4Internal(getLView(), getBindingRoot(), slotOffset, pureFn, exp1, exp2, exp3, exp4, thisArg);
}
function \u0275\u0275pureFunction5(slotOffset, pureFn, exp1, exp2, exp3, exp4, exp5, thisArg) {
const bindingIndex = getBindingRoot() + slotOffset;
const lView = getLView();
const different = bindingUpdated4(lView, bindingIndex, exp1, exp2, exp3, exp4);
return bindingUpdated(lView, bindingIndex + 4, exp5) || different ? updateBinding(lView, bindingIndex + 5, thisArg ? pureFn.call(thisArg, exp1, exp2, exp3, exp4, exp5) : pureFn(exp1, exp2, exp3, exp4, exp5)) : getBinding(lView, bindingIndex + 5);
}
function \u0275\u0275pureFunction6(slotOffset, pureFn, exp1, exp2, exp3, exp4, exp5, exp6, thisArg) {
const bindingIndex = getBindingRoot() + slotOffset;
const lView = getLView();
const different = bindingUpdated4(lView, bindingIndex, exp1, exp2, exp3, exp4);
return bindingUpdated2(lView, bindingIndex + 4, exp5, exp6) || different ? updateBinding(lView, bindingIndex + 6, thisArg ? pureFn.call(thisArg, exp1, exp2, exp3, exp4, exp5, exp6) : pureFn(exp1, exp2, exp3, exp4, exp5, exp6)) : getBinding(lView, bindingIndex + 6);
}
function \u0275\u0275pureFunction7(slotOffset, pureFn, exp1, exp2, exp3, exp4, exp5, exp6, exp7, thisArg) {
const bindingIndex = getBindingRoot() + slotOffset;
const lView = getLView();
let different = bindingUpdated4(lView, bindingIndex, exp1, exp2, exp3, exp4);
return bindingUpdated3(lView, bindingIndex + 4, exp5, exp6, exp7) || different ? updateBinding(lView, bindingIndex + 7, thisArg ? pureFn.call(thisArg, exp1, exp2, exp3, exp4, exp5, exp6, exp7) : pureFn(exp1, exp2, exp3, exp4, exp5, exp6, exp7)) : getBinding(lView, bindingIndex + 7);
}
function \u0275\u0275pureFunction8(slotOffset, pureFn, exp1, exp2, exp3, exp4, exp5, exp6, exp7, exp8, thisArg) {
const bindingIndex = getBindingRoot() + slotOffset;
const lView = getLView();
const different = bindingUpdated4(lView, bindingIndex, exp1, exp2, exp3, exp4);
return bindingUpdated4(lView, bindingIndex + 4, exp5, exp6, exp7, exp8) || different ? updateBinding(lView, bindingIndex + 8, thisArg ? pureFn.call(thisArg, exp1, exp2, exp3, exp4, exp5, exp6, exp7, exp8) : pureFn(exp1, exp2, exp3, exp4, exp5, exp6, exp7, exp8)) : getBinding(lView, bindingIndex + 8);
}
function \u0275\u0275pureFunctionV(slotOffset, pureFn, exps, thisArg) {
return pureFunctionVInternal(getLView(), getBindingRoot(), slotOffset, pureFn, exps, thisArg);
}
function getPureFunctionReturnValue(lView, returnValueIndex) {
ngDevMode && assertIndexInRange(lView, returnValueIndex);
const lastReturnValue = lView[returnValueIndex];
return lastReturnValue === NO_CHANGE ? void 0 : lastReturnValue;
}
function pureFunction1Internal(lView, bindingRoot, slotOffset, pureFn, exp, thisArg) {
const bindingIndex = bindingRoot + slotOffset;
return bindingUpdated(lView, bindingIndex, exp) ? updateBinding(lView, bindingIndex + 1, thisArg ? pureFn.call(thisArg, exp) : pureFn(exp)) : getPureFunctionReturnValue(lView, bindingIndex + 1);
}
function pureFunction2Internal(lView, bindingRoot, slotOffset, pureFn, exp1, exp2, thisArg) {
const bindingIndex = bindingRoot + slotOffset;
return bindingUpdated2(lView, bindingIndex, exp1, exp2) ? updateBinding(lView, bindingIndex + 2, thisArg ? pureFn.call(thisArg, exp1, exp2) : pureFn(exp1, exp2)) : getPureFunctionReturnValue(lView, bindingIndex + 2);
}
function pureFunction3Internal(lView, bindingRoot, slotOffset, pureFn, exp1, exp2, exp3, thisArg) {
const bindingIndex = bindingRoot + slotOffset;
return bindingUpdated3(lView, bindingIndex, exp1, exp2, exp3) ? updateBinding(lView, bindingIndex + 3, thisArg ? pureFn.call(thisArg, exp1, exp2, exp3) : pureFn(exp1, exp2, exp3)) : getPureFunctionReturnValue(lView, bindingIndex + 3);
}
function pureFunction4Internal(lView, bindingRoot, slotOffset, pureFn, exp1, exp2, exp3, exp4, thisArg) {
const bindingIndex = bindingRoot + slotOffset;
return bindingUpdated4(lView, bindingIndex, exp1, exp2, exp3, exp4) ? updateBinding(lView, bindingIndex + 4, thisArg ? pureFn.call(thisArg, exp1, exp2, exp3, exp4) : pureFn(exp1, exp2, exp3, exp4)) : getPureFunctionReturnValue(lView, bindingIndex + 4);
}
function pureFunctionVInternal(lView, bindingRoot, slotOffset, pureFn, exps, thisArg) {
let bindingIndex = bindingRoot + slotOffset;
let different = false;
for (let i = 0; i < exps.length; i++) {
bindingUpdated(lView, bindingIndex++, exps[i]) && (different = true);
}
return different ? updateBinding(lView, bindingIndex, pureFn.apply(thisArg, exps)) : getPureFunctionReturnValue(lView, bindingIndex);
}
function \u0275\u0275pipe(index2, pipeName) {
const tView = getTView();
let pipeDef;
const adjustedIndex = index2 + HEADER_OFFSET;
if (tView.firstCreatePass) {
pipeDef = getPipeDef(pipeName, tView.pipeRegistry);
tView.data[adjustedIndex] = pipeDef;
if (pipeDef.onDestroy) {
(tView.destroyHooks ??= []).push(adjustedIndex, pipeDef.onDestroy);
}
} else {
pipeDef = tView.data[adjustedIndex];
}
const pipeFactory = pipeDef.factory || (pipeDef.factory = getFactoryDef(pipeDef.type, true));
let previousInjectorProfilerContext;
if (ngDevMode) {
previousInjectorProfilerContext = setInjectorProfilerContext({
injector: new NodeInjector(getCurrentTNode(), getLView()),
token: pipeDef.type
});
}
const previousInjectImplementation = setInjectImplementation(\u0275\u0275directiveInject);
try {
const previousIncludeViewProviders = setIncludeViewProviders(false);
const pipeInstance = pipeFactory();
setIncludeViewProviders(previousIncludeViewProviders);
store(tView, getLView(), adjustedIndex, pipeInstance);
return pipeInstance;
} finally {
setInjectImplementation(previousInjectImplementation);
ngDevMode && setInjectorProfilerContext(previousInjectorProfilerContext);
}
}
function getPipeDef(name2, registry) {
if (registry) {
if (ngDevMode) {
const pipes = registry.filter((pipe2) => pipe2.name === name2);
if (pipes.length > 1) {
console.warn(formatRuntimeError(313, getMultipleMatchingPipesMessage(name2)));
}
}
for (let i = registry.length - 1; i >= 0; i--) {
const pipeDef = registry[i];
if (name2 === pipeDef.name) {
return pipeDef;
}
}
}
if (ngDevMode) {
throw new RuntimeError(-302, getPipeNotFoundErrorMessage(name2));
}
return;
}
function getMultipleMatchingPipesMessage(name2) {
const lView = getLView();
const declarationLView = lView[DECLARATION_COMPONENT_VIEW];
const context2 = declarationLView[CONTEXT];
const hostIsStandalone = isHostComponentStandalone(lView);
const componentInfoMessage = context2 ? ` in the '${context2.constructor.name}' component` : "";
const verifyMessage = `check ${hostIsStandalone ? "'@Component.imports' of this component" : "the imports of this module"}`;
const errorMessage = `Multiple pipes match the name \`${name2}\`${componentInfoMessage}. ${verifyMessage}`;
return errorMessage;
}
function getPipeNotFoundErrorMessage(name2) {
const lView = getLView();
const declarationLView = lView[DECLARATION_COMPONENT_VIEW];
const context2 = declarationLView[CONTEXT];
const hostIsStandalone = isHostComponentStandalone(lView);
const componentInfoMessage = context2 ? ` in the '${context2.constructor.name}' component` : "";
const verifyMessage = `Verify that it is ${hostIsStandalone ? "included in the '@Component.imports' of this component" : "declared or imported in this module"}`;
const errorMessage = `The pipe '${name2}' could not be found${componentInfoMessage}. ${verifyMessage}`;
return errorMessage;
}
function \u0275\u0275pipeBind1(index2, offset, v1) {
const adjustedIndex = index2 + HEADER_OFFSET;
const lView = getLView();
const pipeInstance = load(lView, adjustedIndex);
return isPure(lView, adjustedIndex) ? pureFunction1Internal(lView, getBindingRoot(), offset, pipeInstance.transform, v1, pipeInstance) : pipeInstance.transform(v1);
}
function \u0275\u0275pipeBind2(index2, slotOffset, v1, v2) {
const adjustedIndex = index2 + HEADER_OFFSET;
const lView = getLView();
const pipeInstance = load(lView, adjustedIndex);
return isPure(lView, adjustedIndex) ? pureFunction2Internal(lView, getBindingRoot(), slotOffset, pipeInstance.transform, v1, v2, pipeInstance) : pipeInstance.transform(v1, v2);
}
function \u0275\u0275pipeBind3(index2, slotOffset, v1, v2, v3) {
const adjustedIndex = index2 + HEADER_OFFSET;
const lView = getLView();
const pipeInstance = load(lView, adjustedIndex);
return isPure(lView, adjustedIndex) ? pureFunction3Internal(lView, getBindingRoot(), slotOffset, pipeInstance.transform, v1, v2, v3, pipeInstance) : pipeInstance.transform(v1, v2, v3);
}
function \u0275\u0275pipeBind4(index2, slotOffset, v1, v2, v3, v42) {
const adjustedIndex = index2 + HEADER_OFFSET;
const lView = getLView();
const pipeInstance = load(lView, adjustedIndex);
return isPure(lView, adjustedIndex) ? pureFunction4Internal(lView, getBindingRoot(), slotOffset, pipeInstance.transform, v1, v2, v3, v42, pipeInstance) : pipeInstance.transform(v1, v2, v3, v42);
}
function \u0275\u0275pipeBindV(index2, slotOffset, values) {
const adjustedIndex = index2 + HEADER_OFFSET;
const lView = getLView();
const pipeInstance = load(lView, adjustedIndex);
return isPure(lView, adjustedIndex) ? pureFunctionVInternal(lView, getBindingRoot(), slotOffset, pipeInstance.transform, values, pipeInstance) : pipeInstance.transform.apply(pipeInstance, values);
}
function isPure(lView, index2) {
return lView[TVIEW].data[index2].pure;
}
function \u0275\u0275templateRefExtractor(tNode, lView) {
return createTemplateRef(tNode, lView);
}
function \u0275\u0275getComponentDepsFactory(type, rawImports) {
return () => {
try {
return depsTracker.getComponentDependencies(type, rawImports).dependencies;
} catch (e) {
console.error(`Computing dependencies in local compilation mode for the component "${type.name}" failed with the exception:`, e);
throw e;
}
};
}
function \u0275setClassDebugInfo(type, debugInfo) {
const def = getComponentDef(type);
if (def !== null) {
def.debugInfo = debugInfo;
}
}
var angularCoreEnv = /* @__PURE__ */ (() => ({
"\u0275\u0275attribute": \u0275\u0275attribute,
"\u0275\u0275attributeInterpolate1": \u0275\u0275attributeInterpolate1,
"\u0275\u0275attributeInterpolate2": \u0275\u0275attributeInterpolate2,
"\u0275\u0275attributeInterpolate3": \u0275\u0275attributeInterpolate3,
"\u0275\u0275attributeInterpolate4": \u0275\u0275attributeInterpolate4,
"\u0275\u0275attributeInterpolate5": \u0275\u0275attributeInterpolate5,
"\u0275\u0275attributeInterpolate6": \u0275\u0275attributeInterpolate6,
"\u0275\u0275attributeInterpolate7": \u0275\u0275attributeInterpolate7,
"\u0275\u0275attributeInterpolate8": \u0275\u0275attributeInterpolate8,
"\u0275\u0275attributeInterpolateV": \u0275\u0275attributeInterpolateV,
"\u0275\u0275defineComponent": \u0275\u0275defineComponent,
"\u0275\u0275defineDirective": \u0275\u0275defineDirective,
"\u0275\u0275defineInjectable": \u0275\u0275defineInjectable,
"\u0275\u0275defineInjector": \u0275\u0275defineInjector,
"\u0275\u0275defineNgModule": \u0275\u0275defineNgModule,
"\u0275\u0275definePipe": \u0275\u0275definePipe,
"\u0275\u0275directiveInject": \u0275\u0275directiveInject,
"\u0275\u0275getInheritedFactory": \u0275\u0275getInheritedFactory,
"\u0275\u0275inject": \u0275\u0275inject,
"\u0275\u0275injectAttribute": \u0275\u0275injectAttribute,
"\u0275\u0275invalidFactory": \u0275\u0275invalidFactory,
"\u0275\u0275invalidFactoryDep": \u0275\u0275invalidFactoryDep,
"\u0275\u0275templateRefExtractor": \u0275\u0275templateRefExtractor,
"\u0275\u0275resetView": \u0275\u0275resetView,
"\u0275\u0275HostDirectivesFeature": \u0275\u0275HostDirectivesFeature,
"\u0275\u0275NgOnChangesFeature": \u0275\u0275NgOnChangesFeature,
"\u0275\u0275ProvidersFeature": \u0275\u0275ProvidersFeature,
"\u0275\u0275CopyDefinitionFeature": \u0275\u0275CopyDefinitionFeature,
"\u0275\u0275InheritDefinitionFeature": \u0275\u0275InheritDefinitionFeature,
"\u0275\u0275InputTransformsFeature": \u0275\u0275InputTransformsFeature,
"\u0275\u0275StandaloneFeature": \u0275\u0275StandaloneFeature,
"\u0275\u0275nextContext": \u0275\u0275nextContext,
"\u0275\u0275namespaceHTML": \u0275\u0275namespaceHTML,
"\u0275\u0275namespaceMathML": \u0275\u0275namespaceMathML,
"\u0275\u0275namespaceSVG": \u0275\u0275namespaceSVG,
"\u0275\u0275enableBindings": \u0275\u0275enableBindings,
"\u0275\u0275disableBindings": \u0275\u0275disableBindings,
"\u0275\u0275elementStart": \u0275\u0275elementStart,
"\u0275\u0275elementEnd": \u0275\u0275elementEnd,
"\u0275\u0275element": \u0275\u0275element,
"\u0275\u0275elementContainerStart": \u0275\u0275elementContainerStart,
"\u0275\u0275elementContainerEnd": \u0275\u0275elementContainerEnd,
"\u0275\u0275elementContainer": \u0275\u0275elementContainer,
"\u0275\u0275pureFunction0": \u0275\u0275pureFunction0,
"\u0275\u0275pureFunction1": \u0275\u0275pureFunction1,
"\u0275\u0275pureFunction2": \u0275\u0275pureFunction2,
"\u0275\u0275pureFunction3": \u0275\u0275pureFunction3,
"\u0275\u0275pureFunction4": \u0275\u0275pureFunction4,
"\u0275\u0275pureFunction5": \u0275\u0275pureFunction5,
"\u0275\u0275pureFunction6": \u0275\u0275pureFunction6,
"\u0275\u0275pureFunction7": \u0275\u0275pureFunction7,
"\u0275\u0275pureFunction8": \u0275\u0275pureFunction8,
"\u0275\u0275pureFunctionV": \u0275\u0275pureFunctionV,
"\u0275\u0275getCurrentView": \u0275\u0275getCurrentView,
"\u0275\u0275restoreView": \u0275\u0275restoreView,
"\u0275\u0275listener": \u0275\u0275listener,
"\u0275\u0275projection": \u0275\u0275projection,
"\u0275\u0275syntheticHostProperty": \u0275\u0275syntheticHostProperty,
"\u0275\u0275syntheticHostListener": \u0275\u0275syntheticHostListener,
"\u0275\u0275pipeBind1": \u0275\u0275pipeBind1,
"\u0275\u0275pipeBind2": \u0275\u0275pipeBind2,
"\u0275\u0275pipeBind3": \u0275\u0275pipeBind3,
"\u0275\u0275pipeBind4": \u0275\u0275pipeBind4,
"\u0275\u0275pipeBindV": \u0275\u0275pipeBindV,
"\u0275\u0275projectionDef": \u0275\u0275projectionDef,
"\u0275\u0275hostProperty": \u0275\u0275hostProperty,
"\u0275\u0275property": \u0275\u0275property,
"\u0275\u0275propertyInterpolate": \u0275\u0275propertyInterpolate,
"\u0275\u0275propertyInterpolate1": \u0275\u0275propertyInterpolate1,
"\u0275\u0275propertyInterpolate2": \u0275\u0275propertyInterpolate2,
"\u0275\u0275propertyInterpolate3": \u0275\u0275propertyInterpolate3,
"\u0275\u0275propertyInterpolate4": \u0275\u0275propertyInterpolate4,
"\u0275\u0275propertyInterpolate5": \u0275\u0275propertyInterpolate5,
"\u0275\u0275propertyInterpolate6": \u0275\u0275propertyInterpolate6,
"\u0275\u0275propertyInterpolate7": \u0275\u0275propertyInterpolate7,
"\u0275\u0275propertyInterpolate8": \u0275\u0275propertyInterpolate8,
"\u0275\u0275propertyInterpolateV": \u0275\u0275propertyInterpolateV,
"\u0275\u0275pipe": \u0275\u0275pipe,
"\u0275\u0275queryRefresh": \u0275\u0275queryRefresh,
"\u0275\u0275queryAdvance": \u0275\u0275queryAdvance,
"\u0275\u0275viewQuery": \u0275\u0275viewQuery,
"\u0275\u0275viewQuerySignal": \u0275\u0275viewQuerySignal,
"\u0275\u0275loadQuery": \u0275\u0275loadQuery,
"\u0275\u0275contentQuery": \u0275\u0275contentQuery,
"\u0275\u0275contentQuerySignal": \u0275\u0275contentQuerySignal,
"\u0275\u0275reference": \u0275\u0275reference,
"\u0275\u0275classMap": \u0275\u0275classMap,
"\u0275\u0275classMapInterpolate1": \u0275\u0275classMapInterpolate1,
"\u0275\u0275classMapInterpolate2": \u0275\u0275classMapInterpolate2,
"\u0275\u0275classMapInterpolate3": \u0275\u0275classMapInterpolate3,
"\u0275\u0275classMapInterpolate4": \u0275\u0275classMapInterpolate4,
"\u0275\u0275classMapInterpolate5": \u0275\u0275classMapInterpolate5,
"\u0275\u0275classMapInterpolate6": \u0275\u0275classMapInterpolate6,
"\u0275\u0275classMapInterpolate7": \u0275\u0275classMapInterpolate7,
"\u0275\u0275classMapInterpolate8": \u0275\u0275classMapInterpolate8,
"\u0275\u0275classMapInterpolateV": \u0275\u0275classMapInterpolateV,
"\u0275\u0275styleMap": \u0275\u0275styleMap,
"\u0275\u0275styleMapInterpolate1": \u0275\u0275styleMapInterpolate1,
"\u0275\u0275styleMapInterpolate2": \u0275\u0275styleMapInterpolate2,
"\u0275\u0275styleMapInterpolate3": \u0275\u0275styleMapInterpolate3,
"\u0275\u0275styleMapInterpolate4": \u0275\u0275styleMapInterpolate4,
"\u0275\u0275styleMapInterpolate5": \u0275\u0275styleMapInterpolate5,
"\u0275\u0275styleMapInterpolate6": \u0275\u0275styleMapInterpolate6,
"\u0275\u0275styleMapInterpolate7": \u0275\u0275styleMapInterpolate7,
"\u0275\u0275styleMapInterpolate8": \u0275\u0275styleMapInterpolate8,
"\u0275\u0275styleMapInterpolateV": \u0275\u0275styleMapInterpolateV,
"\u0275\u0275styleProp": \u0275\u0275styleProp,
"\u0275\u0275stylePropInterpolate1": \u0275\u0275stylePropInterpolate1,
"\u0275\u0275stylePropInterpolate2": \u0275\u0275stylePropInterpolate2,
"\u0275\u0275stylePropInterpolate3": \u0275\u0275stylePropInterpolate3,
"\u0275\u0275stylePropInterpolate4": \u0275\u0275stylePropInterpolate4,
"\u0275\u0275stylePropInterpolate5": \u0275\u0275stylePropInterpolate5,
"\u0275\u0275stylePropInterpolate6": \u0275\u0275stylePropInterpolate6,
"\u0275\u0275stylePropInterpolate7": \u0275\u0275stylePropInterpolate7,
"\u0275\u0275stylePropInterpolate8": \u0275\u0275stylePropInterpolate8,
"\u0275\u0275stylePropInterpolateV": \u0275\u0275stylePropInterpolateV,
"\u0275\u0275classProp": \u0275\u0275classProp,
"\u0275\u0275advance": \u0275\u0275advance,
"\u0275\u0275template": \u0275\u0275template,
"\u0275\u0275conditional": \u0275\u0275conditional,
"\u0275\u0275defer": \u0275\u0275defer,
"\u0275\u0275deferWhen": \u0275\u0275deferWhen,
"\u0275\u0275deferOnIdle": \u0275\u0275deferOnIdle,
"\u0275\u0275deferOnImmediate": \u0275\u0275deferOnImmediate,
"\u0275\u0275deferOnTimer": \u0275\u0275deferOnTimer,
"\u0275\u0275deferOnHover": \u0275\u0275deferOnHover,
"\u0275\u0275deferOnInteraction": \u0275\u0275deferOnInteraction,
"\u0275\u0275deferOnViewport": \u0275\u0275deferOnViewport,
"\u0275\u0275deferPrefetchWhen": \u0275\u0275deferPrefetchWhen,
"\u0275\u0275deferPrefetchOnIdle": \u0275\u0275deferPrefetchOnIdle,
"\u0275\u0275deferPrefetchOnImmediate": \u0275\u0275deferPrefetchOnImmediate,
"\u0275\u0275deferPrefetchOnTimer": \u0275\u0275deferPrefetchOnTimer,
"\u0275\u0275deferPrefetchOnHover": \u0275\u0275deferPrefetchOnHover,
"\u0275\u0275deferPrefetchOnInteraction": \u0275\u0275deferPrefetchOnInteraction,
"\u0275\u0275deferPrefetchOnViewport": \u0275\u0275deferPrefetchOnViewport,
"\u0275\u0275deferEnableTimerScheduling": \u0275\u0275deferEnableTimerScheduling,
"\u0275\u0275repeater": \u0275\u0275repeater,
"\u0275\u0275repeaterCreate": \u0275\u0275repeaterCreate,
"\u0275\u0275repeaterTrackByIndex": \u0275\u0275repeaterTrackByIndex,
"\u0275\u0275repeaterTrackByIdentity": \u0275\u0275repeaterTrackByIdentity,
"\u0275\u0275componentInstance": \u0275\u0275componentInstance,
"\u0275\u0275text": \u0275\u0275text,
"\u0275\u0275textInterpolate": \u0275\u0275textInterpolate,
"\u0275\u0275textInterpolate1": \u0275\u0275textInterpolate1,
"\u0275\u0275textInterpolate2": \u0275\u0275textInterpolate2,
"\u0275\u0275textInterpolate3": \u0275\u0275textInterpolate3,
"\u0275\u0275textInterpolate4": \u0275\u0275textInterpolate4,
"\u0275\u0275textInterpolate5": \u0275\u0275textInterpolate5,
"\u0275\u0275textInterpolate6": \u0275\u0275textInterpolate6,
"\u0275\u0275textInterpolate7": \u0275\u0275textInterpolate7,
"\u0275\u0275textInterpolate8": \u0275\u0275textInterpolate8,
"\u0275\u0275textInterpolateV": \u0275\u0275textInterpolateV,
"\u0275\u0275i18n": \u0275\u0275i18n,
"\u0275\u0275i18nAttributes": \u0275\u0275i18nAttributes,
"\u0275\u0275i18nExp": \u0275\u0275i18nExp,
"\u0275\u0275i18nStart": \u0275\u0275i18nStart,
"\u0275\u0275i18nEnd": \u0275\u0275i18nEnd,
"\u0275\u0275i18nApply": \u0275\u0275i18nApply,
"\u0275\u0275i18nPostprocess": \u0275\u0275i18nPostprocess,
"\u0275\u0275resolveWindow": \u0275\u0275resolveWindow,
"\u0275\u0275resolveDocument": \u0275\u0275resolveDocument,
"\u0275\u0275resolveBody": \u0275\u0275resolveBody,
"\u0275\u0275setComponentScope": \u0275\u0275setComponentScope,
"\u0275\u0275setNgModuleScope": \u0275\u0275setNgModuleScope,
"\u0275\u0275registerNgModuleType": registerNgModuleType,
"\u0275\u0275getComponentDepsFactory": \u0275\u0275getComponentDepsFactory,
"\u0275setClassDebugInfo": \u0275setClassDebugInfo,
"\u0275\u0275sanitizeHtml": \u0275\u0275sanitizeHtml,
"\u0275\u0275sanitizeStyle": \u0275\u0275sanitizeStyle,
"\u0275\u0275sanitizeResourceUrl": \u0275\u0275sanitizeResourceUrl,
"\u0275\u0275sanitizeScript": \u0275\u0275sanitizeScript,
"\u0275\u0275sanitizeUrl": \u0275\u0275sanitizeUrl,
"\u0275\u0275sanitizeUrlOrResourceUrl": \u0275\u0275sanitizeUrlOrResourceUrl,
"\u0275\u0275trustConstantHtml": \u0275\u0275trustConstantHtml,
"\u0275\u0275trustConstantResourceUrl": \u0275\u0275trustConstantResourceUrl,
"\u0275\u0275validateIframeAttribute": \u0275\u0275validateIframeAttribute,
"forwardRef": forwardRef,
"resolveForwardRef": resolveForwardRef,
"\u0275\u0275twoWayProperty": \u0275\u0275twoWayProperty,
"\u0275\u0275twoWayBindingSet": \u0275\u0275twoWayBindingSet,
"\u0275\u0275twoWayListener": \u0275\u0275twoWayListener,
"\u0275\u0275InputFlags": InputFlags
}))();
var jitOptions = null;
function setJitOptions(options) {
if (jitOptions !== null) {
if (options.defaultEncapsulation !== jitOptions.defaultEncapsulation) {
ngDevMode && console.error("Provided value for `defaultEncapsulation` can not be changed once it has been set.");
return;
}
if (options.preserveWhitespaces !== jitOptions.preserveWhitespaces) {
ngDevMode && console.error("Provided value for `preserveWhitespaces` can not be changed once it has been set.");
return;
}
}
jitOptions = options;
}
function getJitOptions() {
return jitOptions;
}
function patchModuleCompilation() {
}
var moduleQueue = [];
function enqueueModuleForDelayedScoping(moduleType, ngModule) {
moduleQueue.push({ moduleType, ngModule });
}
var flushingModuleQueue = false;
function flushModuleScopingQueueAsMuchAsPossible() {
if (!flushingModuleQueue) {
flushingModuleQueue = true;
try {
for (let i = moduleQueue.length - 1; i >= 0; i--) {
const { moduleType, ngModule } = moduleQueue[i];
if (ngModule.declarations && ngModule.declarations.every(isResolvedDeclaration)) {
moduleQueue.splice(i, 1);
setScopeOnDeclaredComponents(moduleType, ngModule);
}
}
} finally {
flushingModuleQueue = false;
}
}
}
function isResolvedDeclaration(declaration) {
if (Array.isArray(declaration)) {
return declaration.every(isResolvedDeclaration);
}
return !!resolveForwardRef(declaration);
}
function compileNgModule(moduleType, ngModule = {}) {
patchModuleCompilation();
compileNgModuleDefs(moduleType, ngModule);
if (ngModule.id !== void 0) {
registerNgModuleType(moduleType, ngModule.id);
}
enqueueModuleForDelayedScoping(moduleType, ngModule);
}
function compileNgModuleDefs(moduleType, ngModule, allowDuplicateDeclarationsInRoot = false) {
ngDevMode && assertDefined(moduleType, "Required value moduleType");
ngDevMode && assertDefined(ngModule, "Required value ngModule");
const declarations = flatten(ngModule.declarations || EMPTY_ARRAY);
let ngModuleDef = null;
Object.defineProperty(moduleType, NG_MOD_DEF, {
configurable: true,
get: () => {
if (ngModuleDef === null) {
if (ngDevMode && ngModule.imports && ngModule.imports.indexOf(moduleType) > -1) {
throw new Error(`'${stringifyForError(moduleType)}' module can't import itself`);
}
const compiler = getCompilerFacade({ usage: 0, kind: "NgModule", type: moduleType });
ngModuleDef = compiler.compileNgModule(angularCoreEnv, `ng:///${moduleType.name}/\u0275mod.js`, {
type: moduleType,
bootstrap: flatten(ngModule.bootstrap || EMPTY_ARRAY).map(resolveForwardRef),
declarations: declarations.map(resolveForwardRef),
imports: flatten(ngModule.imports || EMPTY_ARRAY).map(resolveForwardRef).map(expandModuleWithProviders),
exports: flatten(ngModule.exports || EMPTY_ARRAY).map(resolveForwardRef).map(expandModuleWithProviders),
schemas: ngModule.schemas ? flatten(ngModule.schemas) : null,
id: ngModule.id || null
});
if (!ngModuleDef.schemas) {
ngModuleDef.schemas = [];
}
}
return ngModuleDef;
}
});
let ngFactoryDef = null;
Object.defineProperty(moduleType, NG_FACTORY_DEF, {
get: () => {
if (ngFactoryDef === null) {
const compiler = getCompilerFacade({ usage: 0, kind: "NgModule", type: moduleType });
ngFactoryDef = compiler.compileFactory(angularCoreEnv, `ng:///${moduleType.name}/\u0275fac.js`, {
name: moduleType.name,
type: moduleType,
deps: reflectDependencies(moduleType),
target: compiler.FactoryTarget.NgModule,
typeArgumentCount: 0
});
}
return ngFactoryDef;
},
// Make the property configurable in dev mode to allow overriding in tests
configurable: !!ngDevMode
});
let ngInjectorDef = null;
Object.defineProperty(moduleType, NG_INJ_DEF, {
get: () => {
if (ngInjectorDef === null) {
ngDevMode && verifySemanticsOfNgModuleDef(moduleType, allowDuplicateDeclarationsInRoot);
const meta = {
name: moduleType.name,
type: moduleType,
providers: ngModule.providers || EMPTY_ARRAY,
imports: [
(ngModule.imports || EMPTY_ARRAY).map(resolveForwardRef),
(ngModule.exports || EMPTY_ARRAY).map(resolveForwardRef)
]
};
const compiler = getCompilerFacade({ usage: 0, kind: "NgModule", type: moduleType });
ngInjectorDef = compiler.compileInjector(angularCoreEnv, `ng:///${moduleType.name}/\u0275inj.js`, meta);
}
return ngInjectorDef;
},
// Make the property configurable in dev mode to allow overriding in tests
configurable: !!ngDevMode
});
}
function generateStandaloneInDeclarationsError(type, location2) {
const prefix = `Unexpected "${stringifyForError(type)}" found in the "declarations" array of the`;
const suffix = `"${stringifyForError(type)}" is marked as standalone and can't be declared in any NgModule - did you intend to import it instead (by adding it to the "imports" array)?`;
return `${prefix} ${location2}, ${suffix}`;
}
function verifySemanticsOfNgModuleDef(moduleType, allowDuplicateDeclarationsInRoot, importingModule) {
if (verifiedNgModule.get(moduleType))
return;
if (isStandalone(moduleType))
return;
verifiedNgModule.set(moduleType, true);
moduleType = resolveForwardRef(moduleType);
let ngModuleDef;
if (importingModule) {
ngModuleDef = getNgModuleDef(moduleType);
if (!ngModuleDef) {
throw new Error(`Unexpected value '${moduleType.name}' imported by the module '${importingModule.name}'. Please add an @NgModule annotation.`);
}
} else {
ngModuleDef = getNgModuleDef(moduleType, true);
}
const errors = [];
const declarations = maybeUnwrapFn(ngModuleDef.declarations);
const imports = maybeUnwrapFn(ngModuleDef.imports);
flatten(imports).map(unwrapModuleWithProvidersImports).forEach((modOrStandaloneCmpt) => {
verifySemanticsOfNgModuleImport(modOrStandaloneCmpt, moduleType);
verifySemanticsOfNgModuleDef(modOrStandaloneCmpt, false, moduleType);
});
const exports2 = maybeUnwrapFn(ngModuleDef.exports);
declarations.forEach(verifyDeclarationsHaveDefinitions);
declarations.forEach(verifyDirectivesHaveSelector);
declarations.forEach((declarationType) => verifyNotStandalone(declarationType, moduleType));
const combinedDeclarations = [
...declarations.map(resolveForwardRef),
...flatten(imports.map(computeCombinedExports)).map(resolveForwardRef)
];
exports2.forEach(verifyExportsAreDeclaredOrReExported);
declarations.forEach((decl) => verifyDeclarationIsUnique(decl, allowDuplicateDeclarationsInRoot));
const ngModule = getAnnotation(moduleType, "NgModule");
if (ngModule) {
ngModule.imports && flatten(ngModule.imports).map(unwrapModuleWithProvidersImports).forEach((mod2) => {
verifySemanticsOfNgModuleImport(mod2, moduleType);
verifySemanticsOfNgModuleDef(mod2, false, moduleType);
});
ngModule.bootstrap && deepForEach(ngModule.bootstrap, verifyCorrectBootstrapType);
ngModule.bootstrap && deepForEach(ngModule.bootstrap, verifyComponentIsPartOfNgModule);
}
if (errors.length) {
throw new Error(errors.join("\n"));
}
function verifyDeclarationsHaveDefinitions(type) {
type = resolveForwardRef(type);
const def = getComponentDef(type) || getDirectiveDef(type) || getPipeDef$1(type);
if (!def) {
errors.push(`Unexpected value '${stringifyForError(type)}' declared by the module '${stringifyForError(moduleType)}'. Please add a @Pipe/@Directive/@Component annotation.`);
}
}
function verifyDirectivesHaveSelector(type) {
type = resolveForwardRef(type);
const def = getDirectiveDef(type);
if (!getComponentDef(type) && def && def.selectors.length == 0) {
errors.push(`Directive ${stringifyForError(type)} has no selector, please add it!`);
}
}
function verifyNotStandalone(type, moduleType2) {
type = resolveForwardRef(type);
const def = getComponentDef(type) || getDirectiveDef(type) || getPipeDef$1(type);
if (def?.standalone) {
const location2 = `"${stringifyForError(moduleType2)}" NgModule`;
errors.push(generateStandaloneInDeclarationsError(type, location2));
}
}
function verifyExportsAreDeclaredOrReExported(type) {
type = resolveForwardRef(type);
const kind = getComponentDef(type) && "component" || getDirectiveDef(type) && "directive" || getPipeDef$1(type) && "pipe";
if (kind) {
if (combinedDeclarations.lastIndexOf(type) === -1) {
errors.push(`Can't export ${kind} ${stringifyForError(type)} from ${stringifyForError(moduleType)} as it was neither declared nor imported!`);
}
}
}
function verifyDeclarationIsUnique(type, suppressErrors) {
type = resolveForwardRef(type);
const existingModule = ownerNgModule.get(type);
if (existingModule && existingModule !== moduleType) {
if (!suppressErrors) {
const modules2 = [existingModule, moduleType].map(stringifyForError).sort();
errors.push(`Type ${stringifyForError(type)} is part of the declarations of 2 modules: ${modules2[0]} and ${modules2[1]}! Please consider moving ${stringifyForError(type)} to a higher module that imports ${modules2[0]} and ${modules2[1]}. You can also create a new NgModule that exports and includes ${stringifyForError(type)} then import that NgModule in ${modules2[0]} and ${modules2[1]}.`);
}
} else {
ownerNgModule.set(type, moduleType);
}
}
function verifyComponentIsPartOfNgModule(type) {
type = resolveForwardRef(type);
const existingModule = ownerNgModule.get(type);
if (!existingModule && !isStandalone(type)) {
errors.push(`Component ${stringifyForError(type)} is not part of any NgModule or the module has not been imported into your module.`);
}
}
function verifyCorrectBootstrapType(type) {
type = resolveForwardRef(type);
if (!getComponentDef(type)) {
errors.push(`${stringifyForError(type)} cannot be used as an entry component.`);
}
if (isStandalone(type)) {
errors.push(`The \`${stringifyForError(type)}\` class is a standalone component, which can not be used in the \`@NgModule.bootstrap\` array. Use the \`bootstrapApplication\` function for bootstrap instead.`);
}
}
function verifySemanticsOfNgModuleImport(type, importingModule2) {
type = resolveForwardRef(type);
const directiveDef = getComponentDef(type) || getDirectiveDef(type);
if (directiveDef !== null && !directiveDef.standalone) {
throw new Error(`Unexpected directive '${type.name}' imported by the module '${importingModule2.name}'. Please add an @NgModule annotation.`);
}
const pipeDef = getPipeDef$1(type);
if (pipeDef !== null && !pipeDef.standalone) {
throw new Error(`Unexpected pipe '${type.name}' imported by the module '${importingModule2.name}'. Please add an @NgModule annotation.`);
}
}
}
function unwrapModuleWithProvidersImports(typeOrWithProviders) {
typeOrWithProviders = resolveForwardRef(typeOrWithProviders);
return typeOrWithProviders.ngModule || typeOrWithProviders;
}
function getAnnotation(type, name2) {
let annotation = null;
collect(type.__annotations__);
collect(type.decorators);
return annotation;
function collect(annotations) {
if (annotations) {
annotations.forEach(readAnnotation);
}
}
function readAnnotation(decorator) {
if (!annotation) {
const proto = Object.getPrototypeOf(decorator);
if (proto.ngMetadataName == name2) {
annotation = decorator;
} else if (decorator.type) {
const proto2 = Object.getPrototypeOf(decorator.type);
if (proto2.ngMetadataName == name2) {
annotation = decorator.args[0];
}
}
}
}
}
var ownerNgModule = /* @__PURE__ */ new WeakMap();
var verifiedNgModule = /* @__PURE__ */ new WeakMap();
function computeCombinedExports(type) {
type = resolveForwardRef(type);
const ngModuleDef = getNgModuleDef(type);
if (ngModuleDef === null) {
return [type];
}
return flatten(maybeUnwrapFn(ngModuleDef.exports).map((type2) => {
const ngModuleDef2 = getNgModuleDef(type2);
if (ngModuleDef2) {
verifySemanticsOfNgModuleDef(type2, false);
return computeCombinedExports(type2);
} else {
return type2;
}
}));
}
function setScopeOnDeclaredComponents(moduleType, ngModule) {
const declarations = flatten(ngModule.declarations || EMPTY_ARRAY);
const transitiveScopes = transitiveScopesFor(moduleType);
declarations.forEach((declaration) => {
declaration = resolveForwardRef(declaration);
if (declaration.hasOwnProperty(NG_COMP_DEF)) {
const component = declaration;
const componentDef = getComponentDef(component);
patchComponentDefWithScope(componentDef, transitiveScopes);
} else if (!declaration.hasOwnProperty(NG_DIR_DEF) && !declaration.hasOwnProperty(NG_PIPE_DEF)) {
declaration.ngSelectorScope = moduleType;
}
});
}
function patchComponentDefWithScope(componentDef, transitiveScopes) {
componentDef.directiveDefs = () => Array.from(transitiveScopes.compilation.directives).map((dir) => dir.hasOwnProperty(NG_COMP_DEF) ? getComponentDef(dir) : getDirectiveDef(dir)).filter((def) => !!def);
componentDef.pipeDefs = () => Array.from(transitiveScopes.compilation.pipes).map((pipe2) => getPipeDef$1(pipe2));
componentDef.schemas = transitiveScopes.schemas;
componentDef.tView = null;
}
function transitiveScopesFor(type) {
if (isNgModule(type)) {
if (USE_RUNTIME_DEPS_TRACKER_FOR_JIT) {
const scope = depsTracker.getNgModuleScope(type);
const def = getNgModuleDef(type, true);
return __spreadValues({
schemas: def.schemas || null
}, scope);
} else {
return transitiveScopesForNgModule(type);
}
} else if (isStandalone(type)) {
const directiveDef = getComponentDef(type) || getDirectiveDef(type);
if (directiveDef !== null) {
return {
schemas: null,
compilation: {
directives: /* @__PURE__ */ new Set(),
pipes: /* @__PURE__ */ new Set()
},
exported: {
directives: /* @__PURE__ */ new Set([type]),
pipes: /* @__PURE__ */ new Set()
}
};
}
const pipeDef = getPipeDef$1(type);
if (pipeDef !== null) {
return {
schemas: null,
compilation: {
directives: /* @__PURE__ */ new Set(),
pipes: /* @__PURE__ */ new Set()
},
exported: {
directives: /* @__PURE__ */ new Set(),
pipes: /* @__PURE__ */ new Set([type])
}
};
}
}
throw new Error(`${type.name} does not have a module def (\u0275mod property)`);
}
function transitiveScopesForNgModule(moduleType) {
const def = getNgModuleDef(moduleType, true);
if (def.transitiveCompileScopes !== null) {
return def.transitiveCompileScopes;
}
const scopes = {
schemas: def.schemas || null,
compilation: {
directives: /* @__PURE__ */ new Set(),
pipes: /* @__PURE__ */ new Set()
},
exported: {
directives: /* @__PURE__ */ new Set(),
pipes: /* @__PURE__ */ new Set()
}
};
maybeUnwrapFn(def.imports).forEach((imported) => {
const importedScope = transitiveScopesFor(imported);
importedScope.exported.directives.forEach((entry) => scopes.compilation.directives.add(entry));
importedScope.exported.pipes.forEach((entry) => scopes.compilation.pipes.add(entry));
});
maybeUnwrapFn(def.declarations).forEach((declared) => {
const declaredWithDefs = declared;
if (getPipeDef$1(declaredWithDefs)) {
scopes.compilation.pipes.add(declared);
} else {
scopes.compilation.directives.add(declared);
}
});
maybeUnwrapFn(def.exports).forEach((exported) => {
const exportedType = exported;
if (isNgModule(exportedType)) {
const exportedScope = transitiveScopesFor(exportedType);
exportedScope.exported.directives.forEach((entry) => {
scopes.compilation.directives.add(entry);
scopes.exported.directives.add(entry);
});
exportedScope.exported.pipes.forEach((entry) => {
scopes.compilation.pipes.add(entry);
scopes.exported.pipes.add(entry);
});
} else if (getPipeDef$1(exportedType)) {
scopes.exported.pipes.add(exportedType);
} else {
scopes.exported.directives.add(exportedType);
}
});
def.transitiveCompileScopes = scopes;
return scopes;
}
function expandModuleWithProviders(value2) {
if (isModuleWithProviders(value2)) {
return value2.ngModule;
}
return value2;
}
var compilationDepth = 0;
function compileComponent(type, metadata) {
(typeof ngDevMode === "undefined" || ngDevMode) && initNgDevMode();
let ngComponentDef = null;
maybeQueueResolutionOfComponentResources(type, metadata);
addDirectiveFactoryDef(type, metadata);
Object.defineProperty(type, NG_COMP_DEF, {
get: () => {
if (ngComponentDef === null) {
const compiler = getCompilerFacade({ usage: 0, kind: "component", type });
if (componentNeedsResolution(metadata)) {
const error = [`Component '${type.name}' is not resolved:`];
if (metadata.templateUrl) {
error.push(` - templateUrl: ${metadata.templateUrl}`);
}
if (metadata.styleUrls && metadata.styleUrls.length) {
error.push(` - styleUrls: ${JSON.stringify(metadata.styleUrls)}`);
}
if (metadata.styleUrl) {
error.push(` - styleUrl: ${metadata.styleUrl}`);
}
error.push(`Did you run and wait for 'resolveComponentResources()'?`);
throw new Error(error.join("\n"));
}
const options = getJitOptions();
let preserveWhitespaces = metadata.preserveWhitespaces;
if (preserveWhitespaces === void 0) {
if (options !== null && options.preserveWhitespaces !== void 0) {
preserveWhitespaces = options.preserveWhitespaces;
} else {
preserveWhitespaces = false;
}
}
let encapsulation = metadata.encapsulation;
if (encapsulation === void 0) {
if (options !== null && options.defaultEncapsulation !== void 0) {
encapsulation = options.defaultEncapsulation;
} else {
encapsulation = ViewEncapsulation$1.Emulated;
}
}
const templateUrl = metadata.templateUrl || `ng:///${type.name}/template.html`;
const meta = __spreadProps(__spreadValues({}, directiveMetadata(type, metadata)), {
typeSourceSpan: compiler.createParseSourceSpan("Component", type.name, templateUrl),
template: metadata.template || "",
preserveWhitespaces,
styles: typeof metadata.styles === "string" ? [metadata.styles] : metadata.styles || EMPTY_ARRAY,
animations: metadata.animations,
// JIT components are always compiled against an empty set of `declarations`. Instead, the
// `directiveDefs` and `pipeDefs` are updated at a later point:
// * for NgModule-based components, they're set when the NgModule which declares the
// component resolves in the module scoping queue
// * for standalone components, they're set just below, after `compileComponent`.
declarations: [],
changeDetection: metadata.changeDetection,
encapsulation,
interpolation: metadata.interpolation,
viewProviders: metadata.viewProviders || null
});
compilationDepth++;
try {
if (meta.usesInheritance) {
addDirectiveDefToUndecoratedParents(type);
}
ngComponentDef = compiler.compileComponent(angularCoreEnv, templateUrl, meta);
if (metadata.standalone) {
const imports = flatten(metadata.imports || EMPTY_ARRAY);
const { directiveDefs, pipeDefs } = getStandaloneDefFunctions(type, imports);
ngComponentDef.directiveDefs = directiveDefs;
ngComponentDef.pipeDefs = pipeDefs;
ngComponentDef.dependencies = () => imports.map(resolveForwardRef);
}
} finally {
compilationDepth--;
}
if (compilationDepth === 0) {
flushModuleScopingQueueAsMuchAsPossible();
}
if (hasSelectorScope(type)) {
const scopes = transitiveScopesFor(type.ngSelectorScope);
patchComponentDefWithScope(ngComponentDef, scopes);
}
if (metadata.schemas) {
if (metadata.standalone) {
ngComponentDef.schemas = metadata.schemas;
} else {
throw new Error(`The 'schemas' was specified for the ${stringifyForError(type)} but is only valid on a component that is standalone.`);
}
} else if (metadata.standalone) {
ngComponentDef.schemas = [];
}
}
return ngComponentDef;
},
// Make the property configurable in dev mode to allow overriding in tests
configurable: !!ngDevMode
});
}
function getStandaloneDefFunctions(type, imports) {
let cachedDirectiveDefs = null;
let cachedPipeDefs = null;
const directiveDefs = () => {
if (!USE_RUNTIME_DEPS_TRACKER_FOR_JIT) {
if (cachedDirectiveDefs === null) {
cachedDirectiveDefs = [getComponentDef(type)];
const seen = /* @__PURE__ */ new Set([type]);
for (const rawDep of imports) {
ngDevMode && verifyStandaloneImport(rawDep, type);
const dep = resolveForwardRef(rawDep);
if (seen.has(dep)) {
continue;
}
seen.add(dep);
if (!!getNgModuleDef(dep)) {
const scope = transitiveScopesFor(dep);
for (const dir of scope.exported.directives) {
const def = getComponentDef(dir) || getDirectiveDef(dir);
if (def && !seen.has(dir)) {
seen.add(dir);
cachedDirectiveDefs.push(def);
}
}
} else {
const def = getComponentDef(dep) || getDirectiveDef(dep);
if (def) {
cachedDirectiveDefs.push(def);
}
}
}
}
return cachedDirectiveDefs;
} else {
if (ngDevMode) {
for (const rawDep of imports) {
verifyStandaloneImport(rawDep, type);
}
}
if (!isComponent(type)) {
return [];
}
const scope = depsTracker.getStandaloneComponentScope(type, imports);
return [...scope.compilation.directives].map((p) => getComponentDef(p) || getDirectiveDef(p)).filter((d) => d !== null);
}
};
const pipeDefs = () => {
if (!USE_RUNTIME_DEPS_TRACKER_FOR_JIT) {
if (cachedPipeDefs === null) {
cachedPipeDefs = [];
const seen = /* @__PURE__ */ new Set();
for (const rawDep of imports) {
const dep = resolveForwardRef(rawDep);
if (seen.has(dep)) {
continue;
}
seen.add(dep);
if (!!getNgModuleDef(dep)) {
const scope = transitiveScopesFor(dep);
for (const pipe2 of scope.exported.pipes) {
const def = getPipeDef$1(pipe2);
if (def && !seen.has(pipe2)) {
seen.add(pipe2);
cachedPipeDefs.push(def);
}
}
} else {
const def = getPipeDef$1(dep);
if (def) {
cachedPipeDefs.push(def);
}
}
}
}
return cachedPipeDefs;
} else {
if (ngDevMode) {
for (const rawDep of imports) {
verifyStandaloneImport(rawDep, type);
}
}
if (!isComponent(type)) {
return [];
}
const scope = depsTracker.getStandaloneComponentScope(type, imports);
return [...scope.compilation.pipes].map((p) => getPipeDef$1(p)).filter((d) => d !== null);
}
};
return {
directiveDefs,
pipeDefs
};
}
function hasSelectorScope(component) {
return component.ngSelectorScope !== void 0;
}
function compileDirective(type, directive) {
let ngDirectiveDef = null;
addDirectiveFactoryDef(type, directive || {});
Object.defineProperty(type, NG_DIR_DEF, {
get: () => {
if (ngDirectiveDef === null) {
const meta = getDirectiveMetadata(type, directive || {});
const compiler = getCompilerFacade({ usage: 0, kind: "directive", type });
ngDirectiveDef = compiler.compileDirective(angularCoreEnv, meta.sourceMapUrl, meta.metadata);
}
return ngDirectiveDef;
},
// Make the property configurable in dev mode to allow overriding in tests
configurable: !!ngDevMode
});
}
function getDirectiveMetadata(type, metadata) {
const name2 = type && type.name;
const sourceMapUrl = `ng:///${name2}/\u0275dir.js`;
const compiler = getCompilerFacade({ usage: 0, kind: "directive", type });
const facade = directiveMetadata(type, metadata);
facade.typeSourceSpan = compiler.createParseSourceSpan("Directive", name2, sourceMapUrl);
if (facade.usesInheritance) {
addDirectiveDefToUndecoratedParents(type);
}
return { metadata: facade, sourceMapUrl };
}
function addDirectiveFactoryDef(type, metadata) {
let ngFactoryDef = null;
Object.defineProperty(type, NG_FACTORY_DEF, {
get: () => {
if (ngFactoryDef === null) {
const meta = getDirectiveMetadata(type, metadata);
const compiler = getCompilerFacade({ usage: 0, kind: "directive", type });
ngFactoryDef = compiler.compileFactory(angularCoreEnv, `ng:///${type.name}/\u0275fac.js`, {
name: meta.metadata.name,
type: meta.metadata.type,
typeArgumentCount: 0,
deps: reflectDependencies(type),
target: compiler.FactoryTarget.Directive
});
}
return ngFactoryDef;
},
// Make the property configurable in dev mode to allow overriding in tests
configurable: !!ngDevMode
});
}
function extendsDirectlyFromObject(type) {
return Object.getPrototypeOf(type.prototype) === Object.prototype;
}
function directiveMetadata(type, metadata) {
const reflect = getReflect();
const propMetadata = reflect.ownPropMetadata(type);
return {
name: type.name,
type,
selector: metadata.selector !== void 0 ? metadata.selector : null,
host: metadata.host || EMPTY_OBJ,
propMetadata,
inputs: metadata.inputs || EMPTY_ARRAY,
outputs: metadata.outputs || EMPTY_ARRAY,
queries: extractQueriesMetadata(type, propMetadata, isContentQuery),
lifecycle: { usesOnChanges: reflect.hasLifecycleHook(type, "ngOnChanges") },
typeSourceSpan: null,
usesInheritance: !extendsDirectlyFromObject(type),
exportAs: extractExportAs(metadata.exportAs),
providers: metadata.providers || null,
viewQueries: extractQueriesMetadata(type, propMetadata, isViewQuery),
isStandalone: !!metadata.standalone,
isSignal: !!metadata.signals,
hostDirectives: metadata.hostDirectives?.map((directive) => typeof directive === "function" ? { directive } : directive) || null
};
}
function addDirectiveDefToUndecoratedParents(type) {
const objPrototype = Object.prototype;
let parent2 = Object.getPrototypeOf(type.prototype).constructor;
while (parent2 && parent2 !== objPrototype) {
if (!getDirectiveDef(parent2) && !getComponentDef(parent2) && shouldAddAbstractDirective(parent2)) {
compileDirective(parent2, null);
}
parent2 = Object.getPrototypeOf(parent2);
}
}
function convertToR3QueryPredicate(selector) {
return typeof selector === "string" ? splitByComma(selector) : resolveForwardRef(selector);
}
function convertToR3QueryMetadata(propertyName, ann) {
return {
propertyName,
predicate: convertToR3QueryPredicate(ann.selector),
descendants: ann.descendants,
first: ann.first,
read: ann.read ? ann.read : null,
static: !!ann.static,
emitDistinctChangesOnly: !!ann.emitDistinctChangesOnly,
isSignal: !!ann.isSignal
};
}
function extractQueriesMetadata(type, propMetadata, isQueryAnn) {
const queriesMeta = [];
for (const field in propMetadata) {
if (propMetadata.hasOwnProperty(field)) {
const annotations = propMetadata[field];
annotations.forEach((ann) => {
if (isQueryAnn(ann)) {
if (!ann.selector) {
throw new Error(`Can't construct a query for the property "${field}" of "${stringifyForError(type)}" since the query selector wasn't defined.`);
}
if (annotations.some(isInputAnnotation)) {
throw new Error(`Cannot combine @Input decorators with query decorators`);
}
queriesMeta.push(convertToR3QueryMetadata(field, ann));
}
});
}
}
return queriesMeta;
}
function extractExportAs(exportAs) {
return exportAs === void 0 ? null : splitByComma(exportAs);
}
function isContentQuery(value2) {
const name2 = value2.ngMetadataName;
return name2 === "ContentChild" || name2 === "ContentChildren";
}
function isViewQuery(value2) {
const name2 = value2.ngMetadataName;
return name2 === "ViewChild" || name2 === "ViewChildren";
}
function isInputAnnotation(value2) {
return value2.ngMetadataName === "Input";
}
function splitByComma(value2) {
return value2.split(",").map((piece) => piece.trim());
}
var LIFECYCLE_HOOKS = [
"ngOnChanges",
"ngOnInit",
"ngOnDestroy",
"ngDoCheck",
"ngAfterViewInit",
"ngAfterViewChecked",
"ngAfterContentInit",
"ngAfterContentChecked"
];
function shouldAddAbstractDirective(type) {
const reflect = getReflect();
if (LIFECYCLE_HOOKS.some((hookName) => reflect.hasLifecycleHook(type, hookName))) {
return true;
}
const propMetadata = reflect.propMetadata(type);
for (const field in propMetadata) {
const annotations = propMetadata[field];
for (let i = 0; i < annotations.length; i++) {
const current = annotations[i];
const metadataName = current.ngMetadataName;
if (isInputAnnotation(current) || isContentQuery(current) || isViewQuery(current) || metadataName === "Output" || metadataName === "HostBinding" || metadataName === "HostListener") {
return true;
}
}
}
return false;
}
function compilePipe(type, meta) {
let ngPipeDef = null;
let ngFactoryDef = null;
Object.defineProperty(type, NG_FACTORY_DEF, {
get: () => {
if (ngFactoryDef === null) {
const metadata = getPipeMetadata(type, meta);
const compiler = getCompilerFacade({ usage: 0, kind: "pipe", type: metadata.type });
ngFactoryDef = compiler.compileFactory(angularCoreEnv, `ng:///${metadata.name}/\u0275fac.js`, {
name: metadata.name,
type: metadata.type,
typeArgumentCount: 0,
deps: reflectDependencies(type),
target: compiler.FactoryTarget.Pipe
});
}
return ngFactoryDef;
},
// Make the property configurable in dev mode to allow overriding in tests
configurable: !!ngDevMode
});
Object.defineProperty(type, NG_PIPE_DEF, {
get: () => {
if (ngPipeDef === null) {
const metadata = getPipeMetadata(type, meta);
const compiler = getCompilerFacade({ usage: 0, kind: "pipe", type: metadata.type });
ngPipeDef = compiler.compilePipe(angularCoreEnv, `ng:///${metadata.name}/\u0275pipe.js`, metadata);
}
return ngPipeDef;
},
// Make the property configurable in dev mode to allow overriding in tests
configurable: !!ngDevMode
});
}
function getPipeMetadata(type, meta) {
return {
type,
name: type.name,
pipeName: meta.name,
pure: meta.pure !== void 0 ? meta.pure : true,
isStandalone: !!meta.standalone
};
}
var Directive = makeDecorator("Directive", (dir = {}) => dir, void 0, void 0, (type, meta) => compileDirective(type, meta));
var Component = makeDecorator("Component", (c = {}) => __spreadValues({ changeDetection: ChangeDetectionStrategy.Default }, c), Directive, void 0, (type, meta) => compileComponent(type, meta));
var Pipe = makeDecorator("Pipe", (p) => __spreadValues({ pure: true }, p), void 0, void 0, (type, meta) => compilePipe(type, meta));
var Input = makePropDecorator("Input", (arg) => {
if (!arg) {
return {};
}
return typeof arg === "string" ? { alias: arg } : arg;
});
var Output = makePropDecorator("Output", (alias) => ({ alias }));
var HostBinding = makePropDecorator("HostBinding", (hostPropertyName) => ({ hostPropertyName }));
var HostListener = makePropDecorator("HostListener", (eventName, args) => ({ eventName, args }));
var NgModule = makeDecorator(
"NgModule",
(ngModule) => ngModule,
void 0,
void 0,
/**
* Decorator that marks the following class as an NgModule, and supplies
* configuration metadata for it.
*
* * The `declarations` option configures the compiler
* with information about what belongs to the NgModule.
* * The `providers` options configures the NgModule's injector to provide
* dependencies the NgModule members.
* * The `imports` and `exports` options bring in members from other modules, and make
* this module's members available to others.
*/
(type, meta) => compileNgModule(type, meta)
);
var Version = class {
constructor(full) {
this.full = full;
const parts = full.split(".");
this.major = parts[0];
this.minor = parts[1];
this.patch = parts.slice(2).join(".");
}
};
var VERSION = new Version("17.3.12");
var _Console = class _Console {
log(message) {
console.log(message);
}
// Note: for reporting errors use `DOM.logError()` as it is platform specific
warn(message) {
console.warn(message);
}
};
_Console.\u0275fac = function Console_Factory(t) {
return new (t || _Console)();
};
_Console.\u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({ token: _Console, factory: _Console.\u0275fac, providedIn: "platform" });
var Console = _Console;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(Console, [{
type: Injectable,
args: [{ providedIn: "platform" }]
}], null, null);
})();
var DIDebugData = class {
constructor() {
this.resolverToTokenToDependencies = /* @__PURE__ */ new WeakMap();
this.resolverToProviders = /* @__PURE__ */ new WeakMap();
this.standaloneInjectorToComponent = /* @__PURE__ */ new WeakMap();
}
reset() {
this.resolverToTokenToDependencies = /* @__PURE__ */ new WeakMap();
this.resolverToProviders = /* @__PURE__ */ new WeakMap();
this.standaloneInjectorToComponent = /* @__PURE__ */ new WeakMap();
}
};
var frameworkDIDebugData = new DIDebugData();
function getFrameworkDIDebugData() {
return frameworkDIDebugData;
}
function setupFrameworkInjectorProfiler() {
frameworkDIDebugData.reset();
setInjectorProfiler((injectorProfilerEvent) => handleInjectorProfilerEvent(injectorProfilerEvent));
}
function handleInjectorProfilerEvent(injectorProfilerEvent) {
const { context: context2, type } = injectorProfilerEvent;
if (type === 0) {
handleInjectEvent(context2, injectorProfilerEvent.service);
} else if (type === 1) {
handleInstanceCreatedByInjectorEvent(context2, injectorProfilerEvent.instance);
} else if (type === 2) {
handleProviderConfiguredEvent(context2, injectorProfilerEvent.providerRecord);
}
}
function handleInjectEvent(context2, data2) {
const diResolver = getDIResolver(context2.injector);
if (diResolver === null) {
throwError2("An Inject event must be run within an injection context.");
}
const diResolverToInstantiatedToken = frameworkDIDebugData.resolverToTokenToDependencies;
if (!diResolverToInstantiatedToken.has(diResolver)) {
diResolverToInstantiatedToken.set(diResolver, /* @__PURE__ */ new WeakMap());
}
if (!canBeHeldWeakly(context2.token)) {
return;
}
const instantiatedTokenToDependencies = diResolverToInstantiatedToken.get(diResolver);
if (!instantiatedTokenToDependencies.has(context2.token)) {
instantiatedTokenToDependencies.set(context2.token, []);
}
const { token, value: value2, flags } = data2;
assertDefined(context2.token, "Injector profiler context token is undefined.");
const dependencies = instantiatedTokenToDependencies.get(context2.token);
assertDefined(dependencies, "Could not resolve dependencies for token.");
if (context2.injector instanceof NodeInjector) {
dependencies.push({ token, value: value2, flags, injectedIn: getNodeInjectorContext(context2.injector) });
} else {
dependencies.push({ token, value: value2, flags });
}
}
function getNodeInjectorContext(injector) {
if (!(injector instanceof NodeInjector)) {
throwError2("getNodeInjectorContext must be called with a NodeInjector");
}
const lView = getNodeInjectorLView(injector);
const tNode = getNodeInjectorTNode(injector);
if (tNode === null) {
return;
}
assertTNodeForLView(tNode, lView);
return { lView, tNode };
}
function handleInstanceCreatedByInjectorEvent(context2, data2) {
const { value: value2 } = data2;
if (getDIResolver(context2.injector) === null) {
throwError2("An InjectorCreatedInstance event must be run within an injection context.");
}
let standaloneComponent = void 0;
if (typeof value2 === "object") {
standaloneComponent = value2?.constructor;
}
if (standaloneComponent === void 0 || !isStandaloneComponent(standaloneComponent)) {
return;
}
const environmentInjector = context2.injector.get(EnvironmentInjector, null, { optional: true });
if (environmentInjector === null) {
return;
}
const { standaloneInjectorToComponent } = frameworkDIDebugData;
if (standaloneInjectorToComponent.has(environmentInjector)) {
return;
}
standaloneInjectorToComponent.set(environmentInjector, standaloneComponent);
}
function isStandaloneComponent(value2) {
const def = getComponentDef(value2);
return !!def?.standalone;
}
function handleProviderConfiguredEvent(context2, data2) {
const { resolverToProviders } = frameworkDIDebugData;
let diResolver;
if (context2?.injector instanceof NodeInjector) {
diResolver = getNodeInjectorTNode(context2.injector);
} else {
diResolver = context2.injector;
}
if (diResolver === null) {
throwError2("A ProviderConfigured event must be run within an injection context.");
}
if (!resolverToProviders.has(diResolver)) {
resolverToProviders.set(diResolver, []);
}
resolverToProviders.get(diResolver).push(data2);
}
function getDIResolver(injector) {
let diResolver = null;
if (injector === void 0) {
return diResolver;
}
if (injector instanceof NodeInjector) {
diResolver = getNodeInjectorLView(injector);
} else {
diResolver = injector;
}
return diResolver;
}
function canBeHeldWeakly(value2) {
return value2 !== null && (typeof value2 === "object" || typeof value2 === "function" || typeof value2 === "symbol");
}
function applyChanges(component) {
ngDevMode && assertDefined(component, "component");
markViewDirty(getComponentViewByInstance(component));
getRootComponents(component).forEach((rootComponent) => detectChanges(rootComponent));
}
function detectChanges(component) {
const view = getComponentViewByInstance(component);
view[FLAGS] |= 1024;
detectChangesInternal(view);
}
function getDependenciesFromInjectable(injector, token) {
const instance = injector.get(token, null, { self: true, optional: true });
if (instance === null) {
throw new Error(`Unable to determine instance of ${token} in given injector`);
}
const unformattedDependencies = getDependenciesForTokenInInjector(token, injector);
const resolutionPath = getInjectorResolutionPath(injector);
const dependencies = unformattedDependencies.map((dep) => {
const formattedDependency = {
value: dep.value
};
const flags = dep.flags;
formattedDependency.flags = {
optional: (8 & flags) === 8,
host: (1 & flags) === 1,
self: (2 & flags) === 2,
skipSelf: (4 & flags) === 4
};
for (let i = 0; i < resolutionPath.length; i++) {
const injectorToCheck = resolutionPath[i];
if (i === 0 && formattedDependency.flags.skipSelf) {
continue;
}
if (formattedDependency.flags.host && injectorToCheck instanceof EnvironmentInjector) {
break;
}
const instance2 = injectorToCheck.get(dep.token, null, { self: true, optional: true });
if (instance2 !== null) {
if (formattedDependency.flags.host) {
const firstInjector = resolutionPath[0];
const lookupFromFirstInjector = firstInjector.get(dep.token, null, __spreadProps(__spreadValues({}, formattedDependency.flags), { optional: true }));
if (lookupFromFirstInjector !== null) {
formattedDependency.providedIn = injectorToCheck;
}
break;
}
formattedDependency.providedIn = injectorToCheck;
break;
}
if (i === 0 && formattedDependency.flags.self) {
break;
}
}
if (dep.token)
formattedDependency.token = dep.token;
return formattedDependency;
});
return { instance, dependencies };
}
function getDependenciesForTokenInInjector(token, injector) {
const { resolverToTokenToDependencies } = getFrameworkDIDebugData();
if (!(injector instanceof NodeInjector)) {
return resolverToTokenToDependencies.get(injector)?.get?.(token) ?? [];
}
const lView = getNodeInjectorLView(injector);
const tokenDependencyMap = resolverToTokenToDependencies.get(lView);
const dependencies = tokenDependencyMap?.get(token) ?? [];
return dependencies.filter((dependency) => {
const dependencyNode = dependency.injectedIn?.tNode;
if (dependencyNode === void 0) {
return false;
}
const instanceNode = getNodeInjectorTNode(injector);
assertTNode(dependencyNode);
assertTNode(instanceNode);
return dependencyNode === instanceNode;
});
}
function getProviderImportsContainer(injector) {
const { standaloneInjectorToComponent } = getFrameworkDIDebugData();
if (standaloneInjectorToComponent.has(injector)) {
return standaloneInjectorToComponent.get(injector);
}
const defTypeRef = injector.get(NgModuleRef$1, null, { self: true, optional: true });
if (defTypeRef === null) {
return null;
}
if (defTypeRef.instance === null) {
return null;
}
return defTypeRef.instance.constructor;
}
function getNodeInjectorProviders(injector) {
const diResolver = getNodeInjectorTNode(injector);
const { resolverToProviders } = getFrameworkDIDebugData();
return resolverToProviders.get(diResolver) ?? [];
}
function getProviderImportPaths(providerImportsContainer) {
const providerToPath = /* @__PURE__ */ new Map();
const visitedContainers = /* @__PURE__ */ new Set();
const visitor = walkProviderTreeToDiscoverImportPaths(providerToPath, visitedContainers);
walkProviderTree(providerImportsContainer, visitor, [], /* @__PURE__ */ new Set());
return providerToPath;
}
function walkProviderTreeToDiscoverImportPaths(providerToPath, visitedContainers) {
return (provider, container) => {
if (!providerToPath.has(provider)) {
providerToPath.set(provider, [container]);
}
if (!visitedContainers.has(container)) {
for (const prov of providerToPath.keys()) {
const existingImportPath = providerToPath.get(prov);
let containerDef = getInjectorDef(container);
if (!containerDef) {
const ngModule = container.ngModule;
containerDef = getInjectorDef(ngModule);
}
if (!containerDef) {
return;
}
const lastContainerAddedToPath = existingImportPath[0];
let isNextStepInPath = false;
deepForEach(containerDef.imports, (moduleImport) => {
if (isNextStepInPath) {
return;
}
isNextStepInPath = moduleImport.ngModule === lastContainerAddedToPath || moduleImport === lastContainerAddedToPath;
if (isNextStepInPath) {
providerToPath.get(prov)?.unshift(container);
}
});
}
}
visitedContainers.add(container);
};
}
function getEnvironmentInjectorProviders(injector) {
const providerRecordsWithoutImportPaths = getFrameworkDIDebugData().resolverToProviders.get(injector) ?? [];
if (isPlatformInjector(injector)) {
return providerRecordsWithoutImportPaths;
}
const providerImportsContainer = getProviderImportsContainer(injector);
if (providerImportsContainer === null) {
return providerRecordsWithoutImportPaths;
}
const providerToPath = getProviderImportPaths(providerImportsContainer);
const providerRecords = [];
for (const providerRecord of providerRecordsWithoutImportPaths) {
const provider = providerRecord.provider;
const token = provider.provide;
if (token === ENVIRONMENT_INITIALIZER || token === INJECTOR_DEF_TYPES) {
continue;
}
let importPath = providerToPath.get(provider) ?? [];
const def = getComponentDef(providerImportsContainer);
const isStandaloneComponent2 = !!def?.standalone;
if (isStandaloneComponent2) {
importPath = [providerImportsContainer, ...importPath];
}
providerRecords.push(__spreadProps(__spreadValues({}, providerRecord), { importPath }));
}
return providerRecords;
}
function isPlatformInjector(injector) {
return injector instanceof R3Injector && injector.scopes.has("platform");
}
function getInjectorProviders(injector) {
if (injector instanceof NodeInjector) {
return getNodeInjectorProviders(injector);
} else if (injector instanceof EnvironmentInjector) {
return getEnvironmentInjectorProviders(injector);
}
throwError2("getInjectorProviders only supports NodeInjector and EnvironmentInjector");
}
function getInjectorMetadata(injector) {
if (injector instanceof NodeInjector) {
const lView = getNodeInjectorLView(injector);
const tNode = getNodeInjectorTNode(injector);
assertTNodeForLView(tNode, lView);
return { type: "element", source: getNativeByTNode(tNode, lView) };
}
if (injector instanceof R3Injector) {
return { type: "environment", source: injector.source ?? null };
}
if (injector instanceof NullInjector) {
return { type: "null", source: null };
}
return null;
}
function getInjectorResolutionPath(injector) {
const resolutionPath = [injector];
getInjectorResolutionPathHelper(injector, resolutionPath);
return resolutionPath;
}
function getInjectorResolutionPathHelper(injector, resolutionPath) {
const parent2 = getInjectorParent(injector);
if (parent2 === null) {
if (injector instanceof NodeInjector) {
const firstInjector = resolutionPath[0];
if (firstInjector instanceof NodeInjector) {
const moduleInjector = getModuleInjectorOfNodeInjector(firstInjector);
if (moduleInjector === null) {
throwError2("NodeInjector must have some connection to the module injector tree");
}
resolutionPath.push(moduleInjector);
getInjectorResolutionPathHelper(moduleInjector, resolutionPath);
}
return resolutionPath;
}
} else {
resolutionPath.push(parent2);
getInjectorResolutionPathHelper(parent2, resolutionPath);
}
return resolutionPath;
}
function getInjectorParent(injector) {
if (injector instanceof R3Injector) {
return injector.parent;
}
let tNode;
let lView;
if (injector instanceof NodeInjector) {
tNode = getNodeInjectorTNode(injector);
lView = getNodeInjectorLView(injector);
} else if (injector instanceof NullInjector) {
return null;
} else if (injector instanceof ChainedInjector) {
return injector.parentInjector;
} else {
throwError2("getInjectorParent only support injectors of type R3Injector, NodeInjector, NullInjector, ChainedInjector");
}
const parentLocation = getParentInjectorLocation(tNode, lView);
if (hasParentInjector(parentLocation)) {
const parentInjectorIndex = getParentInjectorIndex(parentLocation);
const parentLView = getParentInjectorView(parentLocation, lView);
const parentTView = parentLView[TVIEW];
const parentTNode = parentTView.data[
parentInjectorIndex + 8
/* NodeInjectorOffset.TNODE */
];
return new NodeInjector(parentTNode, parentLView);
} else {
const chainedInjector = lView[INJECTOR];
const injectorParent = chainedInjector.injector?.parent;
if (injectorParent instanceof NodeInjector) {
return injectorParent;
}
}
return null;
}
function getModuleInjectorOfNodeInjector(injector) {
let lView;
if (injector instanceof NodeInjector) {
lView = getNodeInjectorLView(injector);
} else {
throwError2("getModuleInjectorOfNodeInjector must be called with a NodeInjector");
}
const inj = lView[INJECTOR];
const moduleInjector = inj instanceof ChainedInjector ? inj.parentInjector : inj.parent;
if (!moduleInjector) {
throwError2("NodeInjector must have some connection to the module injector tree");
}
return moduleInjector;
}
var GLOBAL_PUBLISH_EXPANDO_KEY = "ng";
var globalUtilsFunctions = {
/**
* Warning: functions that start with `ɵ` are considered *INTERNAL* and should not be relied upon
* in application's code. The contract of those functions might be changed in any release and/or a
* function can be removed completely.
*/
"\u0275getDependenciesFromInjectable": getDependenciesFromInjectable,
"\u0275getInjectorProviders": getInjectorProviders,
"\u0275getInjectorResolutionPath": getInjectorResolutionPath,
"\u0275getInjectorMetadata": getInjectorMetadata,
"\u0275setProfiler": setProfiler,
"getDirectiveMetadata": getDirectiveMetadata$1,
"getComponent": getComponent$1,
"getContext": getContext,
"getListeners": getListeners,
"getOwningComponent": getOwningComponent,
"getHostElement": getHostElement,
"getInjector": getInjector,
"getRootComponents": getRootComponents,
"getDirectives": getDirectives,
"applyChanges": applyChanges,
"isSignal": isSignal
};
var _published = false;
function publishDefaultGlobalUtils$1() {
if (!_published) {
_published = true;
if (typeof window !== "undefined") {
setupFrameworkInjectorProfiler();
}
for (const [methodName, method] of Object.entries(globalUtilsFunctions)) {
publishGlobalUtil(methodName, method);
}
}
}
function publishGlobalUtil(name2, fn) {
if (typeof COMPILED === "undefined" || !COMPILED) {
const w = _global;
ngDevMode && assertDefined(fn, "function not defined");
w[GLOBAL_PUBLISH_EXPANDO_KEY] ??= {};
w[GLOBAL_PUBLISH_EXPANDO_KEY][name2] = fn;
}
}
var TESTABILITY = new InjectionToken("");
var TESTABILITY_GETTER = new InjectionToken("");
var _Testability = class _Testability {
constructor(_ngZone, registry, testabilityGetter) {
this._ngZone = _ngZone;
this.registry = registry;
this._pendingCount = 0;
this._isZoneStable = true;
this._callbacks = [];
this.taskTrackingZone = null;
if (!_testabilityGetter) {
setTestabilityGetter(testabilityGetter);
testabilityGetter.addToWindow(registry);
}
this._watchAngularEvents();
_ngZone.run(() => {
this.taskTrackingZone = typeof Zone == "undefined" ? null : Zone.current.get("TaskTrackingZone");
});
}
_watchAngularEvents() {
this._ngZone.onUnstable.subscribe({
next: () => {
this._isZoneStable = false;
}
});
this._ngZone.runOutsideAngular(() => {
this._ngZone.onStable.subscribe({
next: () => {
NgZone.assertNotInAngularZone();
queueMicrotask(() => {
this._isZoneStable = true;
this._runCallbacksIfReady();
});
}
});
});
}
/**
* Increases the number of pending request
* @deprecated pending requests are now tracked with zones.
*/
increasePendingRequestCount() {
this._pendingCount += 1;
return this._pendingCount;
}
/**
* Decreases the number of pending request
* @deprecated pending requests are now tracked with zones
*/
decreasePendingRequestCount() {
this._pendingCount -= 1;
if (this._pendingCount < 0) {
throw new Error("pending async requests below zero");
}
this._runCallbacksIfReady();
return this._pendingCount;
}
/**
* Whether an associated application is stable
*/
isStable() {
return this._isZoneStable && this._pendingCount === 0 && !this._ngZone.hasPendingMacrotasks;
}
_runCallbacksIfReady() {
if (this.isStable()) {
queueMicrotask(() => {
while (this._callbacks.length !== 0) {
let cb = this._callbacks.pop();
clearTimeout(cb.timeoutId);
cb.doneCb();
}
});
} else {
let pending = this.getPendingTasks();
this._callbacks = this._callbacks.filter((cb) => {
if (cb.updateCb && cb.updateCb(pending)) {
clearTimeout(cb.timeoutId);
return false;
}
return true;
});
}
}
getPendingTasks() {
if (!this.taskTrackingZone) {
return [];
}
return this.taskTrackingZone.macroTasks.map((t) => {
return {
source: t.source,
// From TaskTrackingZone:
// https://github.com/angular/zone.js/blob/master/lib/zone-spec/task-tracking.ts#L40
creationLocation: t.creationLocation,
data: t.data
};
});
}
addCallback(cb, timeout, updateCb) {
let timeoutId = -1;
if (timeout && timeout > 0) {
timeoutId = setTimeout(() => {
this._callbacks = this._callbacks.filter((cb2) => cb2.timeoutId !== timeoutId);
cb();
}, timeout);
}
this._callbacks.push({ doneCb: cb, timeoutId, updateCb });
}
/**
* Wait for the application to be stable with a timeout. If the timeout is reached before that
* happens, the callback receives a list of the macro tasks that were pending, otherwise null.
*
* @param doneCb The callback to invoke when Angular is stable or the timeout expires
* whichever comes first.
* @param timeout Optional. The maximum time to wait for Angular to become stable. If not
* specified, whenStable() will wait forever.
* @param updateCb Optional. If specified, this callback will be invoked whenever the set of
* pending macrotasks changes. If this callback returns true doneCb will not be invoked
* and no further updates will be issued.
*/
whenStable(doneCb, timeout, updateCb) {
if (updateCb && !this.taskTrackingZone) {
throw new Error('Task tracking zone is required when passing an update callback to whenStable(). Is "zone.js/plugins/task-tracking" loaded?');
}
this.addCallback(doneCb, timeout, updateCb);
this._runCallbacksIfReady();
}
/**
* Get the number of pending requests
* @deprecated pending requests are now tracked with zones
*/
getPendingRequestCount() {
return this._pendingCount;
}
/**
* Registers an application with a testability hook so that it can be tracked.
* @param token token of application, root element
*
* @internal
*/
registerApplication(token) {
this.registry.registerApplication(token, this);
}
/**
* Unregisters an application.
* @param token token of application, root element
*
* @internal
*/
unregisterApplication(token) {
this.registry.unregisterApplication(token);
}
/**
* Find providers by name
* @param using The root element to search from
* @param provider The name of binding variable
* @param exactMatch Whether using exactMatch
*/
findProviders(using, provider, exactMatch) {
return [];
}
};
_Testability.\u0275fac = function Testability_Factory(t) {
return new (t || _Testability)(\u0275\u0275inject(NgZone), \u0275\u0275inject(TestabilityRegistry), \u0275\u0275inject(TESTABILITY_GETTER));
};
_Testability.\u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({ token: _Testability, factory: _Testability.\u0275fac });
var Testability = _Testability;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(Testability, [{
type: Injectable
}], () => [{ type: NgZone }, { type: TestabilityRegistry }, { type: void 0, decorators: [{
type: Inject,
args: [TESTABILITY_GETTER]
}] }], null);
})();
var _TestabilityRegistry = class _TestabilityRegistry {
constructor() {
this._applications = /* @__PURE__ */ new Map();
}
/**
* Registers an application with a testability hook so that it can be tracked
* @param token token of application, root element
* @param testability Testability hook
*/
registerApplication(token, testability) {
this._applications.set(token, testability);
}
/**
* Unregisters an application.
* @param token token of application, root element
*/
unregisterApplication(token) {
this._applications.delete(token);
}
/**
* Unregisters all applications
*/
unregisterAllApplications() {
this._applications.clear();
}
/**
* Get a testability hook associated with the application
* @param elem root element
*/
getTestability(elem2) {
return this._applications.get(elem2) || null;
}
/**
* Get all registered testabilities
*/
getAllTestabilities() {
return Array.from(this._applications.values());
}
/**
* Get all registered applications(root elements)
*/
getAllRootElements() {
return Array.from(this._applications.keys());
}
/**
* Find testability of a node in the Tree
* @param elem node
* @param findInAncestors whether finding testability in ancestors if testability was not found in
* current node
*/
findTestabilityInTree(elem2, findInAncestors = true) {
return _testabilityGetter?.findTestabilityInTree(this, elem2, findInAncestors) ?? null;
}
};
_TestabilityRegistry.\u0275fac = function TestabilityRegistry_Factory(t) {
return new (t || _TestabilityRegistry)();
};
_TestabilityRegistry.\u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({ token: _TestabilityRegistry, factory: _TestabilityRegistry.\u0275fac, providedIn: "platform" });
var TestabilityRegistry = _TestabilityRegistry;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(TestabilityRegistry, [{
type: Injectable,
args: [{ providedIn: "platform" }]
}], null, null);
})();
function setTestabilityGetter(getter) {
_testabilityGetter = getter;
}
var _testabilityGetter;
function isPromise2(obj) {
return !!obj && typeof obj.then === "function";
}
function isSubscribable(obj) {
return !!obj && typeof obj.subscribe === "function";
}
var APP_INITIALIZER = new InjectionToken(ngDevMode ? "Application Initializer" : "");
var _ApplicationInitStatus = class _ApplicationInitStatus {
constructor() {
this.initialized = false;
this.done = false;
this.donePromise = new Promise((res, rej) => {
this.resolve = res;
this.reject = rej;
});
this.appInits = inject(APP_INITIALIZER, { optional: true }) ?? [];
if ((typeof ngDevMode === "undefined" || ngDevMode) && !Array.isArray(this.appInits)) {
throw new RuntimeError(-209, `Unexpected type of the \`APP_INITIALIZER\` token value (expected an array, but got ${typeof this.appInits}). Please check that the \`APP_INITIALIZER\` token is configured as a \`multi: true\` provider.`);
}
}
/** @internal */
runInitializers() {
if (this.initialized) {
return;
}
const asyncInitPromises = [];
for (const appInits of this.appInits) {
const initResult = appInits();
if (isPromise2(initResult)) {
asyncInitPromises.push(initResult);
} else if (isSubscribable(initResult)) {
const observableAsPromise = new Promise((resolve, reject) => {
initResult.subscribe({ complete: resolve, error: reject });
});
asyncInitPromises.push(observableAsPromise);
}
}
const complete = () => {
this.done = true;
this.resolve();
};
Promise.all(asyncInitPromises).then(() => {
complete();
}).catch((e) => {
this.reject(e);
});
if (asyncInitPromises.length === 0) {
complete();
}
this.initialized = true;
}
};
_ApplicationInitStatus.\u0275fac = function ApplicationInitStatus_Factory(t) {
return new (t || _ApplicationInitStatus)();
};
_ApplicationInitStatus.\u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({ token: _ApplicationInitStatus, factory: _ApplicationInitStatus.\u0275fac, providedIn: "root" });
var ApplicationInitStatus = _ApplicationInitStatus;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(ApplicationInitStatus, [{
type: Injectable,
args: [{ providedIn: "root" }]
}], () => [], null);
})();
var APP_BOOTSTRAP_LISTENER = new InjectionToken(ngDevMode ? "appBootstrapListener" : "");
function publishDefaultGlobalUtils() {
ngDevMode && publishDefaultGlobalUtils$1();
}
function publishSignalConfiguration() {
setThrowInvalidWriteToSignalError(() => {
throw new RuntimeError(600, ngDevMode && "Writing to signals is not allowed in a `computed` or an `effect` by default. Use `allowSignalWrites` in the `CreateEffectOptions` to enable this inside effects.");
});
}
function isBoundToModule(cf) {
return cf.isBoundToModule;
}
function _callAndReportToErrorHandler(errorHandler2, ngZone, callback) {
try {
const result = callback();
if (isPromise2(result)) {
return result.catch((e) => {
ngZone.runOutsideAngular(() => errorHandler2.handleError(e));
throw e;
});
}
return result;
} catch (e) {
ngZone.runOutsideAngular(() => errorHandler2.handleError(e));
throw e;
}
}
function optionsReducer(dst, objs) {
if (Array.isArray(objs)) {
return objs.reduce(optionsReducer, dst);
}
return __spreadValues(__spreadValues({}, dst), objs);
}
var _ApplicationRef = class _ApplicationRef {
constructor() {
this._bootstrapListeners = [];
this._runningTick = false;
this._destroyed = false;
this._destroyListeners = [];
this._views = [];
this.internalErrorHandler = inject(INTERNAL_APPLICATION_ERROR_HANDLER);
this.afterRenderEffectManager = inject(AfterRenderEventManager);
this.externalTestViews = /* @__PURE__ */ new Set();
this.beforeRender = new Subject();
this.afterTick = new Subject();
this.componentTypes = [];
this.components = [];
this.isStable = inject(PendingTasks).hasPendingTasks.pipe(map((pending) => !pending));
this._injector = inject(EnvironmentInjector);
}
/**
* Indicates whether this instance was destroyed.
*/
get destroyed() {
return this._destroyed;
}
/**
* The `EnvironmentInjector` used to create this application.
*/
get injector() {
return this._injector;
}
/**
* Bootstrap a component onto the element identified by its selector or, optionally, to a
* specified element.
*
* @usageNotes
* ### Bootstrap process
*
* When bootstrapping a component, Angular mounts it onto a target DOM element
* and kicks off automatic change detection. The target DOM element can be
* provided using the `rootSelectorOrNode` argument.
*
* If the target DOM element is not provided, Angular tries to find one on a page
* using the `selector` of the component that is being bootstrapped
* (first matched element is used).
*
* ### Example
*
* Generally, we define the component to bootstrap in the `bootstrap` array of `NgModule`,
* but it requires us to know the component while writing the application code.
*
* Imagine a situation where we have to wait for an API call to decide about the component to
* bootstrap. We can use the `ngDoBootstrap` hook of the `NgModule` and call this method to
* dynamically bootstrap a component.
*
* {@example core/ts/platform/platform.ts region='componentSelector'}
*
* Optionally, a component can be mounted onto a DOM element that does not match the
* selector of the bootstrapped component.
*
* In the following example, we are providing a CSS selector to match the target element.
*
* {@example core/ts/platform/platform.ts region='cssSelector'}
*
* While in this example, we are providing reference to a DOM node.
*
* {@example core/ts/platform/platform.ts region='domNode'}
*/
bootstrap(componentOrFactory, rootSelectorOrNode) {
(typeof ngDevMode === "undefined" || ngDevMode) && this.warnIfDestroyed();
const isComponentFactory = componentOrFactory instanceof ComponentFactory$1;
const initStatus = this._injector.get(ApplicationInitStatus);
if (!initStatus.done) {
const standalone2 = !isComponentFactory && isStandalone(componentOrFactory);
const errorMessage = (typeof ngDevMode === "undefined" || ngDevMode) && "Cannot bootstrap as there are still asynchronous initializers running." + (standalone2 ? "" : " Bootstrap components in the `ngDoBootstrap` method of the root module.");
throw new RuntimeError(405, errorMessage);
}
let componentFactory;
if (isComponentFactory) {
componentFactory = componentOrFactory;
} else {
const resolver = this._injector.get(ComponentFactoryResolver$1);
componentFactory = resolver.resolveComponentFactory(componentOrFactory);
}
this.componentTypes.push(componentFactory.componentType);
const ngModule = isBoundToModule(componentFactory) ? void 0 : this._injector.get(NgModuleRef$1);
const selectorOrNode = rootSelectorOrNode || componentFactory.selector;
const compRef = componentFactory.create(Injector.NULL, [], selectorOrNode, ngModule);
const nativeElement = compRef.location.nativeElement;
const testability = compRef.injector.get(TESTABILITY, null);
testability?.registerApplication(nativeElement);
compRef.onDestroy(() => {
this.detachView(compRef.hostView);
remove(this.components, compRef);
testability?.unregisterApplication(nativeElement);
});
this._loadComponent(compRef);
if (typeof ngDevMode === "undefined" || ngDevMode) {
const _console = this._injector.get(Console);
_console.log(`Angular is running in development mode.`);
}
return compRef;
}
/**
* Invoke this method to explicitly process change detection and its side-effects.
*
* In development mode, `tick()` also performs a second change detection cycle to ensure that no
* further changes are detected. If additional changes are picked up during this second cycle,
* bindings in the app have side-effects that cannot be resolved in a single change detection
* pass.
* In this case, Angular throws an error, since an Angular application can only have one change
* detection pass during which all change detection must complete.
*/
tick() {
this._tick(true);
}
/** @internal */
_tick(refreshViews) {
(typeof ngDevMode === "undefined" || ngDevMode) && this.warnIfDestroyed();
if (this._runningTick) {
throw new RuntimeError(101, ngDevMode && "ApplicationRef.tick is called recursively");
}
const prevConsumer = setActiveConsumer(null);
try {
this._runningTick = true;
this.detectChangesInAttachedViews(refreshViews);
if (typeof ngDevMode === "undefined" || ngDevMode) {
for (let view of this._views) {
view.checkNoChanges();
}
}
} catch (e) {
this.internalErrorHandler(e);
} finally {
this.afterTick.next();
this._runningTick = false;
setActiveConsumer(prevConsumer);
}
}
detectChangesInAttachedViews(refreshViews) {
let runs = 0;
const afterRenderEffectManager = this.afterRenderEffectManager;
while (true) {
if (runs === MAXIMUM_REFRESH_RERUNS) {
throw new RuntimeError(103, ngDevMode && "Infinite change detection while refreshing application views. Ensure afterRender or queueStateUpdate hooks are not continuously causing updates.");
}
if (refreshViews) {
const isFirstPass = runs === 0;
this.beforeRender.next(isFirstPass);
for (let { _lView, notifyErrorHandler } of this._views) {
detectChangesInViewIfRequired(_lView, isFirstPass, notifyErrorHandler);
}
}
runs++;
afterRenderEffectManager.executeInternalCallbacks();
if ([...this.externalTestViews.keys(), ...this._views].some(({ _lView }) => shouldRecheckView(_lView))) {
continue;
}
afterRenderEffectManager.execute();
if (![...this.externalTestViews.keys(), ...this._views].some(({ _lView }) => shouldRecheckView(_lView))) {
break;
}
}
}
/**
* Attaches a view so that it will be dirty checked.
* The view will be automatically detached when it is destroyed.
* This will throw if the view is already attached to a ViewContainer.
*/
attachView(viewRef) {
(typeof ngDevMode === "undefined" || ngDevMode) && this.warnIfDestroyed();
const view = viewRef;
this._views.push(view);
view.attachToAppRef(this);
}
/**
* Detaches a view from dirty checking again.
*/
detachView(viewRef) {
(typeof ngDevMode === "undefined" || ngDevMode) && this.warnIfDestroyed();
const view = viewRef;
remove(this._views, view);
view.detachFromAppRef();
}
_loadComponent(componentRef) {
this.attachView(componentRef.hostView);
this.tick();
this.components.push(componentRef);
const listeners = this._injector.get(APP_BOOTSTRAP_LISTENER, []);
if (ngDevMode && !Array.isArray(listeners)) {
throw new RuntimeError(-209, `Unexpected type of the \`APP_BOOTSTRAP_LISTENER\` token value (expected an array, but got ${typeof listeners}). Please check that the \`APP_BOOTSTRAP_LISTENER\` token is configured as a \`multi: true\` provider.`);
}
[...this._bootstrapListeners, ...listeners].forEach((listener) => listener(componentRef));
}
/** @internal */
ngOnDestroy() {
if (this._destroyed)
return;
try {
this._destroyListeners.forEach((listener) => listener());
this._views.slice().forEach((view) => view.destroy());
} finally {
this._destroyed = true;
this._views = [];
this._bootstrapListeners = [];
this._destroyListeners = [];
}
}
/**
* Registers a listener to be called when an instance is destroyed.
*
* @param callback A callback function to add as a listener.
* @returns A function which unregisters a listener.
*/
onDestroy(callback) {
(typeof ngDevMode === "undefined" || ngDevMode) && this.warnIfDestroyed();
this._destroyListeners.push(callback);
return () => remove(this._destroyListeners, callback);
}
/**
* Destroys an Angular application represented by this `ApplicationRef`. Calling this function
* will destroy the associated environment injectors as well as all the bootstrapped components
* with their views.
*/
destroy() {
if (this._destroyed) {
throw new RuntimeError(406, ngDevMode && "This instance of the `ApplicationRef` has already been destroyed.");
}
const injector = this._injector;
if (injector.destroy && !injector.destroyed) {
injector.destroy();
}
}
/**
* Returns the number of attached views.
*/
get viewCount() {
return this._views.length;
}
warnIfDestroyed() {
if ((typeof ngDevMode === "undefined" || ngDevMode) && this._destroyed) {
console.warn(formatRuntimeError(406, "This instance of the `ApplicationRef` has already been destroyed."));
}
}
};
_ApplicationRef.\u0275fac = function ApplicationRef_Factory(t) {
return new (t || _ApplicationRef)();
};
_ApplicationRef.\u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({ token: _ApplicationRef, factory: _ApplicationRef.\u0275fac, providedIn: "root" });
var ApplicationRef = _ApplicationRef;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(ApplicationRef, [{
type: Injectable,
args: [{ providedIn: "root" }]
}], null, null);
})();
function remove(list, el) {
const index2 = list.indexOf(el);
if (index2 > -1) {
list.splice(index2, 1);
}
}
function detectChangesInViewIfRequired(lView, isFirstPass, notifyErrorHandler) {
if (!isFirstPass && !shouldRecheckView(lView)) {
return;
}
detectChangesInView(lView, notifyErrorHandler, isFirstPass);
}
function shouldRecheckView(view) {
return requiresRefreshOrTraversal(view);
}
function detectChangesInView(lView, notifyErrorHandler, isFirstPass) {
let mode;
if (isFirstPass) {
mode = 0;
lView[FLAGS] |= 1024;
} else if (lView[FLAGS] & 64) {
mode = 0;
} else {
mode = 1;
}
detectChangesInternal(lView, notifyErrorHandler, mode);
}
var ModuleWithComponentFactories = class {
constructor(ngModuleFactory, componentFactories) {
this.ngModuleFactory = ngModuleFactory;
this.componentFactories = componentFactories;
}
};
var _Compiler = class _Compiler {
/**
* Compiles the given NgModule and all of its components. All templates of the components
* have to be inlined.
*/
compileModuleSync(moduleType) {
return new NgModuleFactory(moduleType);
}
/**
* Compiles the given NgModule and all of its components
*/
compileModuleAsync(moduleType) {
return Promise.resolve(this.compileModuleSync(moduleType));
}
/**
* Same as {@link #compileModuleSync} but also creates ComponentFactories for all components.
*/
compileModuleAndAllComponentsSync(moduleType) {
const ngModuleFactory = this.compileModuleSync(moduleType);
const moduleDef = getNgModuleDef(moduleType);
const componentFactories = maybeUnwrapFn(moduleDef.declarations).reduce((factories, declaration) => {
const componentDef = getComponentDef(declaration);
componentDef && factories.push(new ComponentFactory(componentDef));
return factories;
}, []);
return new ModuleWithComponentFactories(ngModuleFactory, componentFactories);
}
/**
* Same as {@link #compileModuleAsync} but also creates ComponentFactories for all components.
*/
compileModuleAndAllComponentsAsync(moduleType) {
return Promise.resolve(this.compileModuleAndAllComponentsSync(moduleType));
}
/**
* Clears all caches.
*/
clearCache() {
}
/**
* Clears the cache for the given component/ngModule.
*/
clearCacheFor(type) {
}
/**
* Returns the id for a given NgModule, if one is defined and known to the compiler.
*/
getModuleId(moduleType) {
return void 0;
}
};
_Compiler.\u0275fac = function Compiler_Factory(t) {
return new (t || _Compiler)();
};
_Compiler.\u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({ token: _Compiler, factory: _Compiler.\u0275fac, providedIn: "root" });
var Compiler = _Compiler;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(Compiler, [{
type: Injectable,
args: [{ providedIn: "root" }]
}], null, null);
})();
var COMPILER_OPTIONS = new InjectionToken(ngDevMode ? "compilerOptions" : "");
function compileNgModuleFactory(injector, options, moduleType) {
ngDevMode && assertNgModuleType(moduleType);
const moduleFactory = new NgModuleFactory(moduleType);
if (true) {
return Promise.resolve(moduleFactory);
}
const compilerOptions = injector.get(COMPILER_OPTIONS, []).concat(options);
setJitOptions({
defaultEncapsulation: _lastDefined(compilerOptions.map((opts) => opts.defaultEncapsulation)),
preserveWhitespaces: _lastDefined(compilerOptions.map((opts) => opts.preserveWhitespaces))
});
if (isComponentResourceResolutionQueueEmpty()) {
return Promise.resolve(moduleFactory);
}
const compilerProviders = compilerOptions.flatMap((option) => option.providers ?? []);
if (compilerProviders.length === 0) {
return Promise.resolve(moduleFactory);
}
const compiler = getCompilerFacade({
usage: 0,
kind: "NgModule",
type: moduleType
});
const compilerInjector = Injector.create({ providers: compilerProviders });
const resourceLoader = compilerInjector.get(compiler.ResourceLoader);
return resolveComponentResources((url) => Promise.resolve(resourceLoader.get(url))).then(() => moduleFactory);
}
function _lastDefined(args) {
for (let i = args.length - 1; i >= 0; i--) {
if (args[i] !== void 0) {
return args[i];
}
}
return void 0;
}
var _NgZoneChangeDetectionScheduler = class _NgZoneChangeDetectionScheduler {
constructor() {
this.zone = inject(NgZone);
this.applicationRef = inject(ApplicationRef);
}
initialize() {
if (this._onMicrotaskEmptySubscription) {
return;
}
this._onMicrotaskEmptySubscription = this.zone.onMicrotaskEmpty.subscribe({
next: () => {
this.zone.run(() => {
this.applicationRef.tick();
});
}
});
}
ngOnDestroy() {
this._onMicrotaskEmptySubscription?.unsubscribe();
}
};
_NgZoneChangeDetectionScheduler.\u0275fac = function NgZoneChangeDetectionScheduler_Factory(t) {
return new (t || _NgZoneChangeDetectionScheduler)();
};
_NgZoneChangeDetectionScheduler.\u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({ token: _NgZoneChangeDetectionScheduler, factory: _NgZoneChangeDetectionScheduler.\u0275fac, providedIn: "root" });
var NgZoneChangeDetectionScheduler = _NgZoneChangeDetectionScheduler;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(NgZoneChangeDetectionScheduler, [{
type: Injectable,
args: [{ providedIn: "root" }]
}], null, null);
})();
var PROVIDED_NG_ZONE = new InjectionToken(typeof ngDevMode === "undefined" || ngDevMode ? "provideZoneChangeDetection token" : "");
function internalProvideZoneChangeDetection(ngZoneFactory) {
return [
{ provide: NgZone, useFactory: ngZoneFactory },
{
provide: ENVIRONMENT_INITIALIZER,
multi: true,
useFactory: () => {
const ngZoneChangeDetectionScheduler = inject(NgZoneChangeDetectionScheduler, { optional: true });
if ((typeof ngDevMode === "undefined" || ngDevMode) && ngZoneChangeDetectionScheduler === null) {
throw new RuntimeError(402, `A required Injectable was not found in the dependency injection tree. If you are bootstrapping an NgModule, make sure that the \`BrowserModule\` is imported.`);
}
return () => ngZoneChangeDetectionScheduler.initialize();
}
},
{
provide: ENVIRONMENT_INITIALIZER,
multi: true,
useFactory: () => {
const service = inject(ZoneStablePendingTask);
return () => {
service.initialize();
};
}
},
{ provide: INTERNAL_APPLICATION_ERROR_HANDLER, useFactory: ngZoneApplicationErrorHandlerFactory }
];
}
function ngZoneApplicationErrorHandlerFactory() {
const zone = inject(NgZone);
const userErrorHandler = inject(ErrorHandler);
return (e) => zone.runOutsideAngular(() => userErrorHandler.handleError(e));
}
function provideZoneChangeDetection(options) {
const zoneProviders = internalProvideZoneChangeDetection(() => new NgZone(getNgZoneOptions(options)));
return makeEnvironmentProviders([
typeof ngDevMode === "undefined" || ngDevMode ? { provide: PROVIDED_NG_ZONE, useValue: true } : [],
zoneProviders
]);
}
function getNgZoneOptions(options) {
return {
enableLongStackTrace: typeof ngDevMode === "undefined" ? false : !!ngDevMode,
shouldCoalesceEventChangeDetection: options?.eventCoalescing ?? false,
shouldCoalesceRunChangeDetection: options?.runCoalescing ?? false
};
}
var _ZoneStablePendingTask = class _ZoneStablePendingTask {
constructor() {
this.subscription = new Subscription();
this.initialized = false;
this.zone = inject(NgZone);
this.pendingTasks = inject(PendingTasks);
}
initialize() {
if (this.initialized) {
return;
}
this.initialized = true;
let task = null;
if (!this.zone.isStable && !this.zone.hasPendingMacrotasks && !this.zone.hasPendingMicrotasks) {
task = this.pendingTasks.add();
}
this.zone.runOutsideAngular(() => {
this.subscription.add(this.zone.onStable.subscribe(() => {
NgZone.assertNotInAngularZone();
queueMicrotask(() => {
if (task !== null && !this.zone.hasPendingMacrotasks && !this.zone.hasPendingMicrotasks) {
this.pendingTasks.remove(task);
task = null;
}
});
}));
});
this.subscription.add(this.zone.onUnstable.subscribe(() => {
NgZone.assertInAngularZone();
task ??= this.pendingTasks.add();
}));
}
ngOnDestroy() {
this.subscription.unsubscribe();
}
};
_ZoneStablePendingTask.\u0275fac = function ZoneStablePendingTask_Factory(t) {
return new (t || _ZoneStablePendingTask)();
};
_ZoneStablePendingTask.\u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({ token: _ZoneStablePendingTask, factory: _ZoneStablePendingTask.\u0275fac, providedIn: "root" });
var ZoneStablePendingTask = _ZoneStablePendingTask;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(ZoneStablePendingTask, [{
type: Injectable,
args: [{ providedIn: "root" }]
}], null, null);
})();
function getGlobalLocale() {
if (false) {
return goog.LOCALE;
} else {
return typeof $localize !== "undefined" && $localize.locale || DEFAULT_LOCALE_ID;
}
}
var LOCALE_ID = new InjectionToken(ngDevMode ? "LocaleId" : "", {
providedIn: "root",
factory: () => inject(LOCALE_ID, InjectFlags.Optional | InjectFlags.SkipSelf) || getGlobalLocale()
});
var DEFAULT_CURRENCY_CODE = new InjectionToken(ngDevMode ? "DefaultCurrencyCode" : "", {
providedIn: "root",
factory: () => USD_CURRENCY_CODE
});
var TRANSLATIONS = new InjectionToken(ngDevMode ? "Translations" : "");
var TRANSLATIONS_FORMAT = new InjectionToken(ngDevMode ? "TranslationsFormat" : "");
var MissingTranslationStrategy;
(function(MissingTranslationStrategy2) {
MissingTranslationStrategy2[MissingTranslationStrategy2["Error"] = 0] = "Error";
MissingTranslationStrategy2[MissingTranslationStrategy2["Warning"] = 1] = "Warning";
MissingTranslationStrategy2[MissingTranslationStrategy2["Ignore"] = 2] = "Ignore";
})(MissingTranslationStrategy || (MissingTranslationStrategy = {}));
var PLATFORM_DESTROY_LISTENERS = new InjectionToken(ngDevMode ? "PlatformDestroyListeners" : "");
var _PlatformRef = class _PlatformRef {
/** @internal */
constructor(_injector) {
this._injector = _injector;
this._modules = [];
this._destroyListeners = [];
this._destroyed = false;
}
/**
* Creates an instance of an `@NgModule` for the given platform.
*
* @deprecated Passing NgModule factories as the `PlatformRef.bootstrapModuleFactory` function
* argument is deprecated. Use the `PlatformRef.bootstrapModule` API instead.
*/
bootstrapModuleFactory(moduleFactory, options) {
const ngZone = getNgZone(options?.ngZone, getNgZoneOptions({
eventCoalescing: options?.ngZoneEventCoalescing,
runCoalescing: options?.ngZoneRunCoalescing
}));
return ngZone.run(() => {
const moduleRef = createNgModuleRefWithProviders(moduleFactory.moduleType, this.injector, internalProvideZoneChangeDetection(() => ngZone));
if ((typeof ngDevMode === "undefined" || ngDevMode) && moduleRef.injector.get(PROVIDED_NG_ZONE, null) !== null) {
throw new RuntimeError(207, "`bootstrapModule` does not support `provideZoneChangeDetection`. Use `BootstrapOptions` instead.");
}
const exceptionHandler = moduleRef.injector.get(ErrorHandler, null);
if ((typeof ngDevMode === "undefined" || ngDevMode) && exceptionHandler === null) {
throw new RuntimeError(402, "No ErrorHandler. Is platform module (BrowserModule) included?");
}
ngZone.runOutsideAngular(() => {
const subscription = ngZone.onError.subscribe({
next: (error) => {
exceptionHandler.handleError(error);
}
});
moduleRef.onDestroy(() => {
remove(this._modules, moduleRef);
subscription.unsubscribe();
});
});
return _callAndReportToErrorHandler(exceptionHandler, ngZone, () => {
const initStatus = moduleRef.injector.get(ApplicationInitStatus);
initStatus.runInitializers();
return initStatus.donePromise.then(() => {
const localeId = moduleRef.injector.get(LOCALE_ID, DEFAULT_LOCALE_ID);
setLocaleId(localeId || DEFAULT_LOCALE_ID);
this._moduleDoBootstrap(moduleRef);
return moduleRef;
});
});
});
}
/**
* Creates an instance of an `@NgModule` for a given platform.
*
* @usageNotes
* ### Simple Example
*
* ```typescript
* @NgModule({
* imports: [BrowserModule]
* })
* class MyModule {}
*
* let moduleRef = platformBrowser().bootstrapModule(MyModule);
* ```
*
*/
bootstrapModule(moduleType, compilerOptions = []) {
const options = optionsReducer({}, compilerOptions);
return compileNgModuleFactory(this.injector, options, moduleType).then((moduleFactory) => this.bootstrapModuleFactory(moduleFactory, options));
}
_moduleDoBootstrap(moduleRef) {
const appRef = moduleRef.injector.get(ApplicationRef);
if (moduleRef._bootstrapComponents.length > 0) {
moduleRef._bootstrapComponents.forEach((f) => appRef.bootstrap(f));
} else if (moduleRef.instance.ngDoBootstrap) {
moduleRef.instance.ngDoBootstrap(appRef);
} else {
throw new RuntimeError(-403, ngDevMode && `The module ${stringify(moduleRef.instance.constructor)} was bootstrapped, but it does not declare "@NgModule.bootstrap" components nor a "ngDoBootstrap" method. Please define one of these.`);
}
this._modules.push(moduleRef);
}
/**
* Registers a listener to be called when the platform is destroyed.
*/
onDestroy(callback) {
this._destroyListeners.push(callback);
}
/**
* Retrieves the platform {@link Injector}, which is the parent injector for
* every Angular application on the page and provides singleton providers.
*/
get injector() {
return this._injector;
}
/**
* Destroys the current Angular platform and all Angular applications on the page.
* Destroys all modules and listeners registered with the platform.
*/
destroy() {
if (this._destroyed) {
throw new RuntimeError(404, ngDevMode && "The platform has already been destroyed!");
}
this._modules.slice().forEach((module2) => module2.destroy());
this._destroyListeners.forEach((listener) => listener());
const destroyListeners = this._injector.get(PLATFORM_DESTROY_LISTENERS, null);
if (destroyListeners) {
destroyListeners.forEach((listener) => listener());
destroyListeners.clear();
}
this._destroyed = true;
}
/**
* Indicates whether this instance was destroyed.
*/
get destroyed() {
return this._destroyed;
}
};
_PlatformRef.\u0275fac = function PlatformRef_Factory(t) {
return new (t || _PlatformRef)(\u0275\u0275inject(Injector));
};
_PlatformRef.\u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({ token: _PlatformRef, factory: _PlatformRef.\u0275fac, providedIn: "platform" });
var PlatformRef = _PlatformRef;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(PlatformRef, [{
type: Injectable,
args: [{ providedIn: "platform" }]
}], () => [{ type: Injector }], null);
})();
var _platformInjector = null;
var ALLOW_MULTIPLE_PLATFORMS = new InjectionToken(ngDevMode ? "AllowMultipleToken" : "");
function createPlatform(injector) {
if (_platformInjector && !_platformInjector.get(ALLOW_MULTIPLE_PLATFORMS, false)) {
throw new RuntimeError(400, ngDevMode && "There can be only one platform. Destroy the previous one to create a new one.");
}
publishDefaultGlobalUtils();
publishSignalConfiguration();
_platformInjector = injector;
const platform = injector.get(PlatformRef);
runPlatformInitializers(injector);
return platform;
}
function createPlatformFactory(parentPlatformFactory, name2, providers = []) {
const desc = `Platform: ${name2}`;
const marker = new InjectionToken(desc);
return (extraProviders = []) => {
let platform = getPlatform();
if (!platform || platform.injector.get(ALLOW_MULTIPLE_PLATFORMS, false)) {
const platformProviders = [...providers, ...extraProviders, { provide: marker, useValue: true }];
if (parentPlatformFactory) {
parentPlatformFactory(platformProviders);
} else {
createPlatform(createPlatformInjector(platformProviders, desc));
}
}
return assertPlatform(marker);
};
}
function createPlatformInjector(providers = [], name2) {
return Injector.create({
name: name2,
providers: [
{ provide: INJECTOR_SCOPE, useValue: "platform" },
{ provide: PLATFORM_DESTROY_LISTENERS, useValue: /* @__PURE__ */ new Set([() => _platformInjector = null]) },
...providers
]
});
}
function assertPlatform(requiredToken) {
const platform = getPlatform();
if (!platform) {
throw new RuntimeError(401, ngDevMode && "No platform exists!");
}
if ((typeof ngDevMode === "undefined" || ngDevMode) && !platform.injector.get(requiredToken, null)) {
throw new RuntimeError(400, "A platform with a different configuration has been created. Please destroy it first.");
}
return platform;
}
function getPlatform() {
return _platformInjector?.get(PlatformRef) ?? null;
}
function createOrReusePlatformInjector(providers = []) {
if (_platformInjector)
return _platformInjector;
publishDefaultGlobalUtils();
const injector = createPlatformInjector(providers);
_platformInjector = injector;
publishSignalConfiguration();
runPlatformInitializers(injector);
return injector;
}
function runPlatformInitializers(injector) {
const inits = injector.get(PLATFORM_INITIALIZER, null);
inits?.forEach((init) => init());
}
var _ChangeDetectorRef = class _ChangeDetectorRef {
};
_ChangeDetectorRef.__NG_ELEMENT_ID__ = injectChangeDetectorRef;
var ChangeDetectorRef = _ChangeDetectorRef;
function injectChangeDetectorRef(flags) {
return createViewRef(
getCurrentTNode(),
getLView(),
(flags & 16) === 16
/* InternalInjectFlags.ForPipe */
);
}
function createViewRef(tNode, lView, isPipe2) {
if (isComponentHost(tNode) && !isPipe2) {
const componentView = getComponentLViewByIndex(tNode.index, lView);
return new ViewRef$1(componentView, componentView);
} else if (tNode.type & (3 | 12 | 32)) {
const hostComponentView = lView[DECLARATION_COMPONENT_VIEW];
return new ViewRef$1(hostComponentView, lView);
}
return null;
}
var DefaultIterableDifferFactory = class {
constructor() {
}
supports(obj) {
return isListLikeIterable(obj);
}
create(trackByFn) {
return new DefaultIterableDiffer(trackByFn);
}
};
var trackByIdentity = (index2, item) => item;
var DefaultIterableDiffer = class {
constructor(trackByFn) {
this.length = 0;
this._linkedRecords = null;
this._unlinkedRecords = null;
this._previousItHead = null;
this._itHead = null;
this._itTail = null;
this._additionsHead = null;
this._additionsTail = null;
this._movesHead = null;
this._movesTail = null;
this._removalsHead = null;
this._removalsTail = null;
this._identityChangesHead = null;
this._identityChangesTail = null;
this._trackByFn = trackByFn || trackByIdentity;
}
forEachItem(fn) {
let record;
for (record = this._itHead; record !== null; record = record._next) {
fn(record);
}
}
forEachOperation(fn) {
let nextIt = this._itHead;
let nextRemove = this._removalsHead;
let addRemoveOffset = 0;
let moveOffsets = null;
while (nextIt || nextRemove) {
const record = !nextRemove || nextIt && nextIt.currentIndex < getPreviousIndex(nextRemove, addRemoveOffset, moveOffsets) ? nextIt : nextRemove;
const adjPreviousIndex = getPreviousIndex(record, addRemoveOffset, moveOffsets);
const currentIndex = record.currentIndex;
if (record === nextRemove) {
addRemoveOffset--;
nextRemove = nextRemove._nextRemoved;
} else {
nextIt = nextIt._next;
if (record.previousIndex == null) {
addRemoveOffset++;
} else {
if (!moveOffsets)
moveOffsets = [];
const localMovePreviousIndex = adjPreviousIndex - addRemoveOffset;
const localCurrentIndex = currentIndex - addRemoveOffset;
if (localMovePreviousIndex != localCurrentIndex) {
for (let i = 0; i < localMovePreviousIndex; i++) {
const offset = i < moveOffsets.length ? moveOffsets[i] : moveOffsets[i] = 0;
const index2 = offset + i;
if (localCurrentIndex <= index2 && index2 < localMovePreviousIndex) {
moveOffsets[i] = offset + 1;
}
}
const previousIndex = record.previousIndex;
moveOffsets[previousIndex] = localCurrentIndex - localMovePreviousIndex;
}
}
}
if (adjPreviousIndex !== currentIndex) {
fn(record, adjPreviousIndex, currentIndex);
}
}
}
forEachPreviousItem(fn) {
let record;
for (record = this._previousItHead; record !== null; record = record._nextPrevious) {
fn(record);
}
}
forEachAddedItem(fn) {
let record;
for (record = this._additionsHead; record !== null; record = record._nextAdded) {
fn(record);
}
}
forEachMovedItem(fn) {
let record;
for (record = this._movesHead; record !== null; record = record._nextMoved) {
fn(record);
}
}
forEachRemovedItem(fn) {
let record;
for (record = this._removalsHead; record !== null; record = record._nextRemoved) {
fn(record);
}
}
forEachIdentityChange(fn) {
let record;
for (record = this._identityChangesHead; record !== null; record = record._nextIdentityChange) {
fn(record);
}
}
diff(collection) {
if (collection == null)
collection = [];
if (!isListLikeIterable(collection)) {
throw new RuntimeError(900, ngDevMode && `Error trying to diff '${stringify(collection)}'. Only arrays and iterables are allowed`);
}
if (this.check(collection)) {
return this;
} else {
return null;
}
}
onDestroy() {
}
check(collection) {
this._reset();
let record = this._itHead;
let mayBeDirty = false;
let index2;
let item;
let itemTrackBy;
if (Array.isArray(collection)) {
this.length = collection.length;
for (let index3 = 0; index3 < this.length; index3++) {
item = collection[index3];
itemTrackBy = this._trackByFn(index3, item);
if (record === null || !Object.is(record.trackById, itemTrackBy)) {
record = this._mismatch(record, item, itemTrackBy, index3);
mayBeDirty = true;
} else {
if (mayBeDirty) {
record = this._verifyReinsertion(record, item, itemTrackBy, index3);
}
if (!Object.is(record.item, item))
this._addIdentityChange(record, item);
}
record = record._next;
}
} else {
index2 = 0;
iterateListLike(collection, (item2) => {
itemTrackBy = this._trackByFn(index2, item2);
if (record === null || !Object.is(record.trackById, itemTrackBy)) {
record = this._mismatch(record, item2, itemTrackBy, index2);
mayBeDirty = true;
} else {
if (mayBeDirty) {
record = this._verifyReinsertion(record, item2, itemTrackBy, index2);
}
if (!Object.is(record.item, item2))
this._addIdentityChange(record, item2);
}
record = record._next;
index2++;
});
this.length = index2;
}
this._truncate(record);
this.collection = collection;
return this.isDirty;
}
/* CollectionChanges is considered dirty if it has any additions, moves, removals, or identity
* changes.
*/
get isDirty() {
return this._additionsHead !== null || this._movesHead !== null || this._removalsHead !== null || this._identityChangesHead !== null;
}
/**
* Reset the state of the change objects to show no changes. This means set previousKey to
* currentKey, and clear all of the queues (additions, moves, removals).
* Set the previousIndexes of moved and added items to their currentIndexes
* Reset the list of additions, moves and removals
*
* @internal
*/
_reset() {
if (this.isDirty) {
let record;
for (record = this._previousItHead = this._itHead; record !== null; record = record._next) {
record._nextPrevious = record._next;
}
for (record = this._additionsHead; record !== null; record = record._nextAdded) {
record.previousIndex = record.currentIndex;
}
this._additionsHead = this._additionsTail = null;
for (record = this._movesHead; record !== null; record = record._nextMoved) {
record.previousIndex = record.currentIndex;
}
this._movesHead = this._movesTail = null;
this._removalsHead = this._removalsTail = null;
this._identityChangesHead = this._identityChangesTail = null;
}
}
/**
* This is the core function which handles differences between collections.
*
* - `record` is the record which we saw at this position last time. If null then it is a new
* item.
* - `item` is the current item in the collection
* - `index` is the position of the item in the collection
*
* @internal
*/
_mismatch(record, item, itemTrackBy, index2) {
let previousRecord;
if (record === null) {
previousRecord = this._itTail;
} else {
previousRecord = record._prev;
this._remove(record);
}
record = this._unlinkedRecords === null ? null : this._unlinkedRecords.get(itemTrackBy, null);
if (record !== null) {
if (!Object.is(record.item, item))
this._addIdentityChange(record, item);
this._reinsertAfter(record, previousRecord, index2);
} else {
record = this._linkedRecords === null ? null : this._linkedRecords.get(itemTrackBy, index2);
if (record !== null) {
if (!Object.is(record.item, item))
this._addIdentityChange(record, item);
this._moveAfter(record, previousRecord, index2);
} else {
record = this._addAfter(new IterableChangeRecord_(item, itemTrackBy), previousRecord, index2);
}
}
return record;
}
/**
* This check is only needed if an array contains duplicates. (Short circuit of nothing dirty)
*
* Use case: `[a, a]` => `[b, a, a]`
*
* If we did not have this check then the insertion of `b` would:
* 1) evict first `a`
* 2) insert `b` at `0` index.
* 3) leave `a` at index `1` as is. <-- this is wrong!
* 3) reinsert `a` at index 2. <-- this is wrong!
*
* The correct behavior is:
* 1) evict first `a`
* 2) insert `b` at `0` index.
* 3) reinsert `a` at index 1.
* 3) move `a` at from `1` to `2`.
*
*
* Double check that we have not evicted a duplicate item. We need to check if the item type may
* have already been removed:
* The insertion of b will evict the first 'a'. If we don't reinsert it now it will be reinserted
* at the end. Which will show up as the two 'a's switching position. This is incorrect, since a
* better way to think of it is as insert of 'b' rather then switch 'a' with 'b' and then add 'a'
* at the end.
*
* @internal
*/
_verifyReinsertion(record, item, itemTrackBy, index2) {
let reinsertRecord = this._unlinkedRecords === null ? null : this._unlinkedRecords.get(itemTrackBy, null);
if (reinsertRecord !== null) {
record = this._reinsertAfter(reinsertRecord, record._prev, index2);
} else if (record.currentIndex != index2) {
record.currentIndex = index2;
this._addToMoves(record, index2);
}
return record;
}
/**
* Get rid of any excess {@link IterableChangeRecord_}s from the previous collection
*
* - `record` The first excess {@link IterableChangeRecord_}.
*
* @internal
*/
_truncate(record) {
while (record !== null) {
const nextRecord = record._next;
this._addToRemovals(this._unlink(record));
record = nextRecord;
}
if (this._unlinkedRecords !== null) {
this._unlinkedRecords.clear();
}
if (this._additionsTail !== null) {
this._additionsTail._nextAdded = null;
}
if (this._movesTail !== null) {
this._movesTail._nextMoved = null;
}
if (this._itTail !== null) {
this._itTail._next = null;
}
if (this._removalsTail !== null) {
this._removalsTail._nextRemoved = null;
}
if (this._identityChangesTail !== null) {
this._identityChangesTail._nextIdentityChange = null;
}
}
/** @internal */
_reinsertAfter(record, prevRecord, index2) {
if (this._unlinkedRecords !== null) {
this._unlinkedRecords.remove(record);
}
const prev = record._prevRemoved;
const next = record._nextRemoved;
if (prev === null) {
this._removalsHead = next;
} else {
prev._nextRemoved = next;
}
if (next === null) {
this._removalsTail = prev;
} else {
next._prevRemoved = prev;
}
this._insertAfter(record, prevRecord, index2);
this._addToMoves(record, index2);
return record;
}
/** @internal */
_moveAfter(record, prevRecord, index2) {
this._unlink(record);
this._insertAfter(record, prevRecord, index2);
this._addToMoves(record, index2);
return record;
}
/** @internal */
_addAfter(record, prevRecord, index2) {
this._insertAfter(record, prevRecord, index2);
if (this._additionsTail === null) {
this._additionsTail = this._additionsHead = record;
} else {
this._additionsTail = this._additionsTail._nextAdded = record;
}
return record;
}
/** @internal */
_insertAfter(record, prevRecord, index2) {
const next = prevRecord === null ? this._itHead : prevRecord._next;
record._next = next;
record._prev = prevRecord;
if (next === null) {
this._itTail = record;
} else {
next._prev = record;
}
if (prevRecord === null) {
this._itHead = record;
} else {
prevRecord._next = record;
}
if (this._linkedRecords === null) {
this._linkedRecords = new _DuplicateMap();
}
this._linkedRecords.put(record);
record.currentIndex = index2;
return record;
}
/** @internal */
_remove(record) {
return this._addToRemovals(this._unlink(record));
}
/** @internal */
_unlink(record) {
if (this._linkedRecords !== null) {
this._linkedRecords.remove(record);
}
const prev = record._prev;
const next = record._next;
if (prev === null) {
this._itHead = next;
} else {
prev._next = next;
}
if (next === null) {
this._itTail = prev;
} else {
next._prev = prev;
}
return record;
}
/** @internal */
_addToMoves(record, toIndex) {
if (record.previousIndex === toIndex) {
return record;
}
if (this._movesTail === null) {
this._movesTail = this._movesHead = record;
} else {
this._movesTail = this._movesTail._nextMoved = record;
}
return record;
}
_addToRemovals(record) {
if (this._unlinkedRecords === null) {
this._unlinkedRecords = new _DuplicateMap();
}
this._unlinkedRecords.put(record);
record.currentIndex = null;
record._nextRemoved = null;
if (this._removalsTail === null) {
this._removalsTail = this._removalsHead = record;
record._prevRemoved = null;
} else {
record._prevRemoved = this._removalsTail;
this._removalsTail = this._removalsTail._nextRemoved = record;
}
return record;
}
/** @internal */
_addIdentityChange(record, item) {
record.item = item;
if (this._identityChangesTail === null) {
this._identityChangesTail = this._identityChangesHead = record;
} else {
this._identityChangesTail = this._identityChangesTail._nextIdentityChange = record;
}
return record;
}
};
var IterableChangeRecord_ = class {
constructor(item, trackById) {
this.item = item;
this.trackById = trackById;
this.currentIndex = null;
this.previousIndex = null;
this._nextPrevious = null;
this._prev = null;
this._next = null;
this._prevDup = null;
this._nextDup = null;
this._prevRemoved = null;
this._nextRemoved = null;
this._nextAdded = null;
this._nextMoved = null;
this._nextIdentityChange = null;
}
};
var _DuplicateItemRecordList = class {
constructor() {
this._head = null;
this._tail = null;
}
/**
* Append the record to the list of duplicates.
*
* Note: by design all records in the list of duplicates hold the same value in record.item.
*/
add(record) {
if (this._head === null) {
this._head = this._tail = record;
record._nextDup = null;
record._prevDup = null;
} else {
this._tail._nextDup = record;
record._prevDup = this._tail;
record._nextDup = null;
this._tail = record;
}
}
// Returns a IterableChangeRecord_ having IterableChangeRecord_.trackById == trackById and
// IterableChangeRecord_.currentIndex >= atOrAfterIndex
get(trackById, atOrAfterIndex) {
let record;
for (record = this._head; record !== null; record = record._nextDup) {
if ((atOrAfterIndex === null || atOrAfterIndex <= record.currentIndex) && Object.is(record.trackById, trackById)) {
return record;
}
}
return null;
}
/**
* Remove one {@link IterableChangeRecord_} from the list of duplicates.
*
* Returns whether the list of duplicates is empty.
*/
remove(record) {
const prev = record._prevDup;
const next = record._nextDup;
if (prev === null) {
this._head = next;
} else {
prev._nextDup = next;
}
if (next === null) {
this._tail = prev;
} else {
next._prevDup = prev;
}
return this._head === null;
}
};
var _DuplicateMap = class {
constructor() {
this.map = /* @__PURE__ */ new Map();
}
put(record) {
const key2 = record.trackById;
let duplicates = this.map.get(key2);
if (!duplicates) {
duplicates = new _DuplicateItemRecordList();
this.map.set(key2, duplicates);
}
duplicates.add(record);
}
/**
* Retrieve the `value` using key. Because the IterableChangeRecord_ value may be one which we
* have already iterated over, we use the `atOrAfterIndex` to pretend it is not there.
*
* Use case: `[a, b, c, a, a]` if we are at index `3` which is the second `a` then asking if we
* have any more `a`s needs to return the second `a`.
*/
get(trackById, atOrAfterIndex) {
const key2 = trackById;
const recordList = this.map.get(key2);
return recordList ? recordList.get(trackById, atOrAfterIndex) : null;
}
/**
* Removes a {@link IterableChangeRecord_} from the list of duplicates.
*
* The list of duplicates also is removed from the map if it gets empty.
*/
remove(record) {
const key2 = record.trackById;
const recordList = this.map.get(key2);
if (recordList.remove(record)) {
this.map.delete(key2);
}
return record;
}
get isEmpty() {
return this.map.size === 0;
}
clear() {
this.map.clear();
}
};
function getPreviousIndex(item, addRemoveOffset, moveOffsets) {
const previousIndex = item.previousIndex;
if (previousIndex === null)
return previousIndex;
let moveOffset = 0;
if (moveOffsets && previousIndex < moveOffsets.length) {
moveOffset = moveOffsets[previousIndex];
}
return previousIndex + addRemoveOffset + moveOffset;
}
var DefaultKeyValueDifferFactory = class {
constructor() {
}
supports(obj) {
return obj instanceof Map || isJsObject(obj);
}
create() {
return new DefaultKeyValueDiffer();
}
};
var DefaultKeyValueDiffer = class {
constructor() {
this._records = /* @__PURE__ */ new Map();
this._mapHead = null;
this._appendAfter = null;
this._previousMapHead = null;
this._changesHead = null;
this._changesTail = null;
this._additionsHead = null;
this._additionsTail = null;
this._removalsHead = null;
this._removalsTail = null;
}
get isDirty() {
return this._additionsHead !== null || this._changesHead !== null || this._removalsHead !== null;
}
forEachItem(fn) {
let record;
for (record = this._mapHead; record !== null; record = record._next) {
fn(record);
}
}
forEachPreviousItem(fn) {
let record;
for (record = this._previousMapHead; record !== null; record = record._nextPrevious) {
fn(record);
}
}
forEachChangedItem(fn) {
let record;
for (record = this._changesHead; record !== null; record = record._nextChanged) {
fn(record);
}
}
forEachAddedItem(fn) {
let record;
for (record = this._additionsHead; record !== null; record = record._nextAdded) {
fn(record);
}
}
forEachRemovedItem(fn) {
let record;
for (record = this._removalsHead; record !== null; record = record._nextRemoved) {
fn(record);
}
}
diff(map2) {
if (!map2) {
map2 = /* @__PURE__ */ new Map();
} else if (!(map2 instanceof Map || isJsObject(map2))) {
throw new RuntimeError(900, ngDevMode && `Error trying to diff '${stringify(map2)}'. Only maps and objects are allowed`);
}
return this.check(map2) ? this : null;
}
onDestroy() {
}
/**
* Check the current state of the map vs the previous.
* The algorithm is optimised for when the keys do no change.
*/
check(map2) {
this._reset();
let insertBefore = this._mapHead;
this._appendAfter = null;
this._forEach(map2, (value2, key2) => {
if (insertBefore && insertBefore.key === key2) {
this._maybeAddToChanges(insertBefore, value2);
this._appendAfter = insertBefore;
insertBefore = insertBefore._next;
} else {
const record = this._getOrCreateRecordForKey(key2, value2);
insertBefore = this._insertBeforeOrAppend(insertBefore, record);
}
});
if (insertBefore) {
if (insertBefore._prev) {
insertBefore._prev._next = null;
}
this._removalsHead = insertBefore;
for (let record = insertBefore; record !== null; record = record._nextRemoved) {
if (record === this._mapHead) {
this._mapHead = null;
}
this._records.delete(record.key);
record._nextRemoved = record._next;
record.previousValue = record.currentValue;
record.currentValue = null;
record._prev = null;
record._next = null;
}
}
if (this._changesTail)
this._changesTail._nextChanged = null;
if (this._additionsTail)
this._additionsTail._nextAdded = null;
return this.isDirty;
}
/**
* Inserts a record before `before` or append at the end of the list when `before` is null.
*
* Notes:
* - This method appends at `this._appendAfter`,
* - This method updates `this._appendAfter`,
* - The return value is the new value for the insertion pointer.
*/
_insertBeforeOrAppend(before, record) {
if (before) {
const prev = before._prev;
record._next = before;
record._prev = prev;
before._prev = record;
if (prev) {
prev._next = record;
}
if (before === this._mapHead) {
this._mapHead = record;
}
this._appendAfter = before;
return before;
}
if (this._appendAfter) {
this._appendAfter._next = record;
record._prev = this._appendAfter;
} else {
this._mapHead = record;
}
this._appendAfter = record;
return null;
}
_getOrCreateRecordForKey(key2, value2) {
if (this._records.has(key2)) {
const record2 = this._records.get(key2);
this._maybeAddToChanges(record2, value2);
const prev = record2._prev;
const next = record2._next;
if (prev) {
prev._next = next;
}
if (next) {
next._prev = prev;
}
record2._next = null;
record2._prev = null;
return record2;
}
const record = new KeyValueChangeRecord_(key2);
this._records.set(key2, record);
record.currentValue = value2;
this._addToAdditions(record);
return record;
}
/** @internal */
_reset() {
if (this.isDirty) {
let record;
this._previousMapHead = this._mapHead;
for (record = this._previousMapHead; record !== null; record = record._next) {
record._nextPrevious = record._next;
}
for (record = this._changesHead; record !== null; record = record._nextChanged) {
record.previousValue = record.currentValue;
}
for (record = this._additionsHead; record != null; record = record._nextAdded) {
record.previousValue = record.currentValue;
}
this._changesHead = this._changesTail = null;
this._additionsHead = this._additionsTail = null;
this._removalsHead = null;
}
}
// Add the record or a given key to the list of changes only when the value has actually changed
_maybeAddToChanges(record, newValue) {
if (!Object.is(newValue, record.currentValue)) {
record.previousValue = record.currentValue;
record.currentValue = newValue;
this._addToChanges(record);
}
}
_addToAdditions(record) {
if (this._additionsHead === null) {
this._additionsHead = this._additionsTail = record;
} else {
this._additionsTail._nextAdded = record;
this._additionsTail = record;
}
}
_addToChanges(record) {
if (this._changesHead === null) {
this._changesHead = this._changesTail = record;
} else {
this._changesTail._nextChanged = record;
this._changesTail = record;
}
}
/** @internal */
_forEach(obj, fn) {
if (obj instanceof Map) {
obj.forEach(fn);
} else {
Object.keys(obj).forEach((k) => fn(obj[k], k));
}
}
};
var KeyValueChangeRecord_ = class {
constructor(key2) {
this.key = key2;
this.previousValue = null;
this.currentValue = null;
this._nextPrevious = null;
this._next = null;
this._prev = null;
this._nextAdded = null;
this._nextRemoved = null;
this._nextChanged = null;
}
};
function defaultIterableDiffersFactory() {
return new IterableDiffers([new DefaultIterableDifferFactory()]);
}
var _IterableDiffers = class _IterableDiffers {
constructor(factories) {
this.factories = factories;
}
static create(factories, parent2) {
if (parent2 != null) {
const copied = parent2.factories.slice();
factories = factories.concat(copied);
}
return new _IterableDiffers(factories);
}
/**
* Takes an array of {@link IterableDifferFactory} and returns a provider used to extend the
* inherited {@link IterableDiffers} instance with the provided factories and return a new
* {@link IterableDiffers} instance.
*
* @usageNotes
* ### Example
*
* The following example shows how to extend an existing list of factories,
* which will only be applied to the injector for this component and its children.
* This step is all that's required to make a new {@link IterableDiffer} available.
*
* ```
* @Component({
* viewProviders: [
* IterableDiffers.extend([new ImmutableListDiffer()])
* ]
* })
* ```
*/
static extend(factories) {
return {
provide: _IterableDiffers,
useFactory: (parent2) => {
return _IterableDiffers.create(factories, parent2 || defaultIterableDiffersFactory());
},
// Dependency technically isn't optional, but we can provide a better error message this way.
deps: [[_IterableDiffers, new SkipSelf(), new Optional()]]
};
}
find(iterable) {
const factory = this.factories.find((f) => f.supports(iterable));
if (factory != null) {
return factory;
} else {
throw new RuntimeError(901, ngDevMode && `Cannot find a differ supporting object '${iterable}' of type '${getTypeNameForDebugging(iterable)}'`);
}
}
};
_IterableDiffers.\u0275prov = \u0275\u0275defineInjectable({ token: _IterableDiffers, providedIn: "root", factory: defaultIterableDiffersFactory });
var IterableDiffers = _IterableDiffers;
function getTypeNameForDebugging(type) {
return type["name"] || typeof type;
}
function defaultKeyValueDiffersFactory() {
return new KeyValueDiffers([new DefaultKeyValueDifferFactory()]);
}
var _KeyValueDiffers = class _KeyValueDiffers {
constructor(factories) {
this.factories = factories;
}
static create(factories, parent2) {
if (parent2) {
const copied = parent2.factories.slice();
factories = factories.concat(copied);
}
return new _KeyValueDiffers(factories);
}
/**
* Takes an array of {@link KeyValueDifferFactory} and returns a provider used to extend the
* inherited {@link KeyValueDiffers} instance with the provided factories and return a new
* {@link KeyValueDiffers} instance.
*
* @usageNotes
* ### Example
*
* The following example shows how to extend an existing list of factories,
* which will only be applied to the injector for this component and its children.
* This step is all that's required to make a new {@link KeyValueDiffer} available.
*
* ```
* @Component({
* viewProviders: [
* KeyValueDiffers.extend([new ImmutableMapDiffer()])
* ]
* })
* ```
*/
static extend(factories) {
return {
provide: _KeyValueDiffers,
useFactory: (parent2) => {
return _KeyValueDiffers.create(factories, parent2 || defaultKeyValueDiffersFactory());
},
// Dependency technically isn't optional, but we can provide a better error message this way.
deps: [[_KeyValueDiffers, new SkipSelf(), new Optional()]]
};
}
find(kv) {
const factory = this.factories.find((f) => f.supports(kv));
if (factory) {
return factory;
}
throw new RuntimeError(901, ngDevMode && `Cannot find a differ supporting object '${kv}'`);
}
};
_KeyValueDiffers.\u0275prov = \u0275\u0275defineInjectable({ token: _KeyValueDiffers, providedIn: "root", factory: defaultKeyValueDiffersFactory });
var KeyValueDiffers = _KeyValueDiffers;
var keyValDiff = [new DefaultKeyValueDifferFactory()];
var iterableDiff = [new DefaultIterableDifferFactory()];
var defaultIterableDiffers = new IterableDiffers(iterableDiff);
var defaultKeyValueDiffers = new KeyValueDiffers(keyValDiff);
var platformCore = createPlatformFactory(null, "core", []);
var _ApplicationModule = class _ApplicationModule {
// Inject ApplicationRef to make it eager...
constructor(appRef) {
}
};
_ApplicationModule.\u0275fac = function ApplicationModule_Factory(t) {
return new (t || _ApplicationModule)(\u0275\u0275inject(ApplicationRef));
};
_ApplicationModule.\u0275mod = /* @__PURE__ */ \u0275\u0275defineNgModule({ type: _ApplicationModule });
_ApplicationModule.\u0275inj = /* @__PURE__ */ \u0275\u0275defineInjector({});
var ApplicationModule = _ApplicationModule;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(ApplicationModule, [{
type: NgModule
}], () => [{ type: ApplicationRef }], null);
})();
var SCAN_DELAY = 200;
var OVERSIZED_IMAGE_TOLERANCE = 1200;
var _ImagePerformanceWarning = class _ImagePerformanceWarning {
constructor() {
this.window = null;
this.observer = null;
this.options = inject(IMAGE_CONFIG);
this.ngZone = inject(NgZone);
}
start() {
if (typeof PerformanceObserver === "undefined" || this.options?.disableImageSizeWarning && this.options?.disableImageLazyLoadWarning) {
return;
}
this.observer = this.initPerformanceObserver();
const doc = getDocument();
const win = doc.defaultView;
if (typeof win !== "undefined") {
this.window = win;
const waitToScan = () => {
setTimeout(this.scanImages.bind(this), SCAN_DELAY);
};
this.ngZone.runOutsideAngular(() => {
if (doc.readyState === "complete") {
waitToScan();
} else {
this.window?.addEventListener("load", waitToScan, { once: true });
}
});
}
}
ngOnDestroy() {
this.observer?.disconnect();
}
initPerformanceObserver() {
if (typeof PerformanceObserver === "undefined") {
return null;
}
const observer = new PerformanceObserver((entryList) => {
const entries = entryList.getEntries();
if (entries.length === 0)
return;
const lcpElement = entries[entries.length - 1];
const imgSrc = lcpElement.element?.src ?? "";
if (imgSrc.startsWith("data:") || imgSrc.startsWith("blob:"))
return;
this.lcpImageUrl = imgSrc;
});
observer.observe({ type: "largest-contentful-paint", buffered: true });
return observer;
}
scanImages() {
const images = getDocument().querySelectorAll("img");
let lcpElementFound, lcpElementLoadedCorrectly = false;
images.forEach((image) => {
if (!this.options?.disableImageSizeWarning) {
for (const image2 of images) {
if (!image2.getAttribute("ng-img") && this.isOversized(image2)) {
logOversizedImageWarning(image2.src);
}
}
}
if (!this.options?.disableImageLazyLoadWarning && this.lcpImageUrl) {
if (image.src === this.lcpImageUrl) {
lcpElementFound = true;
if (image.loading !== "lazy" || image.getAttribute("ng-img")) {
lcpElementLoadedCorrectly = true;
}
}
}
});
if (lcpElementFound && !lcpElementLoadedCorrectly && this.lcpImageUrl && !this.options?.disableImageLazyLoadWarning) {
logLazyLCPWarning(this.lcpImageUrl);
}
}
isOversized(image) {
if (!this.window) {
return false;
}
const computedStyle = this.window.getComputedStyle(image);
let renderedWidth = parseFloat(computedStyle.getPropertyValue("width"));
let renderedHeight = parseFloat(computedStyle.getPropertyValue("height"));
const boxSizing = computedStyle.getPropertyValue("box-sizing");
const objectFit = computedStyle.getPropertyValue("object-fit");
if (objectFit === `cover`) {
return false;
}
if (boxSizing === "border-box") {
const paddingTop = computedStyle.getPropertyValue("padding-top");
const paddingRight = computedStyle.getPropertyValue("padding-right");
const paddingBottom = computedStyle.getPropertyValue("padding-bottom");
const paddingLeft = computedStyle.getPropertyValue("padding-left");
renderedWidth -= parseFloat(paddingRight) + parseFloat(paddingLeft);
renderedHeight -= parseFloat(paddingTop) + parseFloat(paddingBottom);
}
const intrinsicWidth = image.naturalWidth;
const intrinsicHeight = image.naturalHeight;
const recommendedWidth = this.window.devicePixelRatio * renderedWidth;
const recommendedHeight = this.window.devicePixelRatio * renderedHeight;
const oversizedWidth = intrinsicWidth - recommendedWidth >= OVERSIZED_IMAGE_TOLERANCE;
const oversizedHeight = intrinsicHeight - recommendedHeight >= OVERSIZED_IMAGE_TOLERANCE;
return oversizedWidth || oversizedHeight;
}
};
_ImagePerformanceWarning.\u0275fac = function ImagePerformanceWarning_Factory(t) {
return new (t || _ImagePerformanceWarning)();
};
_ImagePerformanceWarning.\u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({ token: _ImagePerformanceWarning, factory: _ImagePerformanceWarning.\u0275fac, providedIn: "root" });
var ImagePerformanceWarning = _ImagePerformanceWarning;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(ImagePerformanceWarning, [{
type: Injectable,
args: [{ providedIn: "root" }]
}], null, null);
})();
function logLazyLCPWarning(src) {
console.warn(formatRuntimeError(-913, `An image with src ${src} is the Largest Contentful Paint (LCP) element but was given a "loading" value of "lazy", which can negatively impact application loading performance. This warning can be addressed by changing the loading value of the LCP image to "eager", or by using the NgOptimizedImage directive's prioritization utilities. For more information about addressing or disabling this warning, see https://angular.io/errors/NG0913`));
}
function logOversizedImageWarning(src) {
console.warn(formatRuntimeError(-913, `An image with src ${src} has intrinsic file dimensions much larger than its rendered size. This can negatively impact application loading performance. For more information about addressing or disabling this warning, see https://angular.io/errors/NG0913`));
}
function internalCreateApplication(config2) {
try {
const { rootComponent, appProviders, platformProviders } = config2;
if ((typeof ngDevMode === "undefined" || ngDevMode) && rootComponent !== void 0) {
assertStandaloneComponentType(rootComponent);
}
const platformInjector = createOrReusePlatformInjector(platformProviders);
const allAppProviders = [
provideZoneChangeDetection(),
...appProviders || []
];
const adapter = new EnvironmentNgModuleRefAdapter({
providers: allAppProviders,
parent: platformInjector,
debugName: typeof ngDevMode === "undefined" || ngDevMode ? "Environment Injector" : "",
// We skip environment initializers because we need to run them inside the NgZone, which
// happens after we get the NgZone instance from the Injector.
runEnvironmentInitializers: false
});
const envInjector = adapter.injector;
const ngZone = envInjector.get(NgZone);
return ngZone.run(() => {
envInjector.resolveInjectorInitializers();
const exceptionHandler = envInjector.get(ErrorHandler, null);
if ((typeof ngDevMode === "undefined" || ngDevMode) && !exceptionHandler) {
throw new RuntimeError(402, "No `ErrorHandler` found in the Dependency Injection tree.");
}
let onErrorSubscription;
ngZone.runOutsideAngular(() => {
onErrorSubscription = ngZone.onError.subscribe({
next: (error) => {
exceptionHandler.handleError(error);
}
});
});
const destroyListener = () => envInjector.destroy();
const onPlatformDestroyListeners = platformInjector.get(PLATFORM_DESTROY_LISTENERS);
onPlatformDestroyListeners.add(destroyListener);
envInjector.onDestroy(() => {
onErrorSubscription.unsubscribe();
onPlatformDestroyListeners.delete(destroyListener);
});
return _callAndReportToErrorHandler(exceptionHandler, ngZone, () => {
const initStatus = envInjector.get(ApplicationInitStatus);
initStatus.runInitializers();
return initStatus.donePromise.then(() => {
const localeId = envInjector.get(LOCALE_ID, DEFAULT_LOCALE_ID);
setLocaleId(localeId || DEFAULT_LOCALE_ID);
const appRef = envInjector.get(ApplicationRef);
if (rootComponent !== void 0) {
appRef.bootstrap(rootComponent);
}
if (typeof ngDevMode === "undefined" || ngDevMode) {
const imagePerformanceService = envInjector.get(ImagePerformanceWarning);
imagePerformanceService.start();
}
return appRef;
});
});
});
} catch (e) {
return Promise.reject(e);
}
}
var _ChangeDetectionSchedulerImpl = class _ChangeDetectionSchedulerImpl {
constructor() {
this.appRef = inject(ApplicationRef);
this.taskService = inject(PendingTasks);
this.pendingRenderTaskId = null;
this.shouldRefreshViews = false;
}
notify(type = 0) {
this.shouldRefreshViews ||= type === 0;
if (this.pendingRenderTaskId !== null) {
return;
}
this.pendingRenderTaskId = this.taskService.add();
this.raceTimeoutAndRequestAnimationFrame();
}
/**
* Run change detection after the first of setTimeout and requestAnimationFrame resolves.
*
* - `requestAnimationFrame` ensures that change detection runs ahead of a browser repaint.
* This ensures that the create and update passes of a change detection always happen
* in the same frame.
* - When the browser is resource-starved, `rAF` can execute _before_ a `setTimeout` because
* rendering is a very high priority process. This means that `setTimeout` cannot guarantee
* same-frame create and update pass, when `setTimeout` is used to schedule the update phase.
* - While `rAF` gives us the desirable same-frame updates, it has two limitations that
* prevent it from being used alone. First, it does not run in background tabs, which would
* prevent Angular from initializing an application when opened in a new tab (for example).
* Second, repeated calls to requestAnimationFrame will execute at the refresh rate of the
* hardware (~16ms for a 60Hz display). This would cause significant slowdown of tests that
* are written with several updates and asserts in the form of "update; await stable; assert;".
* - Both `setTimeout` and `rAF` are able to "coalesce" several events from a single user
* interaction into a single change detection. Importantly, this reduces view tree traversals when
* compared to an alternative timing mechanism like `queueMicrotask`, where change detection would
* then be interleaves between each event.
*
* By running change detection after the first of `setTimeout` and `rAF` to execute, we get the
* best of both worlds.
*/
raceTimeoutAndRequestAnimationFrame() {
return __async(this, null, function* () {
const timeout = new Promise((resolve) => setTimeout(resolve));
const rAF = typeof _global["requestAnimationFrame"] === "function" ? new Promise((resolve) => requestAnimationFrame(() => resolve())) : null;
yield Promise.race([timeout, rAF]);
this.tick();
});
}
tick() {
try {
if (!this.appRef.destroyed) {
this.appRef._tick(this.shouldRefreshViews);
}
} finally {
this.shouldRefreshViews = false;
const taskId = this.pendingRenderTaskId;
this.pendingRenderTaskId = null;
this.taskService.remove(taskId);
}
}
};
_ChangeDetectionSchedulerImpl.\u0275fac = function ChangeDetectionSchedulerImpl_Factory(t) {
return new (t || _ChangeDetectionSchedulerImpl)();
};
_ChangeDetectionSchedulerImpl.\u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({ token: _ChangeDetectionSchedulerImpl, factory: _ChangeDetectionSchedulerImpl.\u0275fac, providedIn: "root" });
var ChangeDetectionSchedulerImpl = _ChangeDetectionSchedulerImpl;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(ChangeDetectionSchedulerImpl, [{
type: Injectable,
args: [{ providedIn: "root" }]
}], null, null);
})();
function booleanAttribute(value2) {
return typeof value2 === "boolean" ? value2 : value2 != null && value2 !== "false";
}
function numberAttribute(value2, fallbackValue = NaN) {
const isNumberValue = !isNaN(parseFloat(value2)) && !isNaN(Number(value2));
return isNumberValue ? Number(value2) : fallbackValue;
}
function untracked(nonReactiveReadsFn) {
const prevConsumer = setActiveConsumer(null);
try {
return nonReactiveReadsFn();
} finally {
setActiveConsumer(prevConsumer);
}
}
var APP_EFFECT_SCHEDULER = new InjectionToken("", {
providedIn: "root",
factory: () => inject(EffectScheduler)
});
var _EffectScheduler = class _EffectScheduler {
};
_EffectScheduler.\u0275prov = \u0275\u0275defineInjectable({
token: _EffectScheduler,
providedIn: "root",
factory: () => new ZoneAwareEffectScheduler()
});
var EffectScheduler = _EffectScheduler;
var ZoneAwareEffectScheduler = class {
constructor() {
this.queuedEffectCount = 0;
this.queues = /* @__PURE__ */ new Map();
this.pendingTasks = inject(PendingTasks);
this.taskId = null;
}
scheduleEffect(handle) {
this.enqueue(handle);
if (this.taskId === null) {
const taskId = this.taskId = this.pendingTasks.add();
queueMicrotask(() => {
this.flush();
this.pendingTasks.remove(taskId);
this.taskId = null;
});
}
}
enqueue(handle) {
const zone = handle.creationZone;
if (!this.queues.has(zone)) {
this.queues.set(zone, /* @__PURE__ */ new Set());
}
const queue = this.queues.get(zone);
if (queue.has(handle)) {
return;
}
this.queuedEffectCount++;
queue.add(handle);
}
/**
* Run all scheduled effects.
*
* Execution order of effects within the same zone is guaranteed to be FIFO, but there is no
* ordering guarantee between effects scheduled in different zones.
*/
flush() {
while (this.queuedEffectCount > 0) {
for (const [zone, queue] of this.queues) {
if (zone === null) {
this.flushQueue(queue);
} else {
zone.run(() => this.flushQueue(queue));
}
}
}
}
flushQueue(queue) {
for (const handle of queue) {
queue.delete(handle);
this.queuedEffectCount--;
handle.run();
}
}
};
function reflectComponentType(component) {
const componentDef = getComponentDef(component);
if (!componentDef)
return null;
const factory = new ComponentFactory(componentDef);
return {
get selector() {
return factory.selector;
},
get type() {
return factory.componentType;
},
get inputs() {
return factory.inputs;
},
get outputs() {
return factory.outputs;
},
get ngContentSelectors() {
return factory.ngContentSelectors;
},
get isStandalone() {
return componentDef.standalone;
},
get isSignal() {
return componentDef.signals;
}
};
}
if (typeof ngDevMode !== "undefined" && ngDevMode) {
_global.$localize ??= function() {
throw new Error("It looks like your application or one of its dependencies is using i18n.\nAngular 9 introduced a global `$localize()` function that needs to be loaded.\nPlease run `ng add @angular/localize` from the Angular CLI.\n(For non-CLI projects, add `import '@angular/localize/init';` to your `polyfills.ts` file.\nFor server-side rendering applications add the import to your `main.server.ts` file.)");
};
}
// node_modules/@angular/common/fesm2022/common.mjs
var _DOM = null;
function getDOM() {
return _DOM;
}
function setRootDomAdapter(adapter) {
_DOM ??= adapter;
}
var DomAdapter = class {
};
var _PlatformNavigation = class _PlatformNavigation {
};
_PlatformNavigation.\u0275fac = function PlatformNavigation_Factory(t) {
return new (t || _PlatformNavigation)();
};
_PlatformNavigation.\u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
token: _PlatformNavigation,
factory: () => (() => window.navigation)(),
providedIn: "platform"
});
var PlatformNavigation = _PlatformNavigation;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(PlatformNavigation, [{
type: Injectable,
args: [{
providedIn: "platform",
useFactory: () => window.navigation
}]
}], null, null);
})();
var DOCUMENT2 = new InjectionToken(ngDevMode ? "DocumentToken" : "");
var _PlatformLocation = class _PlatformLocation {
historyGo(relativePosition) {
throw new Error(ngDevMode ? "Not implemented" : "");
}
};
_PlatformLocation.\u0275fac = function PlatformLocation_Factory(t) {
return new (t || _PlatformLocation)();
};
_PlatformLocation.\u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
token: _PlatformLocation,
factory: () => (() => inject(BrowserPlatformLocation))(),
providedIn: "platform"
});
var PlatformLocation = _PlatformLocation;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(PlatformLocation, [{
type: Injectable,
args: [{
providedIn: "platform",
useFactory: () => inject(BrowserPlatformLocation)
}]
}], null, null);
})();
var LOCATION_INITIALIZED = new InjectionToken(ngDevMode ? "Location Initialized" : "");
var _BrowserPlatformLocation = class _BrowserPlatformLocation extends PlatformLocation {
constructor() {
super();
this._doc = inject(DOCUMENT2);
this._location = window.location;
this._history = window.history;
}
getBaseHrefFromDOM() {
return getDOM().getBaseHref(this._doc);
}
onPopState(fn) {
const window2 = getDOM().getGlobalEventTarget(this._doc, "window");
window2.addEventListener("popstate", fn, false);
return () => window2.removeEventListener("popstate", fn);
}
onHashChange(fn) {
const window2 = getDOM().getGlobalEventTarget(this._doc, "window");
window2.addEventListener("hashchange", fn, false);
return () => window2.removeEventListener("hashchange", fn);
}
get href() {
return this._location.href;
}
get protocol() {
return this._location.protocol;
}
get hostname() {
return this._location.hostname;
}
get port() {
return this._location.port;
}
get pathname() {
return this._location.pathname;
}
get search() {
return this._location.search;
}
get hash() {
return this._location.hash;
}
set pathname(newPath) {
this._location.pathname = newPath;
}
pushState(state, title, url) {
this._history.pushState(state, title, url);
}
replaceState(state, title, url) {
this._history.replaceState(state, title, url);
}
forward() {
this._history.forward();
}
back() {
this._history.back();
}
historyGo(relativePosition = 0) {
this._history.go(relativePosition);
}
getState() {
return this._history.state;
}
};
_BrowserPlatformLocation.\u0275fac = function BrowserPlatformLocation_Factory(t) {
return new (t || _BrowserPlatformLocation)();
};
_BrowserPlatformLocation.\u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
token: _BrowserPlatformLocation,
factory: () => (() => new _BrowserPlatformLocation())(),
providedIn: "platform"
});
var BrowserPlatformLocation = _BrowserPlatformLocation;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(BrowserPlatformLocation, [{
type: Injectable,
args: [{
providedIn: "platform",
useFactory: () => new BrowserPlatformLocation()
}]
}], () => [], null);
})();
function joinWithSlash(start, end) {
if (start.length == 0) {
return end;
}
if (end.length == 0) {
return start;
}
let slashes = 0;
if (start.endsWith("/")) {
slashes++;
}
if (end.startsWith("/")) {
slashes++;
}
if (slashes == 2) {
return start + end.substring(1);
}
if (slashes == 1) {
return start + end;
}
return start + "/" + end;
}
function stripTrailingSlash(url) {
const match2 = url.match(/#|\?|$/);
const pathEndIdx = match2 && match2.index || url.length;
const droppedSlashIdx = pathEndIdx - (url[pathEndIdx - 1] === "/" ? 1 : 0);
return url.slice(0, droppedSlashIdx) + url.slice(pathEndIdx);
}
function normalizeQueryParams(params) {
return params && params[0] !== "?" ? "?" + params : params;
}
var _LocationStrategy = class _LocationStrategy {
historyGo(relativePosition) {
throw new Error(ngDevMode ? "Not implemented" : "");
}
};
_LocationStrategy.\u0275fac = function LocationStrategy_Factory(t) {
return new (t || _LocationStrategy)();
};
_LocationStrategy.\u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
token: _LocationStrategy,
factory: () => (() => inject(PathLocationStrategy))(),
providedIn: "root"
});
var LocationStrategy = _LocationStrategy;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(LocationStrategy, [{
type: Injectable,
args: [{
providedIn: "root",
useFactory: () => inject(PathLocationStrategy)
}]
}], null, null);
})();
var APP_BASE_HREF = new InjectionToken(ngDevMode ? "appBaseHref" : "");
var _PathLocationStrategy = class _PathLocationStrategy extends LocationStrategy {
constructor(_platformLocation, href) {
super();
this._platformLocation = _platformLocation;
this._removeListenerFns = [];
this._baseHref = href ?? this._platformLocation.getBaseHrefFromDOM() ?? inject(DOCUMENT2).location?.origin ?? "";
}
/** @nodoc */
ngOnDestroy() {
while (this._removeListenerFns.length) {
this._removeListenerFns.pop()();
}
}
onPopState(fn) {
this._removeListenerFns.push(this._platformLocation.onPopState(fn), this._platformLocation.onHashChange(fn));
}
getBaseHref() {
return this._baseHref;
}
prepareExternalUrl(internal) {
return joinWithSlash(this._baseHref, internal);
}
path(includeHash = false) {
const pathname = this._platformLocation.pathname + normalizeQueryParams(this._platformLocation.search);
const hash = this._platformLocation.hash;
return hash && includeHash ? `${pathname}${hash}` : pathname;
}
pushState(state, title, url, queryParams) {
const externalUrl = this.prepareExternalUrl(url + normalizeQueryParams(queryParams));
this._platformLocation.pushState(state, title, externalUrl);
}
replaceState(state, title, url, queryParams) {
const externalUrl = this.prepareExternalUrl(url + normalizeQueryParams(queryParams));
this._platformLocation.replaceState(state, title, externalUrl);
}
forward() {
this._platformLocation.forward();
}
back() {
this._platformLocation.back();
}
getState() {
return this._platformLocation.getState();
}
historyGo(relativePosition = 0) {
this._platformLocation.historyGo?.(relativePosition);
}
};
_PathLocationStrategy.\u0275fac = function PathLocationStrategy_Factory(t) {
return new (t || _PathLocationStrategy)(\u0275\u0275inject(PlatformLocation), \u0275\u0275inject(APP_BASE_HREF, 8));
};
_PathLocationStrategy.\u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
token: _PathLocationStrategy,
factory: _PathLocationStrategy.\u0275fac,
providedIn: "root"
});
var PathLocationStrategy = _PathLocationStrategy;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(PathLocationStrategy, [{
type: Injectable,
args: [{
providedIn: "root"
}]
}], () => [{
type: PlatformLocation
}, {
type: void 0,
decorators: [{
type: Optional
}, {
type: Inject,
args: [APP_BASE_HREF]
}]
}], null);
})();
var _HashLocationStrategy = class _HashLocationStrategy extends LocationStrategy {
constructor(_platformLocation, _baseHref) {
super();
this._platformLocation = _platformLocation;
this._baseHref = "";
this._removeListenerFns = [];
if (_baseHref != null) {
this._baseHref = _baseHref;
}
}
/** @nodoc */
ngOnDestroy() {
while (this._removeListenerFns.length) {
this._removeListenerFns.pop()();
}
}
onPopState(fn) {
this._removeListenerFns.push(this._platformLocation.onPopState(fn), this._platformLocation.onHashChange(fn));
}
getBaseHref() {
return this._baseHref;
}
path(includeHash = false) {
const path = this._platformLocation.hash ?? "#";
return path.length > 0 ? path.substring(1) : path;
}
prepareExternalUrl(internal) {
const url = joinWithSlash(this._baseHref, internal);
return url.length > 0 ? "#" + url : url;
}
pushState(state, title, path, queryParams) {
let url = this.prepareExternalUrl(path + normalizeQueryParams(queryParams));
if (url.length == 0) {
url = this._platformLocation.pathname;
}
this._platformLocation.pushState(state, title, url);
}
replaceState(state, title, path, queryParams) {
let url = this.prepareExternalUrl(path + normalizeQueryParams(queryParams));
if (url.length == 0) {
url = this._platformLocation.pathname;
}
this._platformLocation.replaceState(state, title, url);
}
forward() {
this._platformLocation.forward();
}
back() {
this._platformLocation.back();
}
getState() {
return this._platformLocation.getState();
}
historyGo(relativePosition = 0) {
this._platformLocation.historyGo?.(relativePosition);
}
};
_HashLocationStrategy.\u0275fac = function HashLocationStrategy_Factory(t) {
return new (t || _HashLocationStrategy)(\u0275\u0275inject(PlatformLocation), \u0275\u0275inject(APP_BASE_HREF, 8));
};
_HashLocationStrategy.\u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
token: _HashLocationStrategy,
factory: _HashLocationStrategy.\u0275fac
});
var HashLocationStrategy = _HashLocationStrategy;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(HashLocationStrategy, [{
type: Injectable
}], () => [{
type: PlatformLocation
}, {
type: void 0,
decorators: [{
type: Optional
}, {
type: Inject,
args: [APP_BASE_HREF]
}]
}], null);
})();
var _Location = class _Location {
constructor(locationStrategy) {
this._subject = new EventEmitter();
this._urlChangeListeners = [];
this._urlChangeSubscription = null;
this._locationStrategy = locationStrategy;
const baseHref = this._locationStrategy.getBaseHref();
this._basePath = _stripOrigin(stripTrailingSlash(_stripIndexHtml(baseHref)));
this._locationStrategy.onPopState((ev) => {
this._subject.emit({
"url": this.path(true),
"pop": true,
"state": ev.state,
"type": ev.type
});
});
}
/** @nodoc */
ngOnDestroy() {
this._urlChangeSubscription?.unsubscribe();
this._urlChangeListeners = [];
}
/**
* Normalizes the URL path for this location.
*
* @param includeHash True to include an anchor fragment in the path.
*
* @returns The normalized URL path.
*/
// TODO: vsavkin. Remove the boolean flag and always include hash once the deprecated router is
// removed.
path(includeHash = false) {
return this.normalize(this._locationStrategy.path(includeHash));
}
/**
* Reports the current state of the location history.
* @returns The current value of the `history.state` object.
*/
getState() {
return this._locationStrategy.getState();
}
/**
* Normalizes the given path and compares to the current normalized path.
*
* @param path The given URL path.
* @param query Query parameters.
*
* @returns True if the given URL path is equal to the current normalized path, false
* otherwise.
*/
isCurrentPathEqualTo(path, query = "") {
return this.path() == this.normalize(path + normalizeQueryParams(query));
}
/**
* Normalizes a URL path by stripping any trailing slashes.
*
* @param url String representing a URL.
*
* @returns The normalized URL string.
*/
normalize(url) {
return _Location.stripTrailingSlash(_stripBasePath(this._basePath, _stripIndexHtml(url)));
}
/**
* Normalizes an external URL path.
* If the given URL doesn't begin with a leading slash (`'/'`), adds one
* before normalizing. Adds a hash if `HashLocationStrategy` is
* in use, or the `APP_BASE_HREF` if the `PathLocationStrategy` is in use.
*
* @param url String representing a URL.
*
* @returns A normalized platform-specific URL.
*/
prepareExternalUrl(url) {
if (url && url[0] !== "/") {
url = "/" + url;
}
return this._locationStrategy.prepareExternalUrl(url);
}
// TODO: rename this method to pushState
/**
* Changes the browser's URL to a normalized version of a given URL, and pushes a
* new item onto the platform's history.
*
* @param path URL path to normalize.
* @param query Query parameters.
* @param state Location history state.
*
*/
go(path, query = "", state = null) {
this._locationStrategy.pushState(state, "", path, query);
this._notifyUrlChangeListeners(this.prepareExternalUrl(path + normalizeQueryParams(query)), state);
}
/**
* Changes the browser's URL to a normalized version of the given URL, and replaces
* the top item on the platform's history stack.
*
* @param path URL path to normalize.
* @param query Query parameters.
* @param state Location history state.
*/
replaceState(path, query = "", state = null) {
this._locationStrategy.replaceState(state, "", path, query);
this._notifyUrlChangeListeners(this.prepareExternalUrl(path + normalizeQueryParams(query)), state);
}
/**
* Navigates forward in the platform's history.
*/
forward() {
this._locationStrategy.forward();
}
/**
* Navigates back in the platform's history.
*/
back() {
this._locationStrategy.back();
}
/**
* Navigate to a specific page from session history, identified by its relative position to the
* current page.
*
* @param relativePosition Position of the target page in the history relative to the current
* page.
* A negative value moves backwards, a positive value moves forwards, e.g. `location.historyGo(2)`
* moves forward two pages and `location.historyGo(-2)` moves back two pages. When we try to go
* beyond what's stored in the history session, we stay in the current page. Same behaviour occurs
* when `relativePosition` equals 0.
* @see https://developer.mozilla.org/en-US/docs/Web/API/History_API#Moving_to_a_specific_point_in_history
*/
historyGo(relativePosition = 0) {
this._locationStrategy.historyGo?.(relativePosition);
}
/**
* Registers a URL change listener. Use to catch updates performed by the Angular
* framework that are not detectible through "popstate" or "hashchange" events.
*
* @param fn The change handler function, which take a URL and a location history state.
* @returns A function that, when executed, unregisters a URL change listener.
*/
onUrlChange(fn) {
this._urlChangeListeners.push(fn);
this._urlChangeSubscription ??= this.subscribe((v) => {
this._notifyUrlChangeListeners(v.url, v.state);
});
return () => {
const fnIndex = this._urlChangeListeners.indexOf(fn);
this._urlChangeListeners.splice(fnIndex, 1);
if (this._urlChangeListeners.length === 0) {
this._urlChangeSubscription?.unsubscribe();
this._urlChangeSubscription = null;
}
};
}
/** @internal */
_notifyUrlChangeListeners(url = "", state) {
this._urlChangeListeners.forEach((fn) => fn(url, state));
}
/**
* Subscribes to the platform's `popState` events.
*
* Note: `Location.go()` does not trigger the `popState` event in the browser. Use
* `Location.onUrlChange()` to subscribe to URL changes instead.
*
* @param value Event that is triggered when the state history changes.
* @param exception The exception to throw.
*
* @see [onpopstate](https://developer.mozilla.org/en-US/docs/Web/API/WindowEventHandlers/onpopstate)
*
* @returns Subscribed events.
*/
subscribe(onNext, onThrow, onReturn) {
return this._subject.subscribe({
next: onNext,
error: onThrow,
complete: onReturn
});
}
};
_Location.normalizeQueryParams = normalizeQueryParams;
_Location.joinWithSlash = joinWithSlash;
_Location.stripTrailingSlash = stripTrailingSlash;
_Location.\u0275fac = function Location_Factory(t) {
return new (t || _Location)(\u0275\u0275inject(LocationStrategy));
};
_Location.\u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
token: _Location,
factory: () => createLocation(),
providedIn: "root"
});
var Location = _Location;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(Location, [{
type: Injectable,
args: [{
providedIn: "root",
// See #23917
useFactory: createLocation
}]
}], () => [{
type: LocationStrategy
}], null);
})();
function createLocation() {
return new Location(\u0275\u0275inject(LocationStrategy));
}
function _stripBasePath(basePath, url) {
if (!basePath || !url.startsWith(basePath)) {
return url;
}
const strippedUrl = url.substring(basePath.length);
if (strippedUrl === "" || ["/", ";", "?", "#"].includes(strippedUrl[0])) {
return strippedUrl;
}
return url;
}
function _stripIndexHtml(url) {
return url.replace(/\/index.html$/, "");
}
function _stripOrigin(baseHref) {
const isAbsoluteUrl2 = new RegExp("^(https?:)?//").test(baseHref);
if (isAbsoluteUrl2) {
const [, pathname] = baseHref.split(/\/\/[^\/]+/);
return pathname;
}
return baseHref;
}
var CURRENCIES_EN = {
"ADP": [void 0, void 0, 0],
"AFN": [void 0, "\u060B", 0],
"ALL": [void 0, void 0, 0],
"AMD": [void 0, "\u058F", 2],
"AOA": [void 0, "Kz"],
"ARS": [void 0, "$"],
"AUD": ["A$", "$"],
"AZN": [void 0, "\u20BC"],
"BAM": [void 0, "KM"],
"BBD": [void 0, "$"],
"BDT": [void 0, "\u09F3"],
"BHD": [void 0, void 0, 3],
"BIF": [void 0, void 0, 0],
"BMD": [void 0, "$"],
"BND": [void 0, "$"],
"BOB": [void 0, "Bs"],
"BRL": ["R$"],
"BSD": [void 0, "$"],
"BWP": [void 0, "P"],
"BYN": [void 0, void 0, 2],
"BYR": [void 0, void 0, 0],
"BZD": [void 0, "$"],
"CAD": ["CA$", "$", 2],
"CHF": [void 0, void 0, 2],
"CLF": [void 0, void 0, 4],
"CLP": [void 0, "$", 0],
"CNY": ["CN\xA5", "\xA5"],
"COP": [void 0, "$", 2],
"CRC": [void 0, "\u20A1", 2],
"CUC": [void 0, "$"],
"CUP": [void 0, "$"],
"CZK": [void 0, "K\u010D", 2],
"DJF": [void 0, void 0, 0],
"DKK": [void 0, "kr", 2],
"DOP": [void 0, "$"],
"EGP": [void 0, "E\xA3"],
"ESP": [void 0, "\u20A7", 0],
"EUR": ["\u20AC"],
"FJD": [void 0, "$"],
"FKP": [void 0, "\xA3"],
"GBP": ["\xA3"],
"GEL": [void 0, "\u20BE"],
"GHS": [void 0, "GH\u20B5"],
"GIP": [void 0, "\xA3"],
"GNF": [void 0, "FG", 0],
"GTQ": [void 0, "Q"],
"GYD": [void 0, "$", 2],
"HKD": ["HK$", "$"],
"HNL": [void 0, "L"],
"HRK": [void 0, "kn"],
"HUF": [void 0, "Ft", 2],
"IDR": [void 0, "Rp", 2],
"ILS": ["\u20AA"],
"INR": ["\u20B9"],
"IQD": [void 0, void 0, 0],
"IRR": [void 0, void 0, 0],
"ISK": [void 0, "kr", 0],
"ITL": [void 0, void 0, 0],
"JMD": [void 0, "$"],
"JOD": [void 0, void 0, 3],
"JPY": ["\xA5", void 0, 0],
"KHR": [void 0, "\u17DB"],
"KMF": [void 0, "CF", 0],
"KPW": [void 0, "\u20A9", 0],
"KRW": ["\u20A9", void 0, 0],
"KWD": [void 0, void 0, 3],
"KYD": [void 0, "$"],
"KZT": [void 0, "\u20B8"],
"LAK": [void 0, "\u20AD", 0],
"LBP": [void 0, "L\xA3", 0],
"LKR": [void 0, "Rs"],
"LRD": [void 0, "$"],
"LTL": [void 0, "Lt"],
"LUF": [void 0, void 0, 0],
"LVL": [void 0, "Ls"],
"LYD": [void 0, void 0, 3],
"MGA": [void 0, "Ar", 0],
"MGF": [void 0, void 0, 0],
"MMK": [void 0, "K", 0],
"MNT": [void 0, "\u20AE", 2],
"MRO": [void 0, void 0, 0],
"MUR": [void 0, "Rs", 2],
"MXN": ["MX$", "$"],
"MYR": [void 0, "RM"],
"NAD": [void 0, "$"],
"NGN": [void 0, "\u20A6"],
"NIO": [void 0, "C$"],
"NOK": [void 0, "kr", 2],
"NPR": [void 0, "Rs"],
"NZD": ["NZ$", "$"],
"OMR": [void 0, void 0, 3],
"PHP": ["\u20B1"],
"PKR": [void 0, "Rs", 2],
"PLN": [void 0, "z\u0142"],
"PYG": [void 0, "\u20B2", 0],
"RON": [void 0, "lei"],
"RSD": [void 0, void 0, 0],
"RUB": [void 0, "\u20BD"],
"RWF": [void 0, "RF", 0],
"SBD": [void 0, "$"],
"SEK": [void 0, "kr", 2],
"SGD": [void 0, "$"],
"SHP": [void 0, "\xA3"],
"SLE": [void 0, void 0, 2],
"SLL": [void 0, void 0, 0],
"SOS": [void 0, void 0, 0],
"SRD": [void 0, "$"],
"SSP": [void 0, "\xA3"],
"STD": [void 0, void 0, 0],
"STN": [void 0, "Db"],
"SYP": [void 0, "\xA3", 0],
"THB": [void 0, "\u0E3F"],
"TMM": [void 0, void 0, 0],
"TND": [void 0, void 0, 3],
"TOP": [void 0, "T$"],
"TRL": [void 0, void 0, 0],
"TRY": [void 0, "\u20BA"],
"TTD": [void 0, "$"],
"TWD": ["NT$", "$", 2],
"TZS": [void 0, void 0, 2],
"UAH": [void 0, "\u20B4"],
"UGX": [void 0, void 0, 0],
"USD": ["$"],
"UYI": [void 0, void 0, 0],
"UYU": [void 0, "$"],
"UYW": [void 0, void 0, 4],
"UZS": [void 0, void 0, 2],
"VEF": [void 0, "Bs", 2],
"VND": ["\u20AB", void 0, 0],
"VUV": [void 0, void 0, 0],
"XAF": ["FCFA", void 0, 0],
"XCD": ["EC$", "$"],
"XOF": ["F\u202FCFA", void 0, 0],
"XPF": ["CFPF", void 0, 0],
"XXX": ["\xA4"],
"YER": [void 0, void 0, 0],
"ZAR": [void 0, "R"],
"ZMK": [void 0, void 0, 0],
"ZMW": [void 0, "ZK"],
"ZWD": [void 0, void 0, 0]
};
var NumberFormatStyle;
(function(NumberFormatStyle2) {
NumberFormatStyle2[NumberFormatStyle2["Decimal"] = 0] = "Decimal";
NumberFormatStyle2[NumberFormatStyle2["Percent"] = 1] = "Percent";
NumberFormatStyle2[NumberFormatStyle2["Currency"] = 2] = "Currency";
NumberFormatStyle2[NumberFormatStyle2["Scientific"] = 3] = "Scientific";
})(NumberFormatStyle || (NumberFormatStyle = {}));
var Plural;
(function(Plural2) {
Plural2[Plural2["Zero"] = 0] = "Zero";
Plural2[Plural2["One"] = 1] = "One";
Plural2[Plural2["Two"] = 2] = "Two";
Plural2[Plural2["Few"] = 3] = "Few";
Plural2[Plural2["Many"] = 4] = "Many";
Plural2[Plural2["Other"] = 5] = "Other";
})(Plural || (Plural = {}));
var FormStyle;
(function(FormStyle2) {
FormStyle2[FormStyle2["Format"] = 0] = "Format";
FormStyle2[FormStyle2["Standalone"] = 1] = "Standalone";
})(FormStyle || (FormStyle = {}));
var TranslationWidth;
(function(TranslationWidth2) {
TranslationWidth2[TranslationWidth2["Narrow"] = 0] = "Narrow";
TranslationWidth2[TranslationWidth2["Abbreviated"] = 1] = "Abbreviated";
TranslationWidth2[TranslationWidth2["Wide"] = 2] = "Wide";
TranslationWidth2[TranslationWidth2["Short"] = 3] = "Short";
})(TranslationWidth || (TranslationWidth = {}));
var FormatWidth;
(function(FormatWidth2) {
FormatWidth2[FormatWidth2["Short"] = 0] = "Short";
FormatWidth2[FormatWidth2["Medium"] = 1] = "Medium";
FormatWidth2[FormatWidth2["Long"] = 2] = "Long";
FormatWidth2[FormatWidth2["Full"] = 3] = "Full";
})(FormatWidth || (FormatWidth = {}));
var NumberSymbol = {
/**
* Decimal separator.
* For `en-US`, the dot character.
* Example: 2,345`.`67
*/
Decimal: 0,
/**
* Grouping separator, typically for thousands.
* For `en-US`, the comma character.
* Example: 2`,`345.67
*/
Group: 1,
/**
* List-item separator.
* Example: "one, two, and three"
*/
List: 2,
/**
* Sign for percentage (out of 100).
* Example: 23.4%
*/
PercentSign: 3,
/**
* Sign for positive numbers.
* Example: +23
*/
PlusSign: 4,
/**
* Sign for negative numbers.
* Example: -23
*/
MinusSign: 5,
/**
* Computer notation for exponential value (n times a power of 10).
* Example: 1.2E3
*/
Exponential: 6,
/**
* Human-readable format of exponential.
* Example: 1.2x103
*/
SuperscriptingExponent: 7,
/**
* Sign for permille (out of 1000).
* Example: 23.4‰
*/
PerMille: 8,
/**
* Infinity, can be used with plus and minus.
* Example: ∞, +∞, -∞
*/
Infinity: 9,
/**
* Not a number.
* Example: NaN
*/
NaN: 10,
/**
* Symbol used between time units.
* Example: 10:52
*/
TimeSeparator: 11,
/**
* Decimal separator for currency values (fallback to `Decimal`).
* Example: $2,345.67
*/
CurrencyDecimal: 12,
/**
* Group separator for currency values (fallback to `Group`).
* Example: $2,345.67
*/
CurrencyGroup: 13
};
var WeekDay;
(function(WeekDay2) {
WeekDay2[WeekDay2["Sunday"] = 0] = "Sunday";
WeekDay2[WeekDay2["Monday"] = 1] = "Monday";
WeekDay2[WeekDay2["Tuesday"] = 2] = "Tuesday";
WeekDay2[WeekDay2["Wednesday"] = 3] = "Wednesday";
WeekDay2[WeekDay2["Thursday"] = 4] = "Thursday";
WeekDay2[WeekDay2["Friday"] = 5] = "Friday";
WeekDay2[WeekDay2["Saturday"] = 6] = "Saturday";
})(WeekDay || (WeekDay = {}));
function getLocaleId2(locale) {
return findLocaleData(locale)[LocaleDataIndex.LocaleId];
}
function getLocaleDayPeriods(locale, formStyle, width2) {
const data2 = findLocaleData(locale);
const amPmData = [data2[LocaleDataIndex.DayPeriodsFormat], data2[LocaleDataIndex.DayPeriodsStandalone]];
const amPm = getLastDefinedValue(amPmData, formStyle);
return getLastDefinedValue(amPm, width2);
}
function getLocaleDayNames(locale, formStyle, width2) {
const data2 = findLocaleData(locale);
const daysData = [data2[LocaleDataIndex.DaysFormat], data2[LocaleDataIndex.DaysStandalone]];
const days = getLastDefinedValue(daysData, formStyle);
return getLastDefinedValue(days, width2);
}
function getLocaleMonthNames(locale, formStyle, width2) {
const data2 = findLocaleData(locale);
const monthsData = [data2[LocaleDataIndex.MonthsFormat], data2[LocaleDataIndex.MonthsStandalone]];
const months = getLastDefinedValue(monthsData, formStyle);
return getLastDefinedValue(months, width2);
}
function getLocaleEraNames(locale, width2) {
const data2 = findLocaleData(locale);
const erasData = data2[LocaleDataIndex.Eras];
return getLastDefinedValue(erasData, width2);
}
function getLocaleDateFormat(locale, width2) {
const data2 = findLocaleData(locale);
return getLastDefinedValue(data2[LocaleDataIndex.DateFormat], width2);
}
function getLocaleTimeFormat(locale, width2) {
const data2 = findLocaleData(locale);
return getLastDefinedValue(data2[LocaleDataIndex.TimeFormat], width2);
}
function getLocaleDateTimeFormat(locale, width2) {
const data2 = findLocaleData(locale);
const dateTimeFormatData = data2[LocaleDataIndex.DateTimeFormat];
return getLastDefinedValue(dateTimeFormatData, width2);
}
function getLocaleNumberSymbol(locale, symbol) {
const data2 = findLocaleData(locale);
const res = data2[LocaleDataIndex.NumberSymbols][symbol];
if (typeof res === "undefined") {
if (symbol === NumberSymbol.CurrencyDecimal) {
return data2[LocaleDataIndex.NumberSymbols][NumberSymbol.Decimal];
} else if (symbol === NumberSymbol.CurrencyGroup) {
return data2[LocaleDataIndex.NumberSymbols][NumberSymbol.Group];
}
}
return res;
}
function getLocaleNumberFormat(locale, type) {
const data2 = findLocaleData(locale);
return data2[LocaleDataIndex.NumberFormats][type];
}
function getLocaleCurrencies(locale) {
const data2 = findLocaleData(locale);
return data2[LocaleDataIndex.Currencies];
}
var getLocalePluralCase2 = getLocalePluralCase;
function checkFullData(data2) {
if (!data2[LocaleDataIndex.ExtraData]) {
throw new Error(`Missing extra locale data for the locale "${data2[LocaleDataIndex.LocaleId]}". Use "registerLocaleData" to load new data. See the "I18n guide" on angular.io to know more.`);
}
}
function getLocaleExtraDayPeriodRules(locale) {
const data2 = findLocaleData(locale);
checkFullData(data2);
const rules = data2[LocaleDataIndex.ExtraData][
2
/* ɵExtraLocaleDataIndex.ExtraDayPeriodsRules */
] || [];
return rules.map((rule) => {
if (typeof rule === "string") {
return extractTime(rule);
}
return [extractTime(rule[0]), extractTime(rule[1])];
});
}
function getLocaleExtraDayPeriods(locale, formStyle, width2) {
const data2 = findLocaleData(locale);
checkFullData(data2);
const dayPeriodsData = [data2[LocaleDataIndex.ExtraData][
0
/* ɵExtraLocaleDataIndex.ExtraDayPeriodFormats */
], data2[LocaleDataIndex.ExtraData][
1
/* ɵExtraLocaleDataIndex.ExtraDayPeriodStandalone */
]];
const dayPeriods = getLastDefinedValue(dayPeriodsData, formStyle) || [];
return getLastDefinedValue(dayPeriods, width2) || [];
}
function getLastDefinedValue(data2, index2) {
for (let i = index2; i > -1; i--) {
if (typeof data2[i] !== "undefined") {
return data2[i];
}
}
throw new Error("Locale data API: locale data undefined");
}
function extractTime(time2) {
const [h, m] = time2.split(":");
return {
hours: +h,
minutes: +m
};
}
function getCurrencySymbol(code, format, locale = "en") {
const currency = getLocaleCurrencies(locale)[code] || CURRENCIES_EN[code] || [];
const symbolNarrow = currency[
1
/* ɵCurrencyIndex.SymbolNarrow */
];
if (format === "narrow" && typeof symbolNarrow === "string") {
return symbolNarrow;
}
return currency[
0
/* ɵCurrencyIndex.Symbol */
] || code;
}
var DEFAULT_NB_OF_CURRENCY_DIGITS = 2;
function getNumberOfCurrencyDigits(code) {
let digits;
const currency = CURRENCIES_EN[code];
if (currency) {
digits = currency[
2
/* ɵCurrencyIndex.NbOfDigits */
];
}
return typeof digits === "number" ? digits : DEFAULT_NB_OF_CURRENCY_DIGITS;
}
var ISO8601_DATE_REGEX = /^(\d{4,})-?(\d\d)-?(\d\d)(?:T(\d\d)(?::?(\d\d)(?::?(\d\d)(?:\.(\d+))?)?)?(Z|([+-])(\d\d):?(\d\d))?)?$/;
var NAMED_FORMATS = {};
var DATE_FORMATS_SPLIT = /((?:[^BEGHLMOSWYZabcdhmswyz']+)|(?:'(?:[^']|'')*')|(?:G{1,5}|y{1,4}|Y{1,4}|M{1,5}|L{1,5}|w{1,2}|W{1}|d{1,2}|E{1,6}|c{1,6}|a{1,5}|b{1,5}|B{1,5}|h{1,2}|H{1,2}|m{1,2}|s{1,2}|S{1,3}|z{1,4}|Z{1,5}|O{1,4}))([\s\S]*)/;
var ZoneWidth;
(function(ZoneWidth2) {
ZoneWidth2[ZoneWidth2["Short"] = 0] = "Short";
ZoneWidth2[ZoneWidth2["ShortGMT"] = 1] = "ShortGMT";
ZoneWidth2[ZoneWidth2["Long"] = 2] = "Long";
ZoneWidth2[ZoneWidth2["Extended"] = 3] = "Extended";
})(ZoneWidth || (ZoneWidth = {}));
var DateType;
(function(DateType2) {
DateType2[DateType2["FullYear"] = 0] = "FullYear";
DateType2[DateType2["Month"] = 1] = "Month";
DateType2[DateType2["Date"] = 2] = "Date";
DateType2[DateType2["Hours"] = 3] = "Hours";
DateType2[DateType2["Minutes"] = 4] = "Minutes";
DateType2[DateType2["Seconds"] = 5] = "Seconds";
DateType2[DateType2["FractionalSeconds"] = 6] = "FractionalSeconds";
DateType2[DateType2["Day"] = 7] = "Day";
})(DateType || (DateType = {}));
var TranslationType;
(function(TranslationType2) {
TranslationType2[TranslationType2["DayPeriods"] = 0] = "DayPeriods";
TranslationType2[TranslationType2["Days"] = 1] = "Days";
TranslationType2[TranslationType2["Months"] = 2] = "Months";
TranslationType2[TranslationType2["Eras"] = 3] = "Eras";
})(TranslationType || (TranslationType = {}));
function formatDate(value2, format, locale, timezone) {
let date = toDate(value2);
const namedFormat = getNamedFormat(locale, format);
format = namedFormat || format;
let parts = [];
let match2;
while (format) {
match2 = DATE_FORMATS_SPLIT.exec(format);
if (match2) {
parts = parts.concat(match2.slice(1));
const part = parts.pop();
if (!part) {
break;
}
format = part;
} else {
parts.push(format);
break;
}
}
let dateTimezoneOffset = date.getTimezoneOffset();
if (timezone) {
dateTimezoneOffset = timezoneToOffset(timezone, dateTimezoneOffset);
date = convertTimezoneToLocal(date, timezone, true);
}
let text2 = "";
parts.forEach((value3) => {
const dateFormatter = getDateFormatter(value3);
text2 += dateFormatter ? dateFormatter(date, locale, dateTimezoneOffset) : value3 === "''" ? "'" : value3.replace(/(^'|'$)/g, "").replace(/''/g, "'");
});
return text2;
}
function createDate(year, month, date) {
const newDate = /* @__PURE__ */ new Date(0);
newDate.setFullYear(year, month, date);
newDate.setHours(0, 0, 0);
return newDate;
}
function getNamedFormat(locale, format) {
const localeId = getLocaleId2(locale);
NAMED_FORMATS[localeId] ??= {};
if (NAMED_FORMATS[localeId][format]) {
return NAMED_FORMATS[localeId][format];
}
let formatValue2 = "";
switch (format) {
case "shortDate":
formatValue2 = getLocaleDateFormat(locale, FormatWidth.Short);
break;
case "mediumDate":
formatValue2 = getLocaleDateFormat(locale, FormatWidth.Medium);
break;
case "longDate":
formatValue2 = getLocaleDateFormat(locale, FormatWidth.Long);
break;
case "fullDate":
formatValue2 = getLocaleDateFormat(locale, FormatWidth.Full);
break;
case "shortTime":
formatValue2 = getLocaleTimeFormat(locale, FormatWidth.Short);
break;
case "mediumTime":
formatValue2 = getLocaleTimeFormat(locale, FormatWidth.Medium);
break;
case "longTime":
formatValue2 = getLocaleTimeFormat(locale, FormatWidth.Long);
break;
case "fullTime":
formatValue2 = getLocaleTimeFormat(locale, FormatWidth.Full);
break;
case "short":
const shortTime = getNamedFormat(locale, "shortTime");
const shortDate = getNamedFormat(locale, "shortDate");
formatValue2 = formatDateTime(getLocaleDateTimeFormat(locale, FormatWidth.Short), [shortTime, shortDate]);
break;
case "medium":
const mediumTime = getNamedFormat(locale, "mediumTime");
const mediumDate = getNamedFormat(locale, "mediumDate");
formatValue2 = formatDateTime(getLocaleDateTimeFormat(locale, FormatWidth.Medium), [mediumTime, mediumDate]);
break;
case "long":
const longTime = getNamedFormat(locale, "longTime");
const longDate = getNamedFormat(locale, "longDate");
formatValue2 = formatDateTime(getLocaleDateTimeFormat(locale, FormatWidth.Long), [longTime, longDate]);
break;
case "full":
const fullTime = getNamedFormat(locale, "fullTime");
const fullDate = getNamedFormat(locale, "fullDate");
formatValue2 = formatDateTime(getLocaleDateTimeFormat(locale, FormatWidth.Full), [fullTime, fullDate]);
break;
}
if (formatValue2) {
NAMED_FORMATS[localeId][format] = formatValue2;
}
return formatValue2;
}
function formatDateTime(str, opt_values) {
if (opt_values) {
str = str.replace(/\{([^}]+)}/g, function(match2, key2) {
return opt_values != null && key2 in opt_values ? opt_values[key2] : match2;
});
}
return str;
}
function padNumber(num, digits, minusSign = "-", trim, negWrap) {
let neg = "";
if (num < 0 || negWrap && num <= 0) {
if (negWrap) {
num = -num + 1;
} else {
num = -num;
neg = minusSign;
}
}
let strNum = String(num);
while (strNum.length < digits) {
strNum = "0" + strNum;
}
if (trim) {
strNum = strNum.slice(strNum.length - digits);
}
return neg + strNum;
}
function formatFractionalSeconds(milliseconds, digits) {
const strMs = padNumber(milliseconds, 3);
return strMs.substring(0, digits);
}
function dateGetter(name2, size, offset = 0, trim = false, negWrap = false) {
return function(date, locale) {
let part = getDatePart(name2, date);
if (offset > 0 || part > -offset) {
part += offset;
}
if (name2 === DateType.Hours) {
if (part === 0 && offset === -12) {
part = 12;
}
} else if (name2 === DateType.FractionalSeconds) {
return formatFractionalSeconds(part, size);
}
const localeMinus = getLocaleNumberSymbol(locale, NumberSymbol.MinusSign);
return padNumber(part, size, localeMinus, trim, negWrap);
};
}
function getDatePart(part, date) {
switch (part) {
case DateType.FullYear:
return date.getFullYear();
case DateType.Month:
return date.getMonth();
case DateType.Date:
return date.getDate();
case DateType.Hours:
return date.getHours();
case DateType.Minutes:
return date.getMinutes();
case DateType.Seconds:
return date.getSeconds();
case DateType.FractionalSeconds:
return date.getMilliseconds();
case DateType.Day:
return date.getDay();
default:
throw new Error(`Unknown DateType value "${part}".`);
}
}
function dateStrGetter(name2, width2, form = FormStyle.Format, extended = false) {
return function(date, locale) {
return getDateTranslation(date, locale, name2, width2, form, extended);
};
}
function getDateTranslation(date, locale, name2, width2, form, extended) {
switch (name2) {
case TranslationType.Months:
return getLocaleMonthNames(locale, form, width2)[date.getMonth()];
case TranslationType.Days:
return getLocaleDayNames(locale, form, width2)[date.getDay()];
case TranslationType.DayPeriods:
const currentHours = date.getHours();
const currentMinutes = date.getMinutes();
if (extended) {
const rules = getLocaleExtraDayPeriodRules(locale);
const dayPeriods = getLocaleExtraDayPeriods(locale, form, width2);
const index2 = rules.findIndex((rule) => {
if (Array.isArray(rule)) {
const [from2, to] = rule;
const afterFrom = currentHours >= from2.hours && currentMinutes >= from2.minutes;
const beforeTo = currentHours < to.hours || currentHours === to.hours && currentMinutes < to.minutes;
if (from2.hours < to.hours) {
if (afterFrom && beforeTo) {
return true;
}
} else if (afterFrom || beforeTo) {
return true;
}
} else {
if (rule.hours === currentHours && rule.minutes === currentMinutes) {
return true;
}
}
return false;
});
if (index2 !== -1) {
return dayPeriods[index2];
}
}
return getLocaleDayPeriods(locale, form, width2)[currentHours < 12 ? 0 : 1];
case TranslationType.Eras:
return getLocaleEraNames(locale, width2)[date.getFullYear() <= 0 ? 0 : 1];
default:
const unexpected = name2;
throw new Error(`unexpected translation type ${unexpected}`);
}
}
function timeZoneGetter(width2) {
return function(date, locale, offset) {
const zone = -1 * offset;
const minusSign = getLocaleNumberSymbol(locale, NumberSymbol.MinusSign);
const hours = zone > 0 ? Math.floor(zone / 60) : Math.ceil(zone / 60);
switch (width2) {
case ZoneWidth.Short:
return (zone >= 0 ? "+" : "") + padNumber(hours, 2, minusSign) + padNumber(Math.abs(zone % 60), 2, minusSign);
case ZoneWidth.ShortGMT:
return "GMT" + (zone >= 0 ? "+" : "") + padNumber(hours, 1, minusSign);
case ZoneWidth.Long:
return "GMT" + (zone >= 0 ? "+" : "") + padNumber(hours, 2, minusSign) + ":" + padNumber(Math.abs(zone % 60), 2, minusSign);
case ZoneWidth.Extended:
if (offset === 0) {
return "Z";
} else {
return (zone >= 0 ? "+" : "") + padNumber(hours, 2, minusSign) + ":" + padNumber(Math.abs(zone % 60), 2, minusSign);
}
default:
throw new Error(`Unknown zone width "${width2}"`);
}
};
}
var JANUARY = 0;
var THURSDAY = 4;
function getFirstThursdayOfYear(year) {
const firstDayOfYear = createDate(year, JANUARY, 1).getDay();
return createDate(year, 0, 1 + (firstDayOfYear <= THURSDAY ? THURSDAY : THURSDAY + 7) - firstDayOfYear);
}
function getThursdayThisIsoWeek(datetime) {
const currentDay = datetime.getDay();
const deltaToThursday = currentDay === 0 ? -3 : THURSDAY - currentDay;
return createDate(datetime.getFullYear(), datetime.getMonth(), datetime.getDate() + deltaToThursday);
}
function weekGetter(size, monthBased = false) {
return function(date, locale) {
let result;
if (monthBased) {
const nbDaysBefore1stDayOfMonth = new Date(date.getFullYear(), date.getMonth(), 1).getDay() - 1;
const today = date.getDate();
result = 1 + Math.floor((today + nbDaysBefore1stDayOfMonth) / 7);
} else {
const thisThurs = getThursdayThisIsoWeek(date);
const firstThurs = getFirstThursdayOfYear(thisThurs.getFullYear());
const diff = thisThurs.getTime() - firstThurs.getTime();
result = 1 + Math.round(diff / 6048e5);
}
return padNumber(result, size, getLocaleNumberSymbol(locale, NumberSymbol.MinusSign));
};
}
function weekNumberingYearGetter(size, trim = false) {
return function(date, locale) {
const thisThurs = getThursdayThisIsoWeek(date);
const weekNumberingYear = thisThurs.getFullYear();
return padNumber(weekNumberingYear, size, getLocaleNumberSymbol(locale, NumberSymbol.MinusSign), trim);
};
}
var DATE_FORMATS = {};
function getDateFormatter(format) {
if (DATE_FORMATS[format]) {
return DATE_FORMATS[format];
}
let formatter;
switch (format) {
case "G":
case "GG":
case "GGG":
formatter = dateStrGetter(TranslationType.Eras, TranslationWidth.Abbreviated);
break;
case "GGGG":
formatter = dateStrGetter(TranslationType.Eras, TranslationWidth.Wide);
break;
case "GGGGG":
formatter = dateStrGetter(TranslationType.Eras, TranslationWidth.Narrow);
break;
case "y":
formatter = dateGetter(DateType.FullYear, 1, 0, false, true);
break;
case "yy":
formatter = dateGetter(DateType.FullYear, 2, 0, true, true);
break;
case "yyy":
formatter = dateGetter(DateType.FullYear, 3, 0, false, true);
break;
case "yyyy":
formatter = dateGetter(DateType.FullYear, 4, 0, false, true);
break;
case "Y":
formatter = weekNumberingYearGetter(1);
break;
case "YY":
formatter = weekNumberingYearGetter(2, true);
break;
case "YYY":
formatter = weekNumberingYearGetter(3);
break;
case "YYYY":
formatter = weekNumberingYearGetter(4);
break;
case "M":
case "L":
formatter = dateGetter(DateType.Month, 1, 1);
break;
case "MM":
case "LL":
formatter = dateGetter(DateType.Month, 2, 1);
break;
case "MMM":
formatter = dateStrGetter(TranslationType.Months, TranslationWidth.Abbreviated);
break;
case "MMMM":
formatter = dateStrGetter(TranslationType.Months, TranslationWidth.Wide);
break;
case "MMMMM":
formatter = dateStrGetter(TranslationType.Months, TranslationWidth.Narrow);
break;
case "LLL":
formatter = dateStrGetter(TranslationType.Months, TranslationWidth.Abbreviated, FormStyle.Standalone);
break;
case "LLLL":
formatter = dateStrGetter(TranslationType.Months, TranslationWidth.Wide, FormStyle.Standalone);
break;
case "LLLLL":
formatter = dateStrGetter(TranslationType.Months, TranslationWidth.Narrow, FormStyle.Standalone);
break;
case "w":
formatter = weekGetter(1);
break;
case "ww":
formatter = weekGetter(2);
break;
case "W":
formatter = weekGetter(1, true);
break;
case "d":
formatter = dateGetter(DateType.Date, 1);
break;
case "dd":
formatter = dateGetter(DateType.Date, 2);
break;
case "c":
case "cc":
formatter = dateGetter(DateType.Day, 1);
break;
case "ccc":
formatter = dateStrGetter(TranslationType.Days, TranslationWidth.Abbreviated, FormStyle.Standalone);
break;
case "cccc":
formatter = dateStrGetter(TranslationType.Days, TranslationWidth.Wide, FormStyle.Standalone);
break;
case "ccccc":
formatter = dateStrGetter(TranslationType.Days, TranslationWidth.Narrow, FormStyle.Standalone);
break;
case "cccccc":
formatter = dateStrGetter(TranslationType.Days, TranslationWidth.Short, FormStyle.Standalone);
break;
case "E":
case "EE":
case "EEE":
formatter = dateStrGetter(TranslationType.Days, TranslationWidth.Abbreviated);
break;
case "EEEE":
formatter = dateStrGetter(TranslationType.Days, TranslationWidth.Wide);
break;
case "EEEEE":
formatter = dateStrGetter(TranslationType.Days, TranslationWidth.Narrow);
break;
case "EEEEEE":
formatter = dateStrGetter(TranslationType.Days, TranslationWidth.Short);
break;
case "a":
case "aa":
case "aaa":
formatter = dateStrGetter(TranslationType.DayPeriods, TranslationWidth.Abbreviated);
break;
case "aaaa":
formatter = dateStrGetter(TranslationType.DayPeriods, TranslationWidth.Wide);
break;
case "aaaaa":
formatter = dateStrGetter(TranslationType.DayPeriods, TranslationWidth.Narrow);
break;
case "b":
case "bb":
case "bbb":
formatter = dateStrGetter(TranslationType.DayPeriods, TranslationWidth.Abbreviated, FormStyle.Standalone, true);
break;
case "bbbb":
formatter = dateStrGetter(TranslationType.DayPeriods, TranslationWidth.Wide, FormStyle.Standalone, true);
break;
case "bbbbb":
formatter = dateStrGetter(TranslationType.DayPeriods, TranslationWidth.Narrow, FormStyle.Standalone, true);
break;
case "B":
case "BB":
case "BBB":
formatter = dateStrGetter(TranslationType.DayPeriods, TranslationWidth.Abbreviated, FormStyle.Format, true);
break;
case "BBBB":
formatter = dateStrGetter(TranslationType.DayPeriods, TranslationWidth.Wide, FormStyle.Format, true);
break;
case "BBBBB":
formatter = dateStrGetter(TranslationType.DayPeriods, TranslationWidth.Narrow, FormStyle.Format, true);
break;
case "h":
formatter = dateGetter(DateType.Hours, 1, -12);
break;
case "hh":
formatter = dateGetter(DateType.Hours, 2, -12);
break;
case "H":
formatter = dateGetter(DateType.Hours, 1);
break;
case "HH":
formatter = dateGetter(DateType.Hours, 2);
break;
case "m":
formatter = dateGetter(DateType.Minutes, 1);
break;
case "mm":
formatter = dateGetter(DateType.Minutes, 2);
break;
case "s":
formatter = dateGetter(DateType.Seconds, 1);
break;
case "ss":
formatter = dateGetter(DateType.Seconds, 2);
break;
case "S":
formatter = dateGetter(DateType.FractionalSeconds, 1);
break;
case "SS":
formatter = dateGetter(DateType.FractionalSeconds, 2);
break;
case "SSS":
formatter = dateGetter(DateType.FractionalSeconds, 3);
break;
case "Z":
case "ZZ":
case "ZZZ":
formatter = timeZoneGetter(ZoneWidth.Short);
break;
case "ZZZZZ":
formatter = timeZoneGetter(ZoneWidth.Extended);
break;
case "O":
case "OO":
case "OOO":
case "z":
case "zz":
case "zzz":
formatter = timeZoneGetter(ZoneWidth.ShortGMT);
break;
case "OOOO":
case "ZZZZ":
case "zzzz":
formatter = timeZoneGetter(ZoneWidth.Long);
break;
default:
return null;
}
DATE_FORMATS[format] = formatter;
return formatter;
}
function timezoneToOffset(timezone, fallback) {
timezone = timezone.replace(/:/g, "");
const requestedTimezoneOffset = Date.parse("Jan 01, 1970 00:00:00 " + timezone) / 6e4;
return isNaN(requestedTimezoneOffset) ? fallback : requestedTimezoneOffset;
}
function addDateMinutes(date, minutes) {
date = new Date(date.getTime());
date.setMinutes(date.getMinutes() + minutes);
return date;
}
function convertTimezoneToLocal(date, timezone, reverse) {
const reverseValue = reverse ? -1 : 1;
const dateTimezoneOffset = date.getTimezoneOffset();
const timezoneOffset = timezoneToOffset(timezone, dateTimezoneOffset);
return addDateMinutes(date, reverseValue * (timezoneOffset - dateTimezoneOffset));
}
function toDate(value2) {
if (isDate(value2)) {
return value2;
}
if (typeof value2 === "number" && !isNaN(value2)) {
return new Date(value2);
}
if (typeof value2 === "string") {
value2 = value2.trim();
if (/^(\d{4}(-\d{1,2}(-\d{1,2})?)?)$/.test(value2)) {
const [y, m = 1, d = 1] = value2.split("-").map((val2) => +val2);
return createDate(y, m - 1, d);
}
const parsedNb = parseFloat(value2);
if (!isNaN(value2 - parsedNb)) {
return new Date(parsedNb);
}
let match2;
if (match2 = value2.match(ISO8601_DATE_REGEX)) {
return isoStringToDate(match2);
}
}
const date = new Date(value2);
if (!isDate(date)) {
throw new Error(`Unable to convert "${value2}" into a date`);
}
return date;
}
function isoStringToDate(match2) {
const date = /* @__PURE__ */ new Date(0);
let tzHour = 0;
let tzMin = 0;
const dateSetter = match2[8] ? date.setUTCFullYear : date.setFullYear;
const timeSetter = match2[8] ? date.setUTCHours : date.setHours;
if (match2[9]) {
tzHour = Number(match2[9] + match2[10]);
tzMin = Number(match2[9] + match2[11]);
}
dateSetter.call(date, Number(match2[1]), Number(match2[2]) - 1, Number(match2[3]));
const h = Number(match2[4] || 0) - tzHour;
const m = Number(match2[5] || 0) - tzMin;
const s = Number(match2[6] || 0);
const ms = Math.floor(parseFloat("0." + (match2[7] || 0)) * 1e3);
timeSetter.call(date, h, m, s, ms);
return date;
}
function isDate(value2) {
return value2 instanceof Date && !isNaN(value2.valueOf());
}
var NUMBER_FORMAT_REGEXP = /^(\d+)?\.((\d+)(-(\d+))?)?$/;
var MAX_DIGITS = 22;
var DECIMAL_SEP = ".";
var ZERO_CHAR = "0";
var PATTERN_SEP = ";";
var GROUP_SEP = ",";
var DIGIT_CHAR = "#";
var CURRENCY_CHAR = "\xA4";
var PERCENT_CHAR = "%";
function formatNumberToLocaleString(value2, pattern, locale, groupSymbol, decimalSymbol, digitsInfo, isPercent = false) {
let formattedText = "";
let isZero = false;
if (!isFinite(value2)) {
formattedText = getLocaleNumberSymbol(locale, NumberSymbol.Infinity);
} else {
let parsedNumber = parseNumber(value2);
if (isPercent) {
parsedNumber = toPercent(parsedNumber);
}
let minInt = pattern.minInt;
let minFraction = pattern.minFrac;
let maxFraction = pattern.maxFrac;
if (digitsInfo) {
const parts = digitsInfo.match(NUMBER_FORMAT_REGEXP);
if (parts === null) {
throw new Error(`${digitsInfo} is not a valid digit info`);
}
const minIntPart = parts[1];
const minFractionPart = parts[3];
const maxFractionPart = parts[5];
if (minIntPart != null) {
minInt = parseIntAutoRadix(minIntPart);
}
if (minFractionPart != null) {
minFraction = parseIntAutoRadix(minFractionPart);
}
if (maxFractionPart != null) {
maxFraction = parseIntAutoRadix(maxFractionPart);
} else if (minFractionPart != null && minFraction > maxFraction) {
maxFraction = minFraction;
}
}
roundNumber(parsedNumber, minFraction, maxFraction);
let digits = parsedNumber.digits;
let integerLen = parsedNumber.integerLen;
const exponent = parsedNumber.exponent;
let decimals = [];
isZero = digits.every((d) => !d);
for (; integerLen < minInt; integerLen++) {
digits.unshift(0);
}
for (; integerLen < 0; integerLen++) {
digits.unshift(0);
}
if (integerLen > 0) {
decimals = digits.splice(integerLen, digits.length);
} else {
decimals = digits;
digits = [0];
}
const groups = [];
if (digits.length >= pattern.lgSize) {
groups.unshift(digits.splice(-pattern.lgSize, digits.length).join(""));
}
while (digits.length > pattern.gSize) {
groups.unshift(digits.splice(-pattern.gSize, digits.length).join(""));
}
if (digits.length) {
groups.unshift(digits.join(""));
}
formattedText = groups.join(getLocaleNumberSymbol(locale, groupSymbol));
if (decimals.length) {
formattedText += getLocaleNumberSymbol(locale, decimalSymbol) + decimals.join("");
}
if (exponent) {
formattedText += getLocaleNumberSymbol(locale, NumberSymbol.Exponential) + "+" + exponent;
}
}
if (value2 < 0 && !isZero) {
formattedText = pattern.negPre + formattedText + pattern.negSuf;
} else {
formattedText = pattern.posPre + formattedText + pattern.posSuf;
}
return formattedText;
}
function formatCurrency(value2, locale, currency, currencyCode, digitsInfo) {
const format = getLocaleNumberFormat(locale, NumberFormatStyle.Currency);
const pattern = parseNumberFormat(format, getLocaleNumberSymbol(locale, NumberSymbol.MinusSign));
pattern.minFrac = getNumberOfCurrencyDigits(currencyCode);
pattern.maxFrac = pattern.minFrac;
const res = formatNumberToLocaleString(value2, pattern, locale, NumberSymbol.CurrencyGroup, NumberSymbol.CurrencyDecimal, digitsInfo);
return res.replace(CURRENCY_CHAR, currency).replace(CURRENCY_CHAR, "").trim();
}
function formatPercent(value2, locale, digitsInfo) {
const format = getLocaleNumberFormat(locale, NumberFormatStyle.Percent);
const pattern = parseNumberFormat(format, getLocaleNumberSymbol(locale, NumberSymbol.MinusSign));
const res = formatNumberToLocaleString(value2, pattern, locale, NumberSymbol.Group, NumberSymbol.Decimal, digitsInfo, true);
return res.replace(new RegExp(PERCENT_CHAR, "g"), getLocaleNumberSymbol(locale, NumberSymbol.PercentSign));
}
function formatNumber(value2, locale, digitsInfo) {
const format = getLocaleNumberFormat(locale, NumberFormatStyle.Decimal);
const pattern = parseNumberFormat(format, getLocaleNumberSymbol(locale, NumberSymbol.MinusSign));
return formatNumberToLocaleString(value2, pattern, locale, NumberSymbol.Group, NumberSymbol.Decimal, digitsInfo);
}
function parseNumberFormat(format, minusSign = "-") {
const p = {
minInt: 1,
minFrac: 0,
maxFrac: 0,
posPre: "",
posSuf: "",
negPre: "",
negSuf: "",
gSize: 0,
lgSize: 0
};
const patternParts = format.split(PATTERN_SEP);
const positive = patternParts[0];
const negative = patternParts[1];
const positiveParts = positive.indexOf(DECIMAL_SEP) !== -1 ? positive.split(DECIMAL_SEP) : [positive.substring(0, positive.lastIndexOf(ZERO_CHAR) + 1), positive.substring(positive.lastIndexOf(ZERO_CHAR) + 1)], integer = positiveParts[0], fraction = positiveParts[1] || "";
p.posPre = integer.substring(0, integer.indexOf(DIGIT_CHAR));
for (let i = 0; i < fraction.length; i++) {
const ch = fraction.charAt(i);
if (ch === ZERO_CHAR) {
p.minFrac = p.maxFrac = i + 1;
} else if (ch === DIGIT_CHAR) {
p.maxFrac = i + 1;
} else {
p.posSuf += ch;
}
}
const groups = integer.split(GROUP_SEP);
p.gSize = groups[1] ? groups[1].length : 0;
p.lgSize = groups[2] || groups[1] ? (groups[2] || groups[1]).length : 0;
if (negative) {
const trunkLen = positive.length - p.posPre.length - p.posSuf.length, pos = negative.indexOf(DIGIT_CHAR);
p.negPre = negative.substring(0, pos).replace(/'/g, "");
p.negSuf = negative.slice(pos + trunkLen).replace(/'/g, "");
} else {
p.negPre = minusSign + p.posPre;
p.negSuf = p.posSuf;
}
return p;
}
function toPercent(parsedNumber) {
if (parsedNumber.digits[0] === 0) {
return parsedNumber;
}
const fractionLen = parsedNumber.digits.length - parsedNumber.integerLen;
if (parsedNumber.exponent) {
parsedNumber.exponent += 2;
} else {
if (fractionLen === 0) {
parsedNumber.digits.push(0, 0);
} else if (fractionLen === 1) {
parsedNumber.digits.push(0);
}
parsedNumber.integerLen += 2;
}
return parsedNumber;
}
function parseNumber(num) {
let numStr = Math.abs(num) + "";
let exponent = 0, digits, integerLen;
let i, j, zeros;
if ((integerLen = numStr.indexOf(DECIMAL_SEP)) > -1) {
numStr = numStr.replace(DECIMAL_SEP, "");
}
if ((i = numStr.search(/e/i)) > 0) {
if (integerLen < 0)
integerLen = i;
integerLen += +numStr.slice(i + 1);
numStr = numStr.substring(0, i);
} else if (integerLen < 0) {
integerLen = numStr.length;
}
for (i = 0; numStr.charAt(i) === ZERO_CHAR; i++) {
}
if (i === (zeros = numStr.length)) {
digits = [0];
integerLen = 1;
} else {
zeros--;
while (numStr.charAt(zeros) === ZERO_CHAR)
zeros--;
integerLen -= i;
digits = [];
for (j = 0; i <= zeros; i++, j++) {
digits[j] = Number(numStr.charAt(i));
}
}
if (integerLen > MAX_DIGITS) {
digits = digits.splice(0, MAX_DIGITS - 1);
exponent = integerLen - 1;
integerLen = 1;
}
return {
digits,
exponent,
integerLen
};
}
function roundNumber(parsedNumber, minFrac, maxFrac) {
if (minFrac > maxFrac) {
throw new Error(`The minimum number of digits after fraction (${minFrac}) is higher than the maximum (${maxFrac}).`);
}
let digits = parsedNumber.digits;
let fractionLen = digits.length - parsedNumber.integerLen;
const fractionSize = Math.min(Math.max(minFrac, fractionLen), maxFrac);
let roundAt = fractionSize + parsedNumber.integerLen;
let digit = digits[roundAt];
if (roundAt > 0) {
digits.splice(Math.max(parsedNumber.integerLen, roundAt));
for (let j = roundAt; j < digits.length; j++) {
digits[j] = 0;
}
} else {
fractionLen = Math.max(0, fractionLen);
parsedNumber.integerLen = 1;
digits.length = Math.max(1, roundAt = fractionSize + 1);
digits[0] = 0;
for (let i = 1; i < roundAt; i++)
digits[i] = 0;
}
if (digit >= 5) {
if (roundAt - 1 < 0) {
for (let k = 0; k > roundAt; k--) {
digits.unshift(0);
parsedNumber.integerLen++;
}
digits.unshift(1);
parsedNumber.integerLen++;
} else {
digits[roundAt - 1]++;
}
}
for (; fractionLen < Math.max(0, fractionSize); fractionLen++)
digits.push(0);
let dropTrailingZeros = fractionSize !== 0;
const minLen = minFrac + parsedNumber.integerLen;
const carry = digits.reduceRight(function(carry2, d, i, digits2) {
d = d + carry2;
digits2[i] = d < 10 ? d : d - 10;
if (dropTrailingZeros) {
if (digits2[i] === 0 && i >= minLen) {
digits2.pop();
} else {
dropTrailingZeros = false;
}
}
return d >= 10 ? 1 : 0;
}, 0);
if (carry) {
digits.unshift(carry);
parsedNumber.integerLen++;
}
}
function parseIntAutoRadix(text2) {
const result = parseInt(text2);
if (isNaN(result)) {
throw new Error("Invalid integer literal when parsing " + text2);
}
return result;
}
var _NgLocalization = class _NgLocalization {
};
_NgLocalization.\u0275fac = function NgLocalization_Factory(t) {
return new (t || _NgLocalization)();
};
_NgLocalization.\u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
token: _NgLocalization,
factory: function NgLocalization_Factory(t) {
let r = null;
if (t) {
r = new t();
} else {
r = ((locale) => new NgLocaleLocalization(locale))(\u0275\u0275inject(LOCALE_ID));
}
return r;
},
providedIn: "root"
});
var NgLocalization = _NgLocalization;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(NgLocalization, [{
type: Injectable,
args: [{
providedIn: "root",
useFactory: (locale) => new NgLocaleLocalization(locale),
deps: [LOCALE_ID]
}]
}], null, null);
})();
function getPluralCategory(value2, cases, ngLocalization, locale) {
let key2 = `=${value2}`;
if (cases.indexOf(key2) > -1) {
return key2;
}
key2 = ngLocalization.getPluralCategory(value2, locale);
if (cases.indexOf(key2) > -1) {
return key2;
}
if (cases.indexOf("other") > -1) {
return "other";
}
throw new Error(`No plural message found for value "${value2}"`);
}
var _NgLocaleLocalization = class _NgLocaleLocalization extends NgLocalization {
constructor(locale) {
super();
this.locale = locale;
}
getPluralCategory(value2, locale) {
const plural2 = getLocalePluralCase2(locale || this.locale)(value2);
switch (plural2) {
case Plural.Zero:
return "zero";
case Plural.One:
return "one";
case Plural.Two:
return "two";
case Plural.Few:
return "few";
case Plural.Many:
return "many";
default:
return "other";
}
}
};
_NgLocaleLocalization.\u0275fac = function NgLocaleLocalization_Factory(t) {
return new (t || _NgLocaleLocalization)(\u0275\u0275inject(LOCALE_ID));
};
_NgLocaleLocalization.\u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
token: _NgLocaleLocalization,
factory: _NgLocaleLocalization.\u0275fac
});
var NgLocaleLocalization = _NgLocaleLocalization;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(NgLocaleLocalization, [{
type: Injectable
}], () => [{
type: void 0,
decorators: [{
type: Inject,
args: [LOCALE_ID]
}]
}], null);
})();
function parseCookieValue(cookieStr, name2) {
name2 = encodeURIComponent(name2);
for (const cookie of cookieStr.split(";")) {
const eqIndex = cookie.indexOf("=");
const [cookieName, cookieValue] = eqIndex == -1 ? [cookie, ""] : [cookie.slice(0, eqIndex), cookie.slice(eqIndex + 1)];
if (cookieName.trim() === name2) {
return decodeURIComponent(cookieValue);
}
}
return null;
}
var WS_REGEXP = /\s+/;
var EMPTY_ARRAY2 = [];
var _NgClass = class _NgClass {
constructor(_ngEl, _renderer) {
this._ngEl = _ngEl;
this._renderer = _renderer;
this.initialClasses = EMPTY_ARRAY2;
this.stateMap = /* @__PURE__ */ new Map();
}
set klass(value2) {
this.initialClasses = value2 != null ? value2.trim().split(WS_REGEXP) : EMPTY_ARRAY2;
}
set ngClass(value2) {
this.rawClass = typeof value2 === "string" ? value2.trim().split(WS_REGEXP) : value2;
}
/*
The NgClass directive uses the custom change detection algorithm for its inputs. The custom
algorithm is necessary since inputs are represented as complex object or arrays that need to be
deeply-compared.
This algorithm is perf-sensitive since NgClass is used very frequently and its poor performance
might negatively impact runtime performance of the entire change detection cycle. The design of
this algorithm is making sure that:
- there is no unnecessary DOM manipulation (CSS classes are added / removed from the DOM only when
needed), even if references to bound objects change;
- there is no memory allocation if nothing changes (even relatively modest memory allocation
during the change detection cycle can result in GC pauses for some of the CD cycles).
The algorithm works by iterating over the set of bound classes, staring with [class] binding and
then going over [ngClass] binding. For each CSS class name:
- check if it was seen before (this information is tracked in the state map) and if its value
changed;
- mark it as "touched" - names that are not marked are not present in the latest set of binding
and we can remove such class name from the internal data structures;
After iteration over all the CSS class names we've got data structure with all the information
necessary to synchronize changes to the DOM - it is enough to iterate over the state map, flush
changes to the DOM and reset internal data structures so those are ready for the next change
detection cycle.
*/
ngDoCheck() {
for (const klass of this.initialClasses) {
this._updateState(klass, true);
}
const rawClass = this.rawClass;
if (Array.isArray(rawClass) || rawClass instanceof Set) {
for (const klass of rawClass) {
this._updateState(klass, true);
}
} else if (rawClass != null) {
for (const klass of Object.keys(rawClass)) {
this._updateState(klass, Boolean(rawClass[klass]));
}
}
this._applyStateDiff();
}
_updateState(klass, nextEnabled) {
const state = this.stateMap.get(klass);
if (state !== void 0) {
if (state.enabled !== nextEnabled) {
state.changed = true;
state.enabled = nextEnabled;
}
state.touched = true;
} else {
this.stateMap.set(klass, {
enabled: nextEnabled,
changed: true,
touched: true
});
}
}
_applyStateDiff() {
for (const stateEntry of this.stateMap) {
const klass = stateEntry[0];
const state = stateEntry[1];
if (state.changed) {
this._toggleClass(klass, state.enabled);
state.changed = false;
} else if (!state.touched) {
if (state.enabled) {
this._toggleClass(klass, false);
}
this.stateMap.delete(klass);
}
state.touched = false;
}
}
_toggleClass(klass, enabled) {
if (ngDevMode) {
if (typeof klass !== "string") {
throw new Error(`NgClass can only toggle CSS classes expressed as strings, got ${stringify(klass)}`);
}
}
klass = klass.trim();
if (klass.length > 0) {
klass.split(WS_REGEXP).forEach((klass2) => {
if (enabled) {
this._renderer.addClass(this._ngEl.nativeElement, klass2);
} else {
this._renderer.removeClass(this._ngEl.nativeElement, klass2);
}
});
}
}
};
_NgClass.\u0275fac = function NgClass_Factory(t) {
return new (t || _NgClass)(\u0275\u0275directiveInject(ElementRef), \u0275\u0275directiveInject(Renderer2));
};
_NgClass.\u0275dir = /* @__PURE__ */ \u0275\u0275defineDirective({
type: _NgClass,
selectors: [["", "ngClass", ""]],
inputs: {
klass: [InputFlags.None, "class", "klass"],
ngClass: "ngClass"
},
standalone: true
});
var NgClass = _NgClass;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(NgClass, [{
type: Directive,
args: [{
selector: "[ngClass]",
standalone: true
}]
}], () => [{
type: ElementRef
}, {
type: Renderer2
}], {
klass: [{
type: Input,
args: ["class"]
}],
ngClass: [{
type: Input,
args: ["ngClass"]
}]
});
})();
var _NgComponentOutlet = class _NgComponentOutlet {
constructor(_viewContainerRef) {
this._viewContainerRef = _viewContainerRef;
this.ngComponentOutlet = null;
this._inputsUsed = /* @__PURE__ */ new Map();
}
_needToReCreateNgModuleInstance(changes) {
return changes["ngComponentOutletNgModule"] !== void 0 || changes["ngComponentOutletNgModuleFactory"] !== void 0;
}
_needToReCreateComponentInstance(changes) {
return changes["ngComponentOutlet"] !== void 0 || changes["ngComponentOutletContent"] !== void 0 || changes["ngComponentOutletInjector"] !== void 0 || this._needToReCreateNgModuleInstance(changes);
}
/** @nodoc */
ngOnChanges(changes) {
if (this._needToReCreateComponentInstance(changes)) {
this._viewContainerRef.clear();
this._inputsUsed.clear();
this._componentRef = void 0;
if (this.ngComponentOutlet) {
const injector = this.ngComponentOutletInjector || this._viewContainerRef.parentInjector;
if (this._needToReCreateNgModuleInstance(changes)) {
this._moduleRef?.destroy();
if (this.ngComponentOutletNgModule) {
this._moduleRef = createNgModule(this.ngComponentOutletNgModule, getParentInjector(injector));
} else if (this.ngComponentOutletNgModuleFactory) {
this._moduleRef = this.ngComponentOutletNgModuleFactory.create(getParentInjector(injector));
} else {
this._moduleRef = void 0;
}
}
this._componentRef = this._viewContainerRef.createComponent(this.ngComponentOutlet, {
injector,
ngModuleRef: this._moduleRef,
projectableNodes: this.ngComponentOutletContent
});
}
}
}
/** @nodoc */
ngDoCheck() {
if (this._componentRef) {
if (this.ngComponentOutletInputs) {
for (const inputName of Object.keys(this.ngComponentOutletInputs)) {
this._inputsUsed.set(inputName, true);
}
}
this._applyInputStateDiff(this._componentRef);
}
}
/** @nodoc */
ngOnDestroy() {
this._moduleRef?.destroy();
}
_applyInputStateDiff(componentRef) {
for (const [inputName, touched] of this._inputsUsed) {
if (!touched) {
componentRef.setInput(inputName, void 0);
this._inputsUsed.delete(inputName);
} else {
componentRef.setInput(inputName, this.ngComponentOutletInputs[inputName]);
this._inputsUsed.set(inputName, false);
}
}
}
};
_NgComponentOutlet.\u0275fac = function NgComponentOutlet_Factory(t) {
return new (t || _NgComponentOutlet)(\u0275\u0275directiveInject(ViewContainerRef));
};
_NgComponentOutlet.\u0275dir = /* @__PURE__ */ \u0275\u0275defineDirective({
type: _NgComponentOutlet,
selectors: [["", "ngComponentOutlet", ""]],
inputs: {
ngComponentOutlet: "ngComponentOutlet",
ngComponentOutletInputs: "ngComponentOutletInputs",
ngComponentOutletInjector: "ngComponentOutletInjector",
ngComponentOutletContent: "ngComponentOutletContent",
ngComponentOutletNgModule: "ngComponentOutletNgModule",
ngComponentOutletNgModuleFactory: "ngComponentOutletNgModuleFactory"
},
standalone: true,
features: [\u0275\u0275NgOnChangesFeature]
});
var NgComponentOutlet = _NgComponentOutlet;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(NgComponentOutlet, [{
type: Directive,
args: [{
selector: "[ngComponentOutlet]",
standalone: true
}]
}], () => [{
type: ViewContainerRef
}], {
ngComponentOutlet: [{
type: Input
}],
ngComponentOutletInputs: [{
type: Input
}],
ngComponentOutletInjector: [{
type: Input
}],
ngComponentOutletContent: [{
type: Input
}],
ngComponentOutletNgModule: [{
type: Input
}],
ngComponentOutletNgModuleFactory: [{
type: Input
}]
});
})();
function getParentInjector(injector) {
const parentNgModule = injector.get(NgModuleRef$1);
return parentNgModule.injector;
}
var NgForOfContext = class {
constructor($implicit, ngForOf, index2, count) {
this.$implicit = $implicit;
this.ngForOf = ngForOf;
this.index = index2;
this.count = count;
}
get first() {
return this.index === 0;
}
get last() {
return this.index === this.count - 1;
}
get even() {
return this.index % 2 === 0;
}
get odd() {
return !this.even;
}
};
var _NgForOf = class _NgForOf {
/**
* The value of the iterable expression, which can be used as a
* [template input variable](guide/structural-directives#shorthand).
*/
set ngForOf(ngForOf) {
this._ngForOf = ngForOf;
this._ngForOfDirty = true;
}
/**
* Specifies a custom `TrackByFunction` to compute the identity of items in an iterable.
*
* If a custom `TrackByFunction` is not provided, `NgForOf` will use the item's [object
* identity](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is)
* as the key.
*
* `NgForOf` uses the computed key to associate items in an iterable with DOM elements
* it produces for these items.
*
* A custom `TrackByFunction` is useful to provide good user experience in cases when items in an
* iterable rendered using `NgForOf` have a natural identifier (for example, custom ID or a
* primary key), and this iterable could be updated with new object instances that still
* represent the same underlying entity (for example, when data is re-fetched from the server,
* and the iterable is recreated and re-rendered, but most of the data is still the same).
*
* @see {@link TrackByFunction}
*/
set ngForTrackBy(fn) {
if ((typeof ngDevMode === "undefined" || ngDevMode) && fn != null && typeof fn !== "function") {
console.warn(`trackBy must be a function, but received ${JSON.stringify(fn)}. See https://angular.io/api/common/NgForOf#change-propagation for more information.`);
}
this._trackByFn = fn;
}
get ngForTrackBy() {
return this._trackByFn;
}
constructor(_viewContainer, _template, _differs) {
this._viewContainer = _viewContainer;
this._template = _template;
this._differs = _differs;
this._ngForOf = null;
this._ngForOfDirty = true;
this._differ = null;
}
/**
* A reference to the template that is stamped out for each item in the iterable.
* @see [template reference variable](guide/template-reference-variables)
*/
set ngForTemplate(value2) {
if (value2) {
this._template = value2;
}
}
/**
* Applies the changes when needed.
* @nodoc
*/
ngDoCheck() {
if (this._ngForOfDirty) {
this._ngForOfDirty = false;
const value2 = this._ngForOf;
if (!this._differ && value2) {
if (typeof ngDevMode === "undefined" || ngDevMode) {
try {
this._differ = this._differs.find(value2).create(this.ngForTrackBy);
} catch {
let errorMessage = `Cannot find a differ supporting object '${value2}' of type '${getTypeName(value2)}'. NgFor only supports binding to Iterables, such as Arrays.`;
if (typeof value2 === "object") {
errorMessage += " Did you mean to use the keyvalue pipe?";
}
throw new RuntimeError(-2200, errorMessage);
}
} else {
this._differ = this._differs.find(value2).create(this.ngForTrackBy);
}
}
}
if (this._differ) {
const changes = this._differ.diff(this._ngForOf);
if (changes)
this._applyChanges(changes);
}
}
_applyChanges(changes) {
const viewContainer = this._viewContainer;
changes.forEachOperation((item, adjustedPreviousIndex, currentIndex) => {
if (item.previousIndex == null) {
viewContainer.createEmbeddedView(this._template, new NgForOfContext(item.item, this._ngForOf, -1, -1), currentIndex === null ? void 0 : currentIndex);
} else if (currentIndex == null) {
viewContainer.remove(adjustedPreviousIndex === null ? void 0 : adjustedPreviousIndex);
} else if (adjustedPreviousIndex !== null) {
const view = viewContainer.get(adjustedPreviousIndex);
viewContainer.move(view, currentIndex);
applyViewChange(view, item);
}
});
for (let i = 0, ilen = viewContainer.length; i < ilen; i++) {
const viewRef = viewContainer.get(i);
const context2 = viewRef.context;
context2.index = i;
context2.count = ilen;
context2.ngForOf = this._ngForOf;
}
changes.forEachIdentityChange((record) => {
const viewRef = viewContainer.get(record.currentIndex);
applyViewChange(viewRef, record);
});
}
/**
* Asserts the correct type of the context for the template that `NgForOf` will render.
*
* The presence of this method is a signal to the Ivy template type-check compiler that the
* `NgForOf` structural directive renders its template with a specific context type.
*/
static ngTemplateContextGuard(dir, ctx) {
return true;
}
};
_NgForOf.\u0275fac = function NgForOf_Factory(t) {
return new (t || _NgForOf)(\u0275\u0275directiveInject(ViewContainerRef), \u0275\u0275directiveInject(TemplateRef), \u0275\u0275directiveInject(IterableDiffers));
};
_NgForOf.\u0275dir = /* @__PURE__ */ \u0275\u0275defineDirective({
type: _NgForOf,
selectors: [["", "ngFor", "", "ngForOf", ""]],
inputs: {
ngForOf: "ngForOf",
ngForTrackBy: "ngForTrackBy",
ngForTemplate: "ngForTemplate"
},
standalone: true
});
var NgForOf = _NgForOf;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(NgForOf, [{
type: Directive,
args: [{
selector: "[ngFor][ngForOf]",
standalone: true
}]
}], () => [{
type: ViewContainerRef
}, {
type: TemplateRef
}, {
type: IterableDiffers
}], {
ngForOf: [{
type: Input
}],
ngForTrackBy: [{
type: Input
}],
ngForTemplate: [{
type: Input
}]
});
})();
function applyViewChange(view, record) {
view.context.$implicit = record.item;
}
function getTypeName(type) {
return type["name"] || typeof type;
}
var _NgIf = class _NgIf {
constructor(_viewContainer, templateRef) {
this._viewContainer = _viewContainer;
this._context = new NgIfContext();
this._thenTemplateRef = null;
this._elseTemplateRef = null;
this._thenViewRef = null;
this._elseViewRef = null;
this._thenTemplateRef = templateRef;
}
/**
* The Boolean expression to evaluate as the condition for showing a template.
*/
set ngIf(condition) {
this._context.$implicit = this._context.ngIf = condition;
this._updateView();
}
/**
* A template to show if the condition expression evaluates to true.
*/
set ngIfThen(templateRef) {
assertTemplate("ngIfThen", templateRef);
this._thenTemplateRef = templateRef;
this._thenViewRef = null;
this._updateView();
}
/**
* A template to show if the condition expression evaluates to false.
*/
set ngIfElse(templateRef) {
assertTemplate("ngIfElse", templateRef);
this._elseTemplateRef = templateRef;
this._elseViewRef = null;
this._updateView();
}
_updateView() {
if (this._context.$implicit) {
if (!this._thenViewRef) {
this._viewContainer.clear();
this._elseViewRef = null;
if (this._thenTemplateRef) {
this._thenViewRef = this._viewContainer.createEmbeddedView(this._thenTemplateRef, this._context);
}
}
} else {
if (!this._elseViewRef) {
this._viewContainer.clear();
this._thenViewRef = null;
if (this._elseTemplateRef) {
this._elseViewRef = this._viewContainer.createEmbeddedView(this._elseTemplateRef, this._context);
}
}
}
}
/**
* Asserts the correct type of the context for the template that `NgIf` will render.
*
* The presence of this method is a signal to the Ivy template type-check compiler that the
* `NgIf` structural directive renders its template with a specific context type.
*/
static ngTemplateContextGuard(dir, ctx) {
return true;
}
};
_NgIf.\u0275fac = function NgIf_Factory(t) {
return new (t || _NgIf)(\u0275\u0275directiveInject(ViewContainerRef), \u0275\u0275directiveInject(TemplateRef));
};
_NgIf.\u0275dir = /* @__PURE__ */ \u0275\u0275defineDirective({
type: _NgIf,
selectors: [["", "ngIf", ""]],
inputs: {
ngIf: "ngIf",
ngIfThen: "ngIfThen",
ngIfElse: "ngIfElse"
},
standalone: true
});
var NgIf = _NgIf;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(NgIf, [{
type: Directive,
args: [{
selector: "[ngIf]",
standalone: true
}]
}], () => [{
type: ViewContainerRef
}, {
type: TemplateRef
}], {
ngIf: [{
type: Input
}],
ngIfThen: [{
type: Input
}],
ngIfElse: [{
type: Input
}]
});
})();
var NgIfContext = class {
constructor() {
this.$implicit = null;
this.ngIf = null;
}
};
function assertTemplate(property2, templateRef) {
const isTemplateRefOrNull = !!(!templateRef || templateRef.createEmbeddedView);
if (!isTemplateRefOrNull) {
throw new Error(`${property2} must be a TemplateRef, but received '${stringify(templateRef)}'.`);
}
}
var NG_SWITCH_USE_STRICT_EQUALS = true;
var SwitchView = class {
constructor(_viewContainerRef, _templateRef) {
this._viewContainerRef = _viewContainerRef;
this._templateRef = _templateRef;
this._created = false;
}
create() {
this._created = true;
this._viewContainerRef.createEmbeddedView(this._templateRef);
}
destroy() {
this._created = false;
this._viewContainerRef.clear();
}
enforceState(created) {
if (created && !this._created) {
this.create();
} else if (!created && this._created) {
this.destroy();
}
}
};
var _NgSwitch = class _NgSwitch {
constructor() {
this._defaultViews = [];
this._defaultUsed = false;
this._caseCount = 0;
this._lastCaseCheckIndex = 0;
this._lastCasesMatched = false;
}
set ngSwitch(newValue) {
this._ngSwitch = newValue;
if (this._caseCount === 0) {
this._updateDefaultCases(true);
}
}
/** @internal */
_addCase() {
return this._caseCount++;
}
/** @internal */
_addDefault(view) {
this._defaultViews.push(view);
}
/** @internal */
_matchCase(value2) {
const matched = NG_SWITCH_USE_STRICT_EQUALS ? value2 === this._ngSwitch : value2 == this._ngSwitch;
if ((typeof ngDevMode === "undefined" || ngDevMode) && matched !== (value2 == this._ngSwitch)) {
console.warn(formatRuntimeError(2001, `As of Angular v17 the NgSwitch directive uses strict equality comparison === instead of == to match different cases. Previously the case value "${stringifyValue(value2)}" matched switch expression value "${stringifyValue(this._ngSwitch)}", but this is no longer the case with the stricter equality check. Your comparison results return different results using === vs. == and you should adjust your ngSwitch expression and / or values to conform with the strict equality requirements.`));
}
this._lastCasesMatched ||= matched;
this._lastCaseCheckIndex++;
if (this._lastCaseCheckIndex === this._caseCount) {
this._updateDefaultCases(!this._lastCasesMatched);
this._lastCaseCheckIndex = 0;
this._lastCasesMatched = false;
}
return matched;
}
_updateDefaultCases(useDefault) {
if (this._defaultViews.length > 0 && useDefault !== this._defaultUsed) {
this._defaultUsed = useDefault;
for (const defaultView of this._defaultViews) {
defaultView.enforceState(useDefault);
}
}
}
};
_NgSwitch.\u0275fac = function NgSwitch_Factory(t) {
return new (t || _NgSwitch)();
};
_NgSwitch.\u0275dir = /* @__PURE__ */ \u0275\u0275defineDirective({
type: _NgSwitch,
selectors: [["", "ngSwitch", ""]],
inputs: {
ngSwitch: "ngSwitch"
},
standalone: true
});
var NgSwitch = _NgSwitch;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(NgSwitch, [{
type: Directive,
args: [{
selector: "[ngSwitch]",
standalone: true
}]
}], null, {
ngSwitch: [{
type: Input
}]
});
})();
var _NgSwitchCase = class _NgSwitchCase {
constructor(viewContainer, templateRef, ngSwitch) {
this.ngSwitch = ngSwitch;
if ((typeof ngDevMode === "undefined" || ngDevMode) && !ngSwitch) {
throwNgSwitchProviderNotFoundError("ngSwitchCase", "NgSwitchCase");
}
ngSwitch._addCase();
this._view = new SwitchView(viewContainer, templateRef);
}
/**
* Performs case matching. For internal use only.
* @nodoc
*/
ngDoCheck() {
this._view.enforceState(this.ngSwitch._matchCase(this.ngSwitchCase));
}
};
_NgSwitchCase.\u0275fac = function NgSwitchCase_Factory(t) {
return new (t || _NgSwitchCase)(\u0275\u0275directiveInject(ViewContainerRef), \u0275\u0275directiveInject(TemplateRef), \u0275\u0275directiveInject(NgSwitch, 9));
};
_NgSwitchCase.\u0275dir = /* @__PURE__ */ \u0275\u0275defineDirective({
type: _NgSwitchCase,
selectors: [["", "ngSwitchCase", ""]],
inputs: {
ngSwitchCase: "ngSwitchCase"
},
standalone: true
});
var NgSwitchCase = _NgSwitchCase;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(NgSwitchCase, [{
type: Directive,
args: [{
selector: "[ngSwitchCase]",
standalone: true
}]
}], () => [{
type: ViewContainerRef
}, {
type: TemplateRef
}, {
type: NgSwitch,
decorators: [{
type: Optional
}, {
type: Host
}]
}], {
ngSwitchCase: [{
type: Input
}]
});
})();
var _NgSwitchDefault = class _NgSwitchDefault {
constructor(viewContainer, templateRef, ngSwitch) {
if ((typeof ngDevMode === "undefined" || ngDevMode) && !ngSwitch) {
throwNgSwitchProviderNotFoundError("ngSwitchDefault", "NgSwitchDefault");
}
ngSwitch._addDefault(new SwitchView(viewContainer, templateRef));
}
};
_NgSwitchDefault.\u0275fac = function NgSwitchDefault_Factory(t) {
return new (t || _NgSwitchDefault)(\u0275\u0275directiveInject(ViewContainerRef), \u0275\u0275directiveInject(TemplateRef), \u0275\u0275directiveInject(NgSwitch, 9));
};
_NgSwitchDefault.\u0275dir = /* @__PURE__ */ \u0275\u0275defineDirective({
type: _NgSwitchDefault,
selectors: [["", "ngSwitchDefault", ""]],
standalone: true
});
var NgSwitchDefault = _NgSwitchDefault;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(NgSwitchDefault, [{
type: Directive,
args: [{
selector: "[ngSwitchDefault]",
standalone: true
}]
}], () => [{
type: ViewContainerRef
}, {
type: TemplateRef
}, {
type: NgSwitch,
decorators: [{
type: Optional
}, {
type: Host
}]
}], null);
})();
function throwNgSwitchProviderNotFoundError(attrName, directiveName) {
throw new RuntimeError(2e3, `An element with the "${attrName}" attribute (matching the "${directiveName}" directive) must be located inside an element with the "ngSwitch" attribute (matching "NgSwitch" directive)`);
}
function stringifyValue(value2) {
return typeof value2 === "string" ? `'${value2}'` : String(value2);
}
var _NgPlural = class _NgPlural {
constructor(_localization) {
this._localization = _localization;
this._caseViews = {};
}
set ngPlural(value2) {
this._updateView(value2);
}
addCase(value2, switchView) {
this._caseViews[value2] = switchView;
}
_updateView(switchValue) {
this._clearViews();
const cases = Object.keys(this._caseViews);
const key2 = getPluralCategory(switchValue, cases, this._localization);
this._activateView(this._caseViews[key2]);
}
_clearViews() {
if (this._activeView)
this._activeView.destroy();
}
_activateView(view) {
if (view) {
this._activeView = view;
this._activeView.create();
}
}
};
_NgPlural.\u0275fac = function NgPlural_Factory(t) {
return new (t || _NgPlural)(\u0275\u0275directiveInject(NgLocalization));
};
_NgPlural.\u0275dir = /* @__PURE__ */ \u0275\u0275defineDirective({
type: _NgPlural,
selectors: [["", "ngPlural", ""]],
inputs: {
ngPlural: "ngPlural"
},
standalone: true
});
var NgPlural = _NgPlural;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(NgPlural, [{
type: Directive,
args: [{
selector: "[ngPlural]",
standalone: true
}]
}], () => [{
type: NgLocalization
}], {
ngPlural: [{
type: Input
}]
});
})();
var _NgPluralCase = class _NgPluralCase {
constructor(value2, template, viewContainer, ngPlural) {
this.value = value2;
const isANumber = !isNaN(Number(value2));
ngPlural.addCase(isANumber ? `=${value2}` : value2, new SwitchView(viewContainer, template));
}
};
_NgPluralCase.\u0275fac = function NgPluralCase_Factory(t) {
return new (t || _NgPluralCase)(\u0275\u0275injectAttribute("ngPluralCase"), \u0275\u0275directiveInject(TemplateRef), \u0275\u0275directiveInject(ViewContainerRef), \u0275\u0275directiveInject(NgPlural, 1));
};
_NgPluralCase.\u0275dir = /* @__PURE__ */ \u0275\u0275defineDirective({
type: _NgPluralCase,
selectors: [["", "ngPluralCase", ""]],
standalone: true
});
var NgPluralCase = _NgPluralCase;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(NgPluralCase, [{
type: Directive,
args: [{
selector: "[ngPluralCase]",
standalone: true
}]
}], () => [{
type: void 0,
decorators: [{
type: Attribute,
args: ["ngPluralCase"]
}]
}, {
type: TemplateRef
}, {
type: ViewContainerRef
}, {
type: NgPlural,
decorators: [{
type: Host
}]
}], null);
})();
var _NgStyle = class _NgStyle {
constructor(_ngEl, _differs, _renderer) {
this._ngEl = _ngEl;
this._differs = _differs;
this._renderer = _renderer;
this._ngStyle = null;
this._differ = null;
}
set ngStyle(values) {
this._ngStyle = values;
if (!this._differ && values) {
this._differ = this._differs.find(values).create();
}
}
ngDoCheck() {
if (this._differ) {
const changes = this._differ.diff(this._ngStyle);
if (changes) {
this._applyChanges(changes);
}
}
}
_setStyle(nameAndUnit, value2) {
const [name2, unit] = nameAndUnit.split(".");
const flags = name2.indexOf("-") === -1 ? void 0 : RendererStyleFlags2.DashCase;
if (value2 != null) {
this._renderer.setStyle(this._ngEl.nativeElement, name2, unit ? `${value2}${unit}` : value2, flags);
} else {
this._renderer.removeStyle(this._ngEl.nativeElement, name2, flags);
}
}
_applyChanges(changes) {
changes.forEachRemovedItem((record) => this._setStyle(record.key, null));
changes.forEachAddedItem((record) => this._setStyle(record.key, record.currentValue));
changes.forEachChangedItem((record) => this._setStyle(record.key, record.currentValue));
}
};
_NgStyle.\u0275fac = function NgStyle_Factory(t) {
return new (t || _NgStyle)(\u0275\u0275directiveInject(ElementRef), \u0275\u0275directiveInject(KeyValueDiffers), \u0275\u0275directiveInject(Renderer2));
};
_NgStyle.\u0275dir = /* @__PURE__ */ \u0275\u0275defineDirective({
type: _NgStyle,
selectors: [["", "ngStyle", ""]],
inputs: {
ngStyle: "ngStyle"
},
standalone: true
});
var NgStyle = _NgStyle;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(NgStyle, [{
type: Directive,
args: [{
selector: "[ngStyle]",
standalone: true
}]
}], () => [{
type: ElementRef
}, {
type: KeyValueDiffers
}, {
type: Renderer2
}], {
ngStyle: [{
type: Input,
args: ["ngStyle"]
}]
});
})();
var _NgTemplateOutlet = class _NgTemplateOutlet {
constructor(_viewContainerRef) {
this._viewContainerRef = _viewContainerRef;
this._viewRef = null;
this.ngTemplateOutletContext = null;
this.ngTemplateOutlet = null;
this.ngTemplateOutletInjector = null;
}
ngOnChanges(changes) {
if (this._shouldRecreateView(changes)) {
const viewContainerRef = this._viewContainerRef;
if (this._viewRef) {
viewContainerRef.remove(viewContainerRef.indexOf(this._viewRef));
}
if (!this.ngTemplateOutlet) {
this._viewRef = null;
return;
}
const viewContext = this._createContextForwardProxy();
this._viewRef = viewContainerRef.createEmbeddedView(this.ngTemplateOutlet, viewContext, {
injector: this.ngTemplateOutletInjector ?? void 0
});
}
}
/**
* We need to re-create existing embedded view if either is true:
* - the outlet changed.
* - the injector changed.
*/
_shouldRecreateView(changes) {
return !!changes["ngTemplateOutlet"] || !!changes["ngTemplateOutletInjector"];
}
/**
* For a given outlet instance, we create a proxy object that delegates
* to the user-specified context. This allows changing, or swapping out
* the context object completely without having to destroy/re-create the view.
*/
_createContextForwardProxy() {
return new Proxy({}, {
set: (_target, prop, newValue) => {
if (!this.ngTemplateOutletContext) {
return false;
}
return Reflect.set(this.ngTemplateOutletContext, prop, newValue);
},
get: (_target, prop, receiver) => {
if (!this.ngTemplateOutletContext) {
return void 0;
}
return Reflect.get(this.ngTemplateOutletContext, prop, receiver);
}
});
}
};
_NgTemplateOutlet.\u0275fac = function NgTemplateOutlet_Factory(t) {
return new (t || _NgTemplateOutlet)(\u0275\u0275directiveInject(ViewContainerRef));
};
_NgTemplateOutlet.\u0275dir = /* @__PURE__ */ \u0275\u0275defineDirective({
type: _NgTemplateOutlet,
selectors: [["", "ngTemplateOutlet", ""]],
inputs: {
ngTemplateOutletContext: "ngTemplateOutletContext",
ngTemplateOutlet: "ngTemplateOutlet",
ngTemplateOutletInjector: "ngTemplateOutletInjector"
},
standalone: true,
features: [\u0275\u0275NgOnChangesFeature]
});
var NgTemplateOutlet = _NgTemplateOutlet;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(NgTemplateOutlet, [{
type: Directive,
args: [{
selector: "[ngTemplateOutlet]",
standalone: true
}]
}], () => [{
type: ViewContainerRef
}], {
ngTemplateOutletContext: [{
type: Input
}],
ngTemplateOutlet: [{
type: Input
}],
ngTemplateOutletInjector: [{
type: Input
}]
});
})();
var COMMON_DIRECTIVES = [NgClass, NgComponentOutlet, NgForOf, NgIf, NgTemplateOutlet, NgStyle, NgSwitch, NgSwitchCase, NgSwitchDefault, NgPlural, NgPluralCase];
function invalidPipeArgumentError(type, value2) {
return new RuntimeError(2100, ngDevMode && `InvalidPipeArgument: '${value2}' for pipe '${stringify(type)}'`);
}
var SubscribableStrategy = class {
createSubscription(async2, updateLatestValue) {
return untracked(() => async2.subscribe({
next: updateLatestValue,
error: (e) => {
throw e;
}
}));
}
dispose(subscription) {
untracked(() => subscription.unsubscribe());
}
};
var PromiseStrategy = class {
createSubscription(async2, updateLatestValue) {
return async2.then(updateLatestValue, (e) => {
throw e;
});
}
dispose(subscription) {
}
};
var _promiseStrategy = new PromiseStrategy();
var _subscribableStrategy = new SubscribableStrategy();
var _AsyncPipe = class _AsyncPipe {
constructor(ref) {
this._latestValue = null;
this.markForCheckOnValueUpdate = true;
this._subscription = null;
this._obj = null;
this._strategy = null;
this._ref = ref;
}
ngOnDestroy() {
if (this._subscription) {
this._dispose();
}
this._ref = null;
}
transform(obj) {
if (!this._obj) {
if (obj) {
try {
this.markForCheckOnValueUpdate = false;
this._subscribe(obj);
} finally {
this.markForCheckOnValueUpdate = true;
}
}
return this._latestValue;
}
if (obj !== this._obj) {
this._dispose();
return this.transform(obj);
}
return this._latestValue;
}
_subscribe(obj) {
this._obj = obj;
this._strategy = this._selectStrategy(obj);
this._subscription = this._strategy.createSubscription(obj, (value2) => this._updateLatestValue(obj, value2));
}
_selectStrategy(obj) {
if (isPromise2(obj)) {
return _promiseStrategy;
}
if (isSubscribable(obj)) {
return _subscribableStrategy;
}
throw invalidPipeArgumentError(_AsyncPipe, obj);
}
_dispose() {
this._strategy.dispose(this._subscription);
this._latestValue = null;
this._subscription = null;
this._obj = null;
}
_updateLatestValue(async2, value2) {
if (async2 === this._obj) {
this._latestValue = value2;
if (this.markForCheckOnValueUpdate) {
this._ref?.markForCheck();
}
}
}
};
_AsyncPipe.\u0275fac = function AsyncPipe_Factory(t) {
return new (t || _AsyncPipe)(\u0275\u0275directiveInject(ChangeDetectorRef, 16));
};
_AsyncPipe.\u0275pipe = /* @__PURE__ */ \u0275\u0275definePipe({
name: "async",
type: _AsyncPipe,
pure: false,
standalone: true
});
var AsyncPipe = _AsyncPipe;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(AsyncPipe, [{
type: Pipe,
args: [{
name: "async",
pure: false,
standalone: true
}]
}], () => [{
type: ChangeDetectorRef
}], null);
})();
var _LowerCasePipe = class _LowerCasePipe {
transform(value2) {
if (value2 == null)
return null;
if (typeof value2 !== "string") {
throw invalidPipeArgumentError(_LowerCasePipe, value2);
}
return value2.toLowerCase();
}
};
_LowerCasePipe.\u0275fac = function LowerCasePipe_Factory(t) {
return new (t || _LowerCasePipe)();
};
_LowerCasePipe.\u0275pipe = /* @__PURE__ */ \u0275\u0275definePipe({
name: "lowercase",
type: _LowerCasePipe,
pure: true,
standalone: true
});
var LowerCasePipe = _LowerCasePipe;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(LowerCasePipe, [{
type: Pipe,
args: [{
name: "lowercase",
standalone: true
}]
}], null, null);
})();
var unicodeWordMatch = /(?:[0-9A-Za-z\xAA\xB5\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0370-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u048A-\u052F\u0531-\u0556\u0559\u0560-\u0588\u05D0-\u05EA\u05EF-\u05F2\u0620-\u064A\u066E\u066F\u0671-\u06D3\u06D5\u06E5\u06E6\u06EE\u06EF\u06FA-\u06FC\u06FF\u0710\u0712-\u072F\u074D-\u07A5\u07B1\u07CA-\u07EA\u07F4\u07F5\u07FA\u0800-\u0815\u081A\u0824\u0828\u0840-\u0858\u0860-\u086A\u0870-\u0887\u0889-\u088E\u08A0-\u08C9\u0904-\u0939\u093D\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BD\u09CE\u09DC\u09DD\u09DF-\u09E1\u09F0\u09F1\u09FC\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A59-\u0A5C\u0A5E\u0A72-\u0A74\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABD\u0AD0\u0AE0\u0AE1\u0AF9\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3D\u0B5C\u0B5D\u0B5F-\u0B61\u0B71\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BD0\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D\u0C58-\u0C5A\u0C5D\u0C60\u0C61\u0C80\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBD\u0CDD\u0CDE\u0CE0\u0CE1\u0CF1\u0CF2\u0D04-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D\u0D4E\u0D54-\u0D56\u0D5F-\u0D61\u0D7A-\u0D7F\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0E01-\u0E30\u0E32\u0E33\u0E40-\u0E46\u0E81\u0E82\u0E84\u0E86-\u0E8A\u0E8C-\u0EA3\u0EA5\u0EA7-\u0EB0\u0EB2\u0EB3\u0EBD\u0EC0-\u0EC4\u0EC6\u0EDC-\u0EDF\u0F00\u0F40-\u0F47\u0F49-\u0F6C\u0F88-\u0F8C\u1000-\u102A\u103F\u1050-\u1055\u105A-\u105D\u1061\u1065\u1066\u106E-\u1070\u1075-\u1081\u108E\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u1380-\u138F\u13A0-\u13F5\u13F8-\u13FD\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16F1-\u16F8\u1700-\u1711\u171F-\u1731\u1740-\u1751\u1760-\u176C\u176E-\u1770\u1780-\u17B3\u17D7\u17DC\u1820-\u1878\u1880-\u1884\u1887-\u18A8\u18AA\u18B0-\u18F5\u1900-\u191E\u1950-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u1A00-\u1A16\u1A20-\u1A54\u1AA7\u1B05-\u1B33\u1B45-\u1B4C\u1B83-\u1BA0\u1BAE\u1BAF\u1BBA-\u1BE5\u1C00-\u1C23\u1C4D-\u1C4F\u1C5A-\u1C7D\u1C80-\u1C88\u1C90-\u1CBA\u1CBD-\u1CBF\u1CE9-\u1CEC\u1CEE-\u1CF3\u1CF5\u1CF6\u1CFA\u1D00-\u1DBF\u1E00-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u2071\u207F\u2090-\u209C\u2102\u2107\u210A-\u2113\u2115\u2119-\u211D\u2124\u2126\u2128\u212A-\u212D\u212F-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2183\u2184\u2C00-\u2CE4\u2CEB-\u2CEE\u2CF2\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D80-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u2E2F\u3005\u3006\u3031-\u3035\u303B\u303C\u3041-\u3096\u309D-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312F\u3131-\u318E\u31A0-\u31BF\u31F0-\u31FF\u3400-\u4DBF\u4E00-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA61F\uA62A\uA62B\uA640-\uA66E\uA67F-\uA69D\uA6A0-\uA6E5\uA717-\uA71F\uA722-\uA788\uA78B-\uA7CA\uA7D0\uA7D1\uA7D3\uA7D5-\uA7D9\uA7F2-\uA801\uA803-\uA805\uA807-\uA80A\uA80C-\uA822\uA840-\uA873\uA882-\uA8B3\uA8F2-\uA8F7\uA8FB\uA8FD\uA8FE\uA90A-\uA925\uA930-\uA946\uA960-\uA97C\uA984-\uA9B2\uA9CF\uA9E0-\uA9E4\uA9E6-\uA9EF\uA9FA-\uA9FE\uAA00-\uAA28\uAA40-\uAA42\uAA44-\uAA4B\uAA60-\uAA76\uAA7A\uAA7E-\uAAAF\uAAB1\uAAB5\uAAB6\uAAB9-\uAABD\uAAC0\uAAC2\uAADB-\uAADD\uAAE0-\uAAEA\uAAF2-\uAAF4\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB69\uAB70-\uABE2\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D\uFB1F-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE70-\uFE74\uFE76-\uFEFC\uFF21-\uFF3A\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC]|\uD800[\uDC00-\uDC0B\uDC0D-\uDC26\uDC28-\uDC3A\uDC3C\uDC3D\uDC3F-\uDC4D\uDC50-\uDC5D\uDC80-\uDCFA\uDE80-\uDE9C\uDEA0-\uDED0\uDF00-\uDF1F\uDF2D-\uDF40\uDF42-\uDF49\uDF50-\uDF75\uDF80-\uDF9D\uDFA0-\uDFC3\uDFC8-\uDFCF]|\uD801[\uDC00-\uDC9D\uDCB0-\uDCD3\uDCD8-\uDCFB\uDD00-\uDD27\uDD30-\uDD63\uDD70-\uDD7A\uDD7C-\uDD8A\uDD8C-\uDD92\uDD94\uDD95\uDD97-\uDDA1\uDDA3-\uDDB1\uDDB3-\uDDB9\uDDBB\uDDBC\uDE00-\uDF36\uDF40-\uDF55\uDF60-\uDF67\uDF80-\uDF85\uDF87-\uDFB0\uDFB2-\uDFBA]|\uD802[\uDC00-\uDC05\uDC08\uDC0A-\uDC35\uDC37\uDC38\uDC3C\uDC3F-\uDC55\uDC60-\uDC76\uDC80-\uDC9E\uDCE0-\uDCF2\uDCF4\uDCF5\uDD00-\uDD15\uDD20-\uDD39\uDD80-\uDDB7\uDDBE\uDDBF\uDE00\uDE10-\uDE13\uDE15-\uDE17\uDE19-\uDE35\uDE60-\uDE7C\uDE80-\uDE9C\uDEC0-\uDEC7\uDEC9-\uDEE4\uDF00-\uDF35\uDF40-\uDF55\uDF60-\uDF72\uDF80-\uDF91]|\uD803[\uDC00-\uDC48\uDC80-\uDCB2\uDCC0-\uDCF2\uDD00-\uDD23\uDE80-\uDEA9\uDEB0\uDEB1\uDF00-\uDF1C\uDF27\uDF30-\uDF45\uDF70-\uDF81\uDFB0-\uDFC4\uDFE0-\uDFF6]|\uD804[\uDC03-\uDC37\uDC71\uDC72\uDC75\uDC83-\uDCAF\uDCD0-\uDCE8\uDD03-\uDD26\uDD44\uDD47\uDD50-\uDD72\uDD76\uDD83-\uDDB2\uDDC1-\uDDC4\uDDDA\uDDDC\uDE00-\uDE11\uDE13-\uDE2B\uDE80-\uDE86\uDE88\uDE8A-\uDE8D\uDE8F-\uDE9D\uDE9F-\uDEA8\uDEB0-\uDEDE\uDF05-\uDF0C\uDF0F\uDF10\uDF13-\uDF28\uDF2A-\uDF30\uDF32\uDF33\uDF35-\uDF39\uDF3D\uDF50\uDF5D-\uDF61]|\uD805[\uDC00-\uDC34\uDC47-\uDC4A\uDC5F-\uDC61\uDC80-\uDCAF\uDCC4\uDCC5\uDCC7\uDD80-\uDDAE\uDDD8-\uDDDB\uDE00-\uDE2F\uDE44\uDE80-\uDEAA\uDEB8\uDF00-\uDF1A\uDF40-\uDF46]|\uD806[\uDC00-\uDC2B\uDCA0-\uDCDF\uDCFF-\uDD06\uDD09\uDD0C-\uDD13\uDD15\uDD16\uDD18-\uDD2F\uDD3F\uDD41\uDDA0-\uDDA7\uDDAA-\uDDD0\uDDE1\uDDE3\uDE00\uDE0B-\uDE32\uDE3A\uDE50\uDE5C-\uDE89\uDE9D\uDEB0-\uDEF8]|\uD807[\uDC00-\uDC08\uDC0A-\uDC2E\uDC40\uDC72-\uDC8F\uDD00-\uDD06\uDD08\uDD09\uDD0B-\uDD30\uDD46\uDD60-\uDD65\uDD67\uDD68\uDD6A-\uDD89\uDD98\uDEE0-\uDEF2\uDFB0]|\uD808[\uDC00-\uDF99]|\uD809[\uDC80-\uDD43]|\uD80B[\uDF90-\uDFF0]|[\uD80C\uD81C-\uD820\uD822\uD840-\uD868\uD86A-\uD86C\uD86F-\uD872\uD874-\uD879\uD880-\uD883][\uDC00-\uDFFF]|\uD80D[\uDC00-\uDC2E]|\uD811[\uDC00-\uDE46]|\uD81A[\uDC00-\uDE38\uDE40-\uDE5E\uDE70-\uDEBE\uDED0-\uDEED\uDF00-\uDF2F\uDF40-\uDF43\uDF63-\uDF77\uDF7D-\uDF8F]|\uD81B[\uDE40-\uDE7F\uDF00-\uDF4A\uDF50\uDF93-\uDF9F\uDFE0\uDFE1\uDFE3]|\uD821[\uDC00-\uDFF7]|\uD823[\uDC00-\uDCD5\uDD00-\uDD08]|\uD82B[\uDFF0-\uDFF3\uDFF5-\uDFFB\uDFFD\uDFFE]|\uD82C[\uDC00-\uDD22\uDD50-\uDD52\uDD64-\uDD67\uDD70-\uDEFB]|\uD82F[\uDC00-\uDC6A\uDC70-\uDC7C\uDC80-\uDC88\uDC90-\uDC99]|\uD835[\uDC00-\uDC54\uDC56-\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD1E-\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD52-\uDEA5\uDEA8-\uDEC0\uDEC2-\uDEDA\uDEDC-\uDEFA\uDEFC-\uDF14\uDF16-\uDF34\uDF36-\uDF4E\uDF50-\uDF6E\uDF70-\uDF88\uDF8A-\uDFA8\uDFAA-\uDFC2\uDFC4-\uDFCB]|\uD837[\uDF00-\uDF1E]|\uD838[\uDD00-\uDD2C\uDD37-\uDD3D\uDD4E\uDE90-\uDEAD\uDEC0-\uDEEB]|\uD839[\uDFE0-\uDFE6\uDFE8-\uDFEB\uDFED\uDFEE\uDFF0-\uDFFE]|\uD83A[\uDC00-\uDCC4\uDD00-\uDD43\uDD4B]|\uD83B[\uDE00-\uDE03\uDE05-\uDE1F\uDE21\uDE22\uDE24\uDE27\uDE29-\uDE32\uDE34-\uDE37\uDE39\uDE3B\uDE42\uDE47\uDE49\uDE4B\uDE4D-\uDE4F\uDE51\uDE52\uDE54\uDE57\uDE59\uDE5B\uDE5D\uDE5F\uDE61\uDE62\uDE64\uDE67-\uDE6A\uDE6C-\uDE72\uDE74-\uDE77\uDE79-\uDE7C\uDE7E\uDE80-\uDE89\uDE8B-\uDE9B\uDEA1-\uDEA3\uDEA5-\uDEA9\uDEAB-\uDEBB]|\uD869[\uDC00-\uDEDF\uDF00-\uDFFF]|\uD86D[\uDC00-\uDF38\uDF40-\uDFFF]|\uD86E[\uDC00-\uDC1D\uDC20-\uDFFF]|\uD873[\uDC00-\uDEA1\uDEB0-\uDFFF]|\uD87A[\uDC00-\uDFE0]|\uD87E[\uDC00-\uDE1D]|\uD884[\uDC00-\uDF4A])\S*/g;
var _TitleCasePipe = class _TitleCasePipe {
transform(value2) {
if (value2 == null)
return null;
if (typeof value2 !== "string") {
throw invalidPipeArgumentError(_TitleCasePipe, value2);
}
return value2.replace(unicodeWordMatch, (txt) => txt[0].toUpperCase() + txt.slice(1).toLowerCase());
}
};
_TitleCasePipe.\u0275fac = function TitleCasePipe_Factory(t) {
return new (t || _TitleCasePipe)();
};
_TitleCasePipe.\u0275pipe = /* @__PURE__ */ \u0275\u0275definePipe({
name: "titlecase",
type: _TitleCasePipe,
pure: true,
standalone: true
});
var TitleCasePipe = _TitleCasePipe;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(TitleCasePipe, [{
type: Pipe,
args: [{
name: "titlecase",
standalone: true
}]
}], null, null);
})();
var _UpperCasePipe = class _UpperCasePipe {
transform(value2) {
if (value2 == null)
return null;
if (typeof value2 !== "string") {
throw invalidPipeArgumentError(_UpperCasePipe, value2);
}
return value2.toUpperCase();
}
};
_UpperCasePipe.\u0275fac = function UpperCasePipe_Factory(t) {
return new (t || _UpperCasePipe)();
};
_UpperCasePipe.\u0275pipe = /* @__PURE__ */ \u0275\u0275definePipe({
name: "uppercase",
type: _UpperCasePipe,
pure: true,
standalone: true
});
var UpperCasePipe = _UpperCasePipe;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(UpperCasePipe, [{
type: Pipe,
args: [{
name: "uppercase",
standalone: true
}]
}], null, null);
})();
var DEFAULT_DATE_FORMAT = "mediumDate";
var DATE_PIPE_DEFAULT_TIMEZONE = new InjectionToken(ngDevMode ? "DATE_PIPE_DEFAULT_TIMEZONE" : "");
var DATE_PIPE_DEFAULT_OPTIONS = new InjectionToken(ngDevMode ? "DATE_PIPE_DEFAULT_OPTIONS" : "");
var _DatePipe = class _DatePipe {
constructor(locale, defaultTimezone, defaultOptions) {
this.locale = locale;
this.defaultTimezone = defaultTimezone;
this.defaultOptions = defaultOptions;
}
transform(value2, format, timezone, locale) {
if (value2 == null || value2 === "" || value2 !== value2)
return null;
try {
const _format = format ?? this.defaultOptions?.dateFormat ?? DEFAULT_DATE_FORMAT;
const _timezone = timezone ?? this.defaultOptions?.timezone ?? this.defaultTimezone ?? void 0;
return formatDate(value2, _format, locale || this.locale, _timezone);
} catch (error) {
throw invalidPipeArgumentError(_DatePipe, error.message);
}
}
};
_DatePipe.\u0275fac = function DatePipe_Factory(t) {
return new (t || _DatePipe)(\u0275\u0275directiveInject(LOCALE_ID, 16), \u0275\u0275directiveInject(DATE_PIPE_DEFAULT_TIMEZONE, 24), \u0275\u0275directiveInject(DATE_PIPE_DEFAULT_OPTIONS, 24));
};
_DatePipe.\u0275pipe = /* @__PURE__ */ \u0275\u0275definePipe({
name: "date",
type: _DatePipe,
pure: true,
standalone: true
});
var DatePipe = _DatePipe;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(DatePipe, [{
type: Pipe,
args: [{
name: "date",
standalone: true
}]
}], () => [{
type: void 0,
decorators: [{
type: Inject,
args: [LOCALE_ID]
}]
}, {
type: void 0,
decorators: [{
type: Inject,
args: [DATE_PIPE_DEFAULT_TIMEZONE]
}, {
type: Optional
}]
}, {
type: void 0,
decorators: [{
type: Inject,
args: [DATE_PIPE_DEFAULT_OPTIONS]
}, {
type: Optional
}]
}], null);
})();
var _INTERPOLATION_REGEXP = /#/g;
var _I18nPluralPipe = class _I18nPluralPipe {
constructor(_localization) {
this._localization = _localization;
}
/**
* @param value the number to be formatted
* @param pluralMap an object that mimics the ICU format, see
* https://unicode-org.github.io/icu/userguide/format_parse/messages/.
* @param locale a `string` defining the locale to use (uses the current {@link LOCALE_ID} by
* default).
*/
transform(value2, pluralMap, locale) {
if (value2 == null)
return "";
if (typeof pluralMap !== "object" || pluralMap === null) {
throw invalidPipeArgumentError(_I18nPluralPipe, pluralMap);
}
const key2 = getPluralCategory(value2, Object.keys(pluralMap), this._localization, locale);
return pluralMap[key2].replace(_INTERPOLATION_REGEXP, value2.toString());
}
};
_I18nPluralPipe.\u0275fac = function I18nPluralPipe_Factory(t) {
return new (t || _I18nPluralPipe)(\u0275\u0275directiveInject(NgLocalization, 16));
};
_I18nPluralPipe.\u0275pipe = /* @__PURE__ */ \u0275\u0275definePipe({
name: "i18nPlural",
type: _I18nPluralPipe,
pure: true,
standalone: true
});
var I18nPluralPipe = _I18nPluralPipe;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(I18nPluralPipe, [{
type: Pipe,
args: [{
name: "i18nPlural",
standalone: true
}]
}], () => [{
type: NgLocalization
}], null);
})();
var _I18nSelectPipe = class _I18nSelectPipe {
/**
* @param value a string to be internationalized.
* @param mapping an object that indicates the text that should be displayed
* for different values of the provided `value`.
*/
transform(value2, mapping) {
if (value2 == null)
return "";
if (typeof mapping !== "object" || typeof value2 !== "string") {
throw invalidPipeArgumentError(_I18nSelectPipe, mapping);
}
if (mapping.hasOwnProperty(value2)) {
return mapping[value2];
}
if (mapping.hasOwnProperty("other")) {
return mapping["other"];
}
return "";
}
};
_I18nSelectPipe.\u0275fac = function I18nSelectPipe_Factory(t) {
return new (t || _I18nSelectPipe)();
};
_I18nSelectPipe.\u0275pipe = /* @__PURE__ */ \u0275\u0275definePipe({
name: "i18nSelect",
type: _I18nSelectPipe,
pure: true,
standalone: true
});
var I18nSelectPipe = _I18nSelectPipe;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(I18nSelectPipe, [{
type: Pipe,
args: [{
name: "i18nSelect",
standalone: true
}]
}], null, null);
})();
var _JsonPipe = class _JsonPipe {
/**
* @param value A value of any type to convert into a JSON-format string.
*/
transform(value2) {
return JSON.stringify(value2, null, 2);
}
};
_JsonPipe.\u0275fac = function JsonPipe_Factory(t) {
return new (t || _JsonPipe)();
};
_JsonPipe.\u0275pipe = /* @__PURE__ */ \u0275\u0275definePipe({
name: "json",
type: _JsonPipe,
pure: false,
standalone: true
});
var JsonPipe = _JsonPipe;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(JsonPipe, [{
type: Pipe,
args: [{
name: "json",
pure: false,
standalone: true
}]
}], null, null);
})();
function makeKeyValuePair(key2, value2) {
return {
key: key2,
value: value2
};
}
var _KeyValuePipe = class _KeyValuePipe {
constructor(differs) {
this.differs = differs;
this.keyValues = [];
this.compareFn = defaultComparator;
}
transform(input2, compareFn = defaultComparator) {
if (!input2 || !(input2 instanceof Map) && typeof input2 !== "object") {
return null;
}
this.differ ??= this.differs.find(input2).create();
const differChanges = this.differ.diff(input2);
const compareFnChanged = compareFn !== this.compareFn;
if (differChanges) {
this.keyValues = [];
differChanges.forEachItem((r) => {
this.keyValues.push(makeKeyValuePair(r.key, r.currentValue));
});
}
if (differChanges || compareFnChanged) {
this.keyValues.sort(compareFn);
this.compareFn = compareFn;
}
return this.keyValues;
}
};
_KeyValuePipe.\u0275fac = function KeyValuePipe_Factory(t) {
return new (t || _KeyValuePipe)(\u0275\u0275directiveInject(KeyValueDiffers, 16));
};
_KeyValuePipe.\u0275pipe = /* @__PURE__ */ \u0275\u0275definePipe({
name: "keyvalue",
type: _KeyValuePipe,
pure: false,
standalone: true
});
var KeyValuePipe = _KeyValuePipe;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(KeyValuePipe, [{
type: Pipe,
args: [{
name: "keyvalue",
pure: false,
standalone: true
}]
}], () => [{
type: KeyValueDiffers
}], null);
})();
function defaultComparator(keyValueA, keyValueB) {
const a = keyValueA.key;
const b = keyValueB.key;
if (a === b)
return 0;
if (a === void 0)
return 1;
if (b === void 0)
return -1;
if (a === null)
return 1;
if (b === null)
return -1;
if (typeof a == "string" && typeof b == "string") {
return a < b ? -1 : 1;
}
if (typeof a == "number" && typeof b == "number") {
return a - b;
}
if (typeof a == "boolean" && typeof b == "boolean") {
return a < b ? -1 : 1;
}
const aString = String(a);
const bString = String(b);
return aString == bString ? 0 : aString < bString ? -1 : 1;
}
var _DecimalPipe = class _DecimalPipe {
constructor(_locale) {
this._locale = _locale;
}
/**
* @param value The value to be formatted.
* @param digitsInfo Sets digit and decimal representation.
* [See more](#digitsinfo).
* @param locale Specifies what locale format rules to use.
* [See more](#locale).
*/
transform(value2, digitsInfo, locale) {
if (!isValue(value2))
return null;
locale ||= this._locale;
try {
const num = strToNumber(value2);
return formatNumber(num, locale, digitsInfo);
} catch (error) {
throw invalidPipeArgumentError(_DecimalPipe, error.message);
}
}
};
_DecimalPipe.\u0275fac = function DecimalPipe_Factory(t) {
return new (t || _DecimalPipe)(\u0275\u0275directiveInject(LOCALE_ID, 16));
};
_DecimalPipe.\u0275pipe = /* @__PURE__ */ \u0275\u0275definePipe({
name: "number",
type: _DecimalPipe,
pure: true,
standalone: true
});
var DecimalPipe = _DecimalPipe;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(DecimalPipe, [{
type: Pipe,
args: [{
name: "number",
standalone: true
}]
}], () => [{
type: void 0,
decorators: [{
type: Inject,
args: [LOCALE_ID]
}]
}], null);
})();
var _PercentPipe = class _PercentPipe {
constructor(_locale) {
this._locale = _locale;
}
/**
*
* @param value The number to be formatted as a percentage.
* @param digitsInfo Decimal representation options, specified by a string
* in the following format:<br>
* <code>{minIntegerDigits}.{minFractionDigits}-{maxFractionDigits}</code>.
* - `minIntegerDigits`: The minimum number of integer digits before the decimal point.
* Default is `1`.
* - `minFractionDigits`: The minimum number of digits after the decimal point.
* Default is `0`.
* - `maxFractionDigits`: The maximum number of digits after the decimal point.
* Default is `0`.
* @param locale A locale code for the locale format rules to use.
* When not supplied, uses the value of `LOCALE_ID`, which is `en-US` by default.
* See [Setting your app locale](guide/i18n-common-locale-id).
*/
transform(value2, digitsInfo, locale) {
if (!isValue(value2))
return null;
locale ||= this._locale;
try {
const num = strToNumber(value2);
return formatPercent(num, locale, digitsInfo);
} catch (error) {
throw invalidPipeArgumentError(_PercentPipe, error.message);
}
}
};
_PercentPipe.\u0275fac = function PercentPipe_Factory(t) {
return new (t || _PercentPipe)(\u0275\u0275directiveInject(LOCALE_ID, 16));
};
_PercentPipe.\u0275pipe = /* @__PURE__ */ \u0275\u0275definePipe({
name: "percent",
type: _PercentPipe,
pure: true,
standalone: true
});
var PercentPipe = _PercentPipe;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(PercentPipe, [{
type: Pipe,
args: [{
name: "percent",
standalone: true
}]
}], () => [{
type: void 0,
decorators: [{
type: Inject,
args: [LOCALE_ID]
}]
}], null);
})();
var _CurrencyPipe = class _CurrencyPipe {
constructor(_locale, _defaultCurrencyCode = "USD") {
this._locale = _locale;
this._defaultCurrencyCode = _defaultCurrencyCode;
}
/**
*
* @param value The number to be formatted as currency.
* @param currencyCode The [ISO 4217](https://en.wikipedia.org/wiki/ISO_4217) currency code,
* such as `USD` for the US dollar and `EUR` for the euro. The default currency code can be
* configured using the `DEFAULT_CURRENCY_CODE` injection token.
* @param display The format for the currency indicator. One of the following:
* - `code`: Show the code (such as `USD`).
* - `symbol`(default): Show the symbol (such as `$`).
* - `symbol-narrow`: Use the narrow symbol for locales that have two symbols for their
* currency.
* For example, the Canadian dollar CAD has the symbol `CA$` and the symbol-narrow `$`. If the
* locale has no narrow symbol, uses the standard symbol for the locale.
* - String: Use the given string value instead of a code or a symbol.
* For example, an empty string will suppress the currency & symbol.
* - Boolean (marked deprecated in v5): `true` for symbol and false for `code`.
*
* @param digitsInfo Decimal representation options, specified by a string
* in the following format:<br>
* <code>{minIntegerDigits}.{minFractionDigits}-{maxFractionDigits}</code>.
* - `minIntegerDigits`: The minimum number of integer digits before the decimal point.
* Default is `1`.
* - `minFractionDigits`: The minimum number of digits after the decimal point.
* Default is `2`.
* - `maxFractionDigits`: The maximum number of digits after the decimal point.
* Default is `2`.
* If not provided, the number will be formatted with the proper amount of digits,
* depending on what the [ISO 4217](https://en.wikipedia.org/wiki/ISO_4217) specifies.
* For example, the Canadian dollar has 2 digits, whereas the Chilean peso has none.
* @param locale A locale code for the locale format rules to use.
* When not supplied, uses the value of `LOCALE_ID`, which is `en-US` by default.
* See [Setting your app locale](guide/i18n-common-locale-id).
*/
transform(value2, currencyCode = this._defaultCurrencyCode, display = "symbol", digitsInfo, locale) {
if (!isValue(value2))
return null;
locale ||= this._locale;
if (typeof display === "boolean") {
if ((typeof ngDevMode === "undefined" || ngDevMode) && console && console.warn) {
console.warn(`Warning: the currency pipe has been changed in Angular v5. The symbolDisplay option (third parameter) is now a string instead of a boolean. The accepted values are "code", "symbol" or "symbol-narrow".`);
}
display = display ? "symbol" : "code";
}
let currency = currencyCode || this._defaultCurrencyCode;
if (display !== "code") {
if (display === "symbol" || display === "symbol-narrow") {
currency = getCurrencySymbol(currency, display === "symbol" ? "wide" : "narrow", locale);
} else {
currency = display;
}
}
try {
const num = strToNumber(value2);
return formatCurrency(num, locale, currency, currencyCode, digitsInfo);
} catch (error) {
throw invalidPipeArgumentError(_CurrencyPipe, error.message);
}
}
};
_CurrencyPipe.\u0275fac = function CurrencyPipe_Factory(t) {
return new (t || _CurrencyPipe)(\u0275\u0275directiveInject(LOCALE_ID, 16), \u0275\u0275directiveInject(DEFAULT_CURRENCY_CODE, 16));
};
_CurrencyPipe.\u0275pipe = /* @__PURE__ */ \u0275\u0275definePipe({
name: "currency",
type: _CurrencyPipe,
pure: true,
standalone: true
});
var CurrencyPipe = _CurrencyPipe;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(CurrencyPipe, [{
type: Pipe,
args: [{
name: "currency",
standalone: true
}]
}], () => [{
type: void 0,
decorators: [{
type: Inject,
args: [LOCALE_ID]
}]
}, {
type: void 0,
decorators: [{
type: Inject,
args: [DEFAULT_CURRENCY_CODE]
}]
}], null);
})();
function isValue(value2) {
return !(value2 == null || value2 === "" || value2 !== value2);
}
function strToNumber(value2) {
if (typeof value2 === "string" && !isNaN(Number(value2) - parseFloat(value2))) {
return Number(value2);
}
if (typeof value2 !== "number") {
throw new Error(`${value2} is not a number`);
}
return value2;
}
var _SlicePipe = class _SlicePipe {
transform(value2, start, end) {
if (value2 == null)
return null;
if (!this.supports(value2)) {
throw invalidPipeArgumentError(_SlicePipe, value2);
}
return value2.slice(start, end);
}
supports(obj) {
return typeof obj === "string" || Array.isArray(obj);
}
};
_SlicePipe.\u0275fac = function SlicePipe_Factory(t) {
return new (t || _SlicePipe)();
};
_SlicePipe.\u0275pipe = /* @__PURE__ */ \u0275\u0275definePipe({
name: "slice",
type: _SlicePipe,
pure: false,
standalone: true
});
var SlicePipe = _SlicePipe;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(SlicePipe, [{
type: Pipe,
args: [{
name: "slice",
pure: false,
standalone: true
}]
}], null, null);
})();
var COMMON_PIPES = [AsyncPipe, UpperCasePipe, LowerCasePipe, JsonPipe, SlicePipe, DecimalPipe, PercentPipe, TitleCasePipe, CurrencyPipe, DatePipe, I18nPluralPipe, I18nSelectPipe, KeyValuePipe];
var _CommonModule = class _CommonModule {
};
_CommonModule.\u0275fac = function CommonModule_Factory(t) {
return new (t || _CommonModule)();
};
_CommonModule.\u0275mod = /* @__PURE__ */ \u0275\u0275defineNgModule({
type: _CommonModule
});
_CommonModule.\u0275inj = /* @__PURE__ */ \u0275\u0275defineInjector({});
var CommonModule = _CommonModule;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(CommonModule, [{
type: NgModule,
args: [{
imports: [COMMON_DIRECTIVES, COMMON_PIPES],
exports: [COMMON_DIRECTIVES, COMMON_PIPES]
}]
}], null, null);
})();
var PLATFORM_BROWSER_ID = "browser";
var PLATFORM_SERVER_ID = "server";
function isPlatformBrowser2(platformId) {
return platformId === PLATFORM_BROWSER_ID;
}
function isPlatformServer(platformId) {
return platformId === PLATFORM_SERVER_ID;
}
var VERSION2 = new Version("17.3.12");
var _ViewportScroller = class _ViewportScroller {
};
_ViewportScroller.\u0275prov = \u0275\u0275defineInjectable({
token: _ViewportScroller,
providedIn: "root",
factory: () => isPlatformBrowser2(inject(PLATFORM_ID)) ? new BrowserViewportScroller(inject(DOCUMENT2), window) : new NullViewportScroller()
});
var ViewportScroller = _ViewportScroller;
var BrowserViewportScroller = class {
constructor(document2, window2) {
this.document = document2;
this.window = window2;
this.offset = () => [0, 0];
}
/**
* Configures the top offset used when scrolling to an anchor.
* @param offset A position in screen coordinates (a tuple with x and y values)
* or a function that returns the top offset position.
*
*/
setOffset(offset) {
if (Array.isArray(offset)) {
this.offset = () => offset;
} else {
this.offset = offset;
}
}
/**
* Retrieves the current scroll position.
* @returns The position in screen coordinates.
*/
getScrollPosition() {
return [this.window.scrollX, this.window.scrollY];
}
/**
* Sets the scroll position.
* @param position The new position in screen coordinates.
*/
scrollToPosition(position2) {
this.window.scrollTo(position2[0], position2[1]);
}
/**
* Scrolls to an element and attempts to focus the element.
*
* Note that the function name here is misleading in that the target string may be an ID for a
* non-anchor element.
*
* @param target The ID of an element or name of the anchor.
*
* @see https://html.spec.whatwg.org/#the-indicated-part-of-the-document
* @see https://html.spec.whatwg.org/#scroll-to-fragid
*/
scrollToAnchor(target) {
const elSelected = findAnchorFromDocument(this.document, target);
if (elSelected) {
this.scrollToElement(elSelected);
elSelected.focus();
}
}
/**
* Disables automatic scroll restoration provided by the browser.
*/
setHistoryScrollRestoration(scrollRestoration) {
this.window.history.scrollRestoration = scrollRestoration;
}
/**
* Scrolls to an element using the native offset and the specified offset set on this scroller.
*
* The offset can be used when we know that there is a floating header and scrolling naively to an
* element (ex: `scrollIntoView`) leaves the element hidden behind the floating header.
*/
scrollToElement(el) {
const rect = el.getBoundingClientRect();
const left = rect.left + this.window.pageXOffset;
const top = rect.top + this.window.pageYOffset;
const offset = this.offset();
this.window.scrollTo(left - offset[0], top - offset[1]);
}
};
function findAnchorFromDocument(document2, target) {
const documentResult = document2.getElementById(target) || document2.getElementsByName(target)[0];
if (documentResult) {
return documentResult;
}
if (typeof document2.createTreeWalker === "function" && document2.body && typeof document2.body.attachShadow === "function") {
const treeWalker = document2.createTreeWalker(document2.body, NodeFilter.SHOW_ELEMENT);
let currentNode = treeWalker.currentNode;
while (currentNode) {
const shadowRoot = currentNode.shadowRoot;
if (shadowRoot) {
const result = shadowRoot.getElementById(target) || shadowRoot.querySelector(`[name="${target}"]`);
if (result) {
return result;
}
}
currentNode = treeWalker.nextNode();
}
}
return null;
}
var NullViewportScroller = class {
/**
* Empty implementation
*/
setOffset(offset) {
}
/**
* Empty implementation
*/
getScrollPosition() {
return [0, 0];
}
/**
* Empty implementation
*/
scrollToPosition(position2) {
}
/**
* Empty implementation
*/
scrollToAnchor(anchor) {
}
/**
* Empty implementation
*/
setHistoryScrollRestoration(scrollRestoration) {
}
};
var XhrFactory = class {
};
var PLACEHOLDER_QUALITY = "20";
function getUrl(src, win) {
return isAbsoluteUrl(src) ? new URL(src) : new URL(src, win.location.href);
}
function isAbsoluteUrl(src) {
return /^https?:\/\//.test(src);
}
function extractHostname(url) {
return isAbsoluteUrl(url) ? new URL(url).hostname : url;
}
function isValidPath(path) {
const isString = typeof path === "string";
if (!isString || path.trim() === "") {
return false;
}
try {
const url = new URL(path);
return true;
} catch {
return false;
}
}
function normalizePath(path) {
return path.endsWith("/") ? path.slice(0, -1) : path;
}
function normalizeSrc(src) {
return src.startsWith("/") ? src.slice(1) : src;
}
var noopImageLoader = (config2) => config2.src;
var IMAGE_LOADER = new InjectionToken(ngDevMode ? "ImageLoader" : "", {
providedIn: "root",
factory: () => noopImageLoader
});
function createImageLoader(buildUrlFn, exampleUrls) {
return function provideImageLoader(path) {
if (!isValidPath(path)) {
throwInvalidPathError(path, exampleUrls || []);
}
path = normalizePath(path);
const loaderFn = (config2) => {
if (isAbsoluteUrl(config2.src)) {
throwUnexpectedAbsoluteUrlError(path, config2.src);
}
return buildUrlFn(path, __spreadProps(__spreadValues({}, config2), {
src: normalizeSrc(config2.src)
}));
};
const providers = [{
provide: IMAGE_LOADER,
useValue: loaderFn
}];
return providers;
};
}
function throwInvalidPathError(path, exampleUrls) {
throw new RuntimeError(2959, ngDevMode && `Image loader has detected an invalid path (\`${path}\`). To fix this, supply a path using one of the following formats: ${exampleUrls.join(" or ")}`);
}
function throwUnexpectedAbsoluteUrlError(path, url) {
throw new RuntimeError(2959, ngDevMode && `Image loader has detected a \`<img>\` tag with an invalid \`ngSrc\` attribute: ${url}. This image loader expects \`ngSrc\` to be a relative URL - however the provided value is an absolute URL. To fix this, provide \`ngSrc\` as a path relative to the base URL configured for this loader (\`${path}\`).`);
}
var provideCloudflareLoader = createImageLoader(createCloudflareUrl, ngDevMode ? ["https://<ZONE>/cdn-cgi/image/<OPTIONS>/<SOURCE-IMAGE>"] : void 0);
function createCloudflareUrl(path, config2) {
let params = `format=auto`;
if (config2.width) {
params += `,width=${config2.width}`;
}
if (config2.isPlaceholder) {
params += `,quality=${PLACEHOLDER_QUALITY}`;
}
return `${path}/cdn-cgi/image/${params}/${config2.src}`;
}
var cloudinaryLoaderInfo = {
name: "Cloudinary",
testUrl: isCloudinaryUrl
};
var CLOUDINARY_LOADER_REGEX = /https?\:\/\/[^\/]+\.cloudinary\.com\/.+/;
function isCloudinaryUrl(url) {
return CLOUDINARY_LOADER_REGEX.test(url);
}
var provideCloudinaryLoader = createImageLoader(createCloudinaryUrl, ngDevMode ? ["https://res.cloudinary.com/mysite", "https://mysite.cloudinary.com", "https://subdomain.mysite.com"] : void 0);
function createCloudinaryUrl(path, config2) {
const quality = config2.isPlaceholder ? "q_auto:low" : "q_auto";
let params = `f_auto,${quality}`;
if (config2.width) {
params += `,w_${config2.width}`;
}
return `${path}/image/upload/${params}/${config2.src}`;
}
var imageKitLoaderInfo = {
name: "ImageKit",
testUrl: isImageKitUrl
};
var IMAGE_KIT_LOADER_REGEX = /https?\:\/\/[^\/]+\.imagekit\.io\/.+/;
function isImageKitUrl(url) {
return IMAGE_KIT_LOADER_REGEX.test(url);
}
var provideImageKitLoader = createImageLoader(createImagekitUrl, ngDevMode ? ["https://ik.imagekit.io/mysite", "https://subdomain.mysite.com"] : void 0);
function createImagekitUrl(path, config2) {
const {
src,
width: width2
} = config2;
const params = [];
if (width2) {
params.push(`w-${width2}`);
}
if (config2.isPlaceholder) {
params.push(`q-${PLACEHOLDER_QUALITY}`);
}
const urlSegments = params.length ? [path, `tr:${params.join(",")}`, src] : [path, src];
const url = new URL(urlSegments.join("/"));
return url.href;
}
var imgixLoaderInfo = {
name: "Imgix",
testUrl: isImgixUrl
};
var IMGIX_LOADER_REGEX = /https?\:\/\/[^\/]+\.imgix\.net\/.+/;
function isImgixUrl(url) {
return IMGIX_LOADER_REGEX.test(url);
}
var provideImgixLoader = createImageLoader(createImgixUrl, ngDevMode ? ["https://somepath.imgix.net/"] : void 0);
function createImgixUrl(path, config2) {
const url = new URL(`${path}/${config2.src}`);
url.searchParams.set("auto", "format");
if (config2.width) {
url.searchParams.set("w", config2.width.toString());
}
if (config2.isPlaceholder) {
url.searchParams.set("q", PLACEHOLDER_QUALITY);
}
return url.href;
}
var netlifyLoaderInfo = {
name: "Netlify",
testUrl: isNetlifyUrl
};
var NETLIFY_LOADER_REGEX = /https?\:\/\/[^\/]+\.netlify\.app\/.+/;
function isNetlifyUrl(url) {
return NETLIFY_LOADER_REGEX.test(url);
}
function imgDirectiveDetails(ngSrc, includeNgSrc = true) {
const ngSrcInfo = includeNgSrc ? `(activated on an <img> element with the \`ngSrc="${ngSrc}"\`) ` : "";
return `The NgOptimizedImage directive ${ngSrcInfo}has detected that`;
}
function assertDevMode(checkName) {
if (!ngDevMode) {
throw new RuntimeError(2958, `Unexpected invocation of the ${checkName} in the prod mode. Please make sure that the prod mode is enabled for production builds.`);
}
}
var _LCPImageObserver = class _LCPImageObserver {
constructor() {
this.images = /* @__PURE__ */ new Map();
this.window = null;
this.observer = null;
assertDevMode("LCP checker");
const win = inject(DOCUMENT2).defaultView;
if (typeof win !== "undefined" && typeof PerformanceObserver !== "undefined") {
this.window = win;
this.observer = this.initPerformanceObserver();
}
}
/**
* Inits PerformanceObserver and subscribes to LCP events.
* Based on https://web.dev/lcp/#measure-lcp-in-javascript
*/
initPerformanceObserver() {
const observer = new PerformanceObserver((entryList) => {
const entries = entryList.getEntries();
if (entries.length === 0)
return;
const lcpElement = entries[entries.length - 1];
const imgSrc = lcpElement.element?.src ?? "";
if (imgSrc.startsWith("data:") || imgSrc.startsWith("blob:"))
return;
const img = this.images.get(imgSrc);
if (!img)
return;
if (!img.priority && !img.alreadyWarnedPriority) {
img.alreadyWarnedPriority = true;
logMissingPriorityError(imgSrc);
}
if (img.modified && !img.alreadyWarnedModified) {
img.alreadyWarnedModified = true;
logModifiedWarning(imgSrc);
}
});
observer.observe({
type: "largest-contentful-paint",
buffered: true
});
return observer;
}
registerImage(rewrittenSrc, originalNgSrc, isPriority) {
if (!this.observer)
return;
const newObservedImageState = {
priority: isPriority,
modified: false,
alreadyWarnedModified: false,
alreadyWarnedPriority: false
};
this.images.set(getUrl(rewrittenSrc, this.window).href, newObservedImageState);
}
unregisterImage(rewrittenSrc) {
if (!this.observer)
return;
this.images.delete(getUrl(rewrittenSrc, this.window).href);
}
updateImage(originalSrc, newSrc) {
const originalUrl = getUrl(originalSrc, this.window).href;
const img = this.images.get(originalUrl);
if (img) {
img.modified = true;
this.images.set(getUrl(newSrc, this.window).href, img);
this.images.delete(originalUrl);
}
}
ngOnDestroy() {
if (!this.observer)
return;
this.observer.disconnect();
this.images.clear();
}
};
_LCPImageObserver.\u0275fac = function LCPImageObserver_Factory(t) {
return new (t || _LCPImageObserver)();
};
_LCPImageObserver.\u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
token: _LCPImageObserver,
factory: _LCPImageObserver.\u0275fac,
providedIn: "root"
});
var LCPImageObserver = _LCPImageObserver;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(LCPImageObserver, [{
type: Injectable,
args: [{
providedIn: "root"
}]
}], () => [], null);
})();
function logMissingPriorityError(ngSrc) {
const directiveDetails = imgDirectiveDetails(ngSrc);
console.error(formatRuntimeError(2955, `${directiveDetails} this image is the Largest Contentful Paint (LCP) element but was not marked "priority". This image should be marked "priority" in order to prioritize its loading. To fix this, add the "priority" attribute.`));
}
function logModifiedWarning(ngSrc) {
const directiveDetails = imgDirectiveDetails(ngSrc);
console.warn(formatRuntimeError(2964, `${directiveDetails} this image is the Largest Contentful Paint (LCP) element and has had its "ngSrc" attribute modified. This can cause slower loading performance. It is recommended not to modify the "ngSrc" property on any image which could be the LCP element.`));
}
var INTERNAL_PRECONNECT_CHECK_BLOCKLIST = /* @__PURE__ */ new Set(["localhost", "127.0.0.1", "0.0.0.0"]);
var PRECONNECT_CHECK_BLOCKLIST = new InjectionToken(ngDevMode ? "PRECONNECT_CHECK_BLOCKLIST" : "");
var _PreconnectLinkChecker = class _PreconnectLinkChecker {
constructor() {
this.document = inject(DOCUMENT2);
this.preconnectLinks = null;
this.alreadySeen = /* @__PURE__ */ new Set();
this.window = null;
this.blocklist = new Set(INTERNAL_PRECONNECT_CHECK_BLOCKLIST);
assertDevMode("preconnect link checker");
const win = this.document.defaultView;
if (typeof win !== "undefined") {
this.window = win;
}
const blocklist = inject(PRECONNECT_CHECK_BLOCKLIST, {
optional: true
});
if (blocklist) {
this.populateBlocklist(blocklist);
}
}
populateBlocklist(origins) {
if (Array.isArray(origins)) {
deepForEach2(origins, (origin) => {
this.blocklist.add(extractHostname(origin));
});
} else {
this.blocklist.add(extractHostname(origins));
}
}
/**
* Checks that a preconnect resource hint exists in the head for the
* given src.
*
* @param rewrittenSrc src formatted with loader
* @param originalNgSrc ngSrc value
*/
assertPreconnect(rewrittenSrc, originalNgSrc) {
if (!this.window)
return;
const imgUrl = getUrl(rewrittenSrc, this.window);
if (this.blocklist.has(imgUrl.hostname) || this.alreadySeen.has(imgUrl.origin))
return;
this.alreadySeen.add(imgUrl.origin);
this.preconnectLinks ??= this.queryPreconnectLinks();
if (!this.preconnectLinks.has(imgUrl.origin)) {
console.warn(formatRuntimeError(2956, `${imgDirectiveDetails(originalNgSrc)} there is no preconnect tag present for this image. Preconnecting to the origin(s) that serve priority images ensures that these images are delivered as soon as possible. To fix this, please add the following element into the <head> of the document:
<link rel="preconnect" href="${imgUrl.origin}">`));
}
}
queryPreconnectLinks() {
const preconnectUrls = /* @__PURE__ */ new Set();
const selector = "link[rel=preconnect]";
const links = Array.from(this.document.querySelectorAll(selector));
for (let link of links) {
const url = getUrl(link.href, this.window);
preconnectUrls.add(url.origin);
}
return preconnectUrls;
}
ngOnDestroy() {
this.preconnectLinks?.clear();
this.alreadySeen.clear();
}
};
_PreconnectLinkChecker.\u0275fac = function PreconnectLinkChecker_Factory(t) {
return new (t || _PreconnectLinkChecker)();
};
_PreconnectLinkChecker.\u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
token: _PreconnectLinkChecker,
factory: _PreconnectLinkChecker.\u0275fac,
providedIn: "root"
});
var PreconnectLinkChecker = _PreconnectLinkChecker;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(PreconnectLinkChecker, [{
type: Injectable,
args: [{
providedIn: "root"
}]
}], () => [], null);
})();
function deepForEach2(input2, fn) {
for (let value2 of input2) {
Array.isArray(value2) ? deepForEach2(value2, fn) : fn(value2);
}
}
var DEFAULT_PRELOADED_IMAGES_LIMIT = 5;
var PRELOADED_IMAGES = new InjectionToken("NG_OPTIMIZED_PRELOADED_IMAGES", {
providedIn: "root",
factory: () => /* @__PURE__ */ new Set()
});
var _PreloadLinkCreator = class _PreloadLinkCreator {
constructor() {
this.preloadedImages = inject(PRELOADED_IMAGES);
this.document = inject(DOCUMENT2);
}
/**
* @description Add a preload `<link>` to the `<head>` of the `index.html` that is served from the
* server while using Angular Universal and SSR to kick off image loads for high priority images.
*
* The `sizes` (passed in from the user) and `srcset` (parsed and formatted from `ngSrcset`)
* properties used to set the corresponding attributes, `imagesizes` and `imagesrcset`
* respectively, on the preload `<link>` tag so that the correctly sized image is preloaded from
* the CDN.
*
* {@link https://web.dev/preload-responsive-images/#imagesrcset-and-imagesizes}
*
* @param renderer The `Renderer2` passed in from the directive
* @param src The original src of the image that is set on the `ngSrc` input.
* @param srcset The parsed and formatted srcset created from the `ngSrcset` input
* @param sizes The value of the `sizes` attribute passed in to the `<img>` tag
*/
createPreloadLinkTag(renderer2, src, srcset, sizes) {
if (ngDevMode) {
if (this.preloadedImages.size >= DEFAULT_PRELOADED_IMAGES_LIMIT) {
throw new RuntimeError(2961, ngDevMode && `The \`NgOptimizedImage\` directive has detected that more than ${DEFAULT_PRELOADED_IMAGES_LIMIT} images were marked as priority. This might negatively affect an overall performance of the page. To fix this, remove the "priority" attribute from images with less priority.`);
}
}
if (this.preloadedImages.has(src)) {
return;
}
this.preloadedImages.add(src);
const preload = renderer2.createElement("link");
renderer2.setAttribute(preload, "as", "image");
renderer2.setAttribute(preload, "href", src);
renderer2.setAttribute(preload, "rel", "preload");
renderer2.setAttribute(preload, "fetchpriority", "high");
if (sizes) {
renderer2.setAttribute(preload, "imageSizes", sizes);
}
if (srcset) {
renderer2.setAttribute(preload, "imageSrcset", srcset);
}
renderer2.appendChild(this.document.head, preload);
}
};
_PreloadLinkCreator.\u0275fac = function PreloadLinkCreator_Factory(t) {
return new (t || _PreloadLinkCreator)();
};
_PreloadLinkCreator.\u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
token: _PreloadLinkCreator,
factory: _PreloadLinkCreator.\u0275fac,
providedIn: "root"
});
var PreloadLinkCreator = _PreloadLinkCreator;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(PreloadLinkCreator, [{
type: Injectable,
args: [{
providedIn: "root"
}]
}], null, null);
})();
var BASE64_IMG_MAX_LENGTH_IN_ERROR = 50;
var VALID_WIDTH_DESCRIPTOR_SRCSET = /^((\s*\d+w\s*(,|$)){1,})$/;
var VALID_DENSITY_DESCRIPTOR_SRCSET = /^((\s*\d+(\.\d+)?x\s*(,|$)){1,})$/;
var ABSOLUTE_SRCSET_DENSITY_CAP = 3;
var RECOMMENDED_SRCSET_DENSITY_CAP = 2;
var DENSITY_SRCSET_MULTIPLIERS = [1, 2];
var VIEWPORT_BREAKPOINT_CUTOFF = 640;
var ASPECT_RATIO_TOLERANCE = 0.1;
var OVERSIZED_IMAGE_TOLERANCE2 = 1e3;
var FIXED_SRCSET_WIDTH_LIMIT = 1920;
var FIXED_SRCSET_HEIGHT_LIMIT = 1080;
var PLACEHOLDER_BLUR_AMOUNT = 15;
var DATA_URL_WARN_LIMIT = 4e3;
var DATA_URL_ERROR_LIMIT = 1e4;
var BUILT_IN_LOADERS = [imgixLoaderInfo, imageKitLoaderInfo, cloudinaryLoaderInfo, netlifyLoaderInfo];
var _NgOptimizedImage = class _NgOptimizedImage {
constructor() {
this.imageLoader = inject(IMAGE_LOADER);
this.config = processConfig(inject(IMAGE_CONFIG));
this.renderer = inject(Renderer2);
this.imgElement = inject(ElementRef).nativeElement;
this.injector = inject(Injector);
this.isServer = isPlatformServer(inject(PLATFORM_ID));
this.preloadLinkCreator = inject(PreloadLinkCreator);
this.lcpObserver = ngDevMode ? this.injector.get(LCPImageObserver) : null;
this._renderedSrc = null;
this.priority = false;
this.disableOptimizedSrcset = false;
this.fill = false;
}
/** @nodoc */
ngOnInit() {
performanceMarkFeature("NgOptimizedImage");
if (ngDevMode) {
const ngZone = this.injector.get(NgZone);
assertNonEmptyInput(this, "ngSrc", this.ngSrc);
assertValidNgSrcset(this, this.ngSrcset);
assertNoConflictingSrc(this);
if (this.ngSrcset) {
assertNoConflictingSrcset(this);
}
assertNotBase64Image(this);
assertNotBlobUrl(this);
if (this.fill) {
assertEmptyWidthAndHeight(this);
ngZone.runOutsideAngular(() => assertNonZeroRenderedHeight(this, this.imgElement, this.renderer));
} else {
assertNonEmptyWidthAndHeight(this);
if (this.height !== void 0) {
assertGreaterThanZero(this, this.height, "height");
}
if (this.width !== void 0) {
assertGreaterThanZero(this, this.width, "width");
}
ngZone.runOutsideAngular(() => assertNoImageDistortion(this, this.imgElement, this.renderer));
}
assertValidLoadingInput(this);
if (!this.ngSrcset) {
assertNoComplexSizes(this);
}
assertValidPlaceholder(this, this.imageLoader);
assertNotMissingBuiltInLoader(this.ngSrc, this.imageLoader);
assertNoNgSrcsetWithoutLoader(this, this.imageLoader);
assertNoLoaderParamsWithoutLoader(this, this.imageLoader);
if (this.lcpObserver !== null) {
const ngZone2 = this.injector.get(NgZone);
ngZone2.runOutsideAngular(() => {
this.lcpObserver.registerImage(this.getRewrittenSrc(), this.ngSrc, this.priority);
});
}
if (this.priority) {
const checker = this.injector.get(PreconnectLinkChecker);
checker.assertPreconnect(this.getRewrittenSrc(), this.ngSrc);
}
}
if (this.placeholder) {
this.removePlaceholderOnLoad(this.imgElement);
}
this.setHostAttributes();
}
setHostAttributes() {
if (this.fill) {
this.sizes ||= "100vw";
} else {
this.setHostAttribute("width", this.width.toString());
this.setHostAttribute("height", this.height.toString());
}
this.setHostAttribute("loading", this.getLoadingBehavior());
this.setHostAttribute("fetchpriority", this.getFetchPriority());
this.setHostAttribute("ng-img", "true");
const rewrittenSrcset = this.updateSrcAndSrcset();
if (this.sizes) {
this.setHostAttribute("sizes", this.sizes);
}
if (this.isServer && this.priority) {
this.preloadLinkCreator.createPreloadLinkTag(this.renderer, this.getRewrittenSrc(), rewrittenSrcset, this.sizes);
}
}
/** @nodoc */
ngOnChanges(changes) {
if (ngDevMode) {
assertNoPostInitInputChange(this, changes, ["ngSrcset", "width", "height", "priority", "fill", "loading", "sizes", "loaderParams", "disableOptimizedSrcset"]);
}
if (changes["ngSrc"] && !changes["ngSrc"].isFirstChange()) {
const oldSrc = this._renderedSrc;
this.updateSrcAndSrcset(true);
const newSrc = this._renderedSrc;
if (this.lcpObserver !== null && oldSrc && newSrc && oldSrc !== newSrc) {
const ngZone = this.injector.get(NgZone);
ngZone.runOutsideAngular(() => {
this.lcpObserver?.updateImage(oldSrc, newSrc);
});
}
}
}
callImageLoader(configWithoutCustomParams) {
let augmentedConfig = configWithoutCustomParams;
if (this.loaderParams) {
augmentedConfig.loaderParams = this.loaderParams;
}
return this.imageLoader(augmentedConfig);
}
getLoadingBehavior() {
if (!this.priority && this.loading !== void 0) {
return this.loading;
}
return this.priority ? "eager" : "lazy";
}
getFetchPriority() {
return this.priority ? "high" : "auto";
}
getRewrittenSrc() {
if (!this._renderedSrc) {
const imgConfig = {
src: this.ngSrc
};
this._renderedSrc = this.callImageLoader(imgConfig);
}
return this._renderedSrc;
}
getRewrittenSrcset() {
const widthSrcSet = VALID_WIDTH_DESCRIPTOR_SRCSET.test(this.ngSrcset);
const finalSrcs = this.ngSrcset.split(",").filter((src) => src !== "").map((srcStr) => {
srcStr = srcStr.trim();
const width2 = widthSrcSet ? parseFloat(srcStr) : parseFloat(srcStr) * this.width;
return `${this.callImageLoader({
src: this.ngSrc,
width: width2
})} ${srcStr}`;
});
return finalSrcs.join(", ");
}
getAutomaticSrcset() {
if (this.sizes) {
return this.getResponsiveSrcset();
} else {
return this.getFixedSrcset();
}
}
getResponsiveSrcset() {
const {
breakpoints
} = this.config;
let filteredBreakpoints = breakpoints;
if (this.sizes?.trim() === "100vw") {
filteredBreakpoints = breakpoints.filter((bp) => bp >= VIEWPORT_BREAKPOINT_CUTOFF);
}
const finalSrcs = filteredBreakpoints.map((bp) => `${this.callImageLoader({
src: this.ngSrc,
width: bp
})} ${bp}w`);
return finalSrcs.join(", ");
}
updateSrcAndSrcset(forceSrcRecalc = false) {
if (forceSrcRecalc) {
this._renderedSrc = null;
}
const rewrittenSrc = this.getRewrittenSrc();
this.setHostAttribute("src", rewrittenSrc);
let rewrittenSrcset = void 0;
if (this.ngSrcset) {
rewrittenSrcset = this.getRewrittenSrcset();
} else if (this.shouldGenerateAutomaticSrcset()) {
rewrittenSrcset = this.getAutomaticSrcset();
}
if (rewrittenSrcset) {
this.setHostAttribute("srcset", rewrittenSrcset);
}
return rewrittenSrcset;
}
getFixedSrcset() {
const finalSrcs = DENSITY_SRCSET_MULTIPLIERS.map((multiplier) => `${this.callImageLoader({
src: this.ngSrc,
width: this.width * multiplier
})} ${multiplier}x`);
return finalSrcs.join(", ");
}
shouldGenerateAutomaticSrcset() {
let oversizedImage = false;
if (!this.sizes) {
oversizedImage = this.width > FIXED_SRCSET_WIDTH_LIMIT || this.height > FIXED_SRCSET_HEIGHT_LIMIT;
}
return !this.disableOptimizedSrcset && !this.srcset && this.imageLoader !== noopImageLoader && !oversizedImage;
}
/**
* Returns an image url formatted for use with the CSS background-image property. Expects one of:
* * A base64 encoded image, which is wrapped and passed through.
* * A boolean. If true, calls the image loader to generate a small placeholder url.
*/
generatePlaceholder(placeholderInput) {
const {
placeholderResolution
} = this.config;
if (placeholderInput === true) {
return `url(${this.callImageLoader({
src: this.ngSrc,
width: placeholderResolution,
isPlaceholder: true
})})`;
} else if (typeof placeholderInput === "string" && placeholderInput.startsWith("data:")) {
return `url(${placeholderInput})`;
}
return null;
}
/**
* Determines if blur should be applied, based on an optional boolean
* property `blur` within the optional configuration object `placeholderConfig`.
*/
shouldBlurPlaceholder(placeholderConfig) {
if (!placeholderConfig || !placeholderConfig.hasOwnProperty("blur")) {
return true;
}
return Boolean(placeholderConfig.blur);
}
removePlaceholderOnLoad(img) {
const callback = () => {
const changeDetectorRef = this.injector.get(ChangeDetectorRef);
removeLoadListenerFn();
removeErrorListenerFn();
this.placeholder = false;
changeDetectorRef.markForCheck();
};
const removeLoadListenerFn = this.renderer.listen(img, "load", callback);
const removeErrorListenerFn = this.renderer.listen(img, "error", callback);
}
/** @nodoc */
ngOnDestroy() {
if (ngDevMode) {
if (!this.priority && this._renderedSrc !== null && this.lcpObserver !== null) {
this.lcpObserver.unregisterImage(this._renderedSrc);
}
}
}
setHostAttribute(name2, value2) {
this.renderer.setAttribute(this.imgElement, name2, value2);
}
};
_NgOptimizedImage.\u0275fac = function NgOptimizedImage_Factory(t) {
return new (t || _NgOptimizedImage)();
};
_NgOptimizedImage.\u0275dir = /* @__PURE__ */ \u0275\u0275defineDirective({
type: _NgOptimizedImage,
selectors: [["img", "ngSrc", ""]],
hostVars: 18,
hostBindings: function NgOptimizedImage_HostBindings(rf, ctx) {
if (rf & 2) {
\u0275\u0275styleProp("position", ctx.fill ? "absolute" : null)("width", ctx.fill ? "100%" : null)("height", ctx.fill ? "100%" : null)("inset", ctx.fill ? "0" : null)("background-size", ctx.placeholder ? "cover" : null)("background-position", ctx.placeholder ? "50% 50%" : null)("background-repeat", ctx.placeholder ? "no-repeat" : null)("background-image", ctx.placeholder ? ctx.generatePlaceholder(ctx.placeholder) : null)("filter", ctx.placeholder && ctx.shouldBlurPlaceholder(ctx.placeholderConfig) ? "blur(15px)" : null);
}
},
inputs: {
ngSrc: [InputFlags.HasDecoratorInputTransform, "ngSrc", "ngSrc", unwrapSafeUrl],
ngSrcset: "ngSrcset",
sizes: "sizes",
width: [InputFlags.HasDecoratorInputTransform, "width", "width", numberAttribute],
height: [InputFlags.HasDecoratorInputTransform, "height", "height", numberAttribute],
loading: "loading",
priority: [InputFlags.HasDecoratorInputTransform, "priority", "priority", booleanAttribute],
loaderParams: "loaderParams",
disableOptimizedSrcset: [InputFlags.HasDecoratorInputTransform, "disableOptimizedSrcset", "disableOptimizedSrcset", booleanAttribute],
fill: [InputFlags.HasDecoratorInputTransform, "fill", "fill", booleanAttribute],
placeholder: [InputFlags.HasDecoratorInputTransform, "placeholder", "placeholder", booleanOrDataUrlAttribute],
placeholderConfig: "placeholderConfig",
src: "src",
srcset: "srcset"
},
standalone: true,
features: [\u0275\u0275InputTransformsFeature, \u0275\u0275NgOnChangesFeature]
});
var NgOptimizedImage = _NgOptimizedImage;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(NgOptimizedImage, [{
type: Directive,
args: [{
standalone: true,
selector: "img[ngSrc]",
host: {
"[style.position]": 'fill ? "absolute" : null',
"[style.width]": 'fill ? "100%" : null',
"[style.height]": 'fill ? "100%" : null',
"[style.inset]": 'fill ? "0" : null',
"[style.background-size]": 'placeholder ? "cover" : null',
"[style.background-position]": 'placeholder ? "50% 50%" : null',
"[style.background-repeat]": 'placeholder ? "no-repeat" : null',
"[style.background-image]": "placeholder ? generatePlaceholder(placeholder) : null",
"[style.filter]": `placeholder && shouldBlurPlaceholder(placeholderConfig) ? "blur(${PLACEHOLDER_BLUR_AMOUNT}px)" : null`
}
}]
}], null, {
ngSrc: [{
type: Input,
args: [{
required: true,
transform: unwrapSafeUrl
}]
}],
ngSrcset: [{
type: Input
}],
sizes: [{
type: Input
}],
width: [{
type: Input,
args: [{
transform: numberAttribute
}]
}],
height: [{
type: Input,
args: [{
transform: numberAttribute
}]
}],
loading: [{
type: Input
}],
priority: [{
type: Input,
args: [{
transform: booleanAttribute
}]
}],
loaderParams: [{
type: Input
}],
disableOptimizedSrcset: [{
type: Input,
args: [{
transform: booleanAttribute
}]
}],
fill: [{
type: Input,
args: [{
transform: booleanAttribute
}]
}],
placeholder: [{
type: Input,
args: [{
transform: booleanOrDataUrlAttribute
}]
}],
placeholderConfig: [{
type: Input
}],
src: [{
type: Input
}],
srcset: [{
type: Input
}]
});
})();
function processConfig(config2) {
let sortedBreakpoints = {};
if (config2.breakpoints) {
sortedBreakpoints.breakpoints = config2.breakpoints.sort((a, b) => a - b);
}
return Object.assign({}, IMAGE_CONFIG_DEFAULTS, config2, sortedBreakpoints);
}
function assertNoConflictingSrc(dir) {
if (dir.src) {
throw new RuntimeError(2950, `${imgDirectiveDetails(dir.ngSrc)} both \`src\` and \`ngSrc\` have been set. Supplying both of these attributes breaks lazy loading. The NgOptimizedImage directive sets \`src\` itself based on the value of \`ngSrc\`. To fix this, please remove the \`src\` attribute.`);
}
}
function assertNoConflictingSrcset(dir) {
if (dir.srcset) {
throw new RuntimeError(2951, `${imgDirectiveDetails(dir.ngSrc)} both \`srcset\` and \`ngSrcset\` have been set. Supplying both of these attributes breaks lazy loading. The NgOptimizedImage directive sets \`srcset\` itself based on the value of \`ngSrcset\`. To fix this, please remove the \`srcset\` attribute.`);
}
}
function assertNotBase64Image(dir) {
let ngSrc = dir.ngSrc.trim();
if (ngSrc.startsWith("data:")) {
if (ngSrc.length > BASE64_IMG_MAX_LENGTH_IN_ERROR) {
ngSrc = ngSrc.substring(0, BASE64_IMG_MAX_LENGTH_IN_ERROR) + "...";
}
throw new RuntimeError(2952, `${imgDirectiveDetails(dir.ngSrc, false)} \`ngSrc\` is a Base64-encoded string (${ngSrc}). NgOptimizedImage does not support Base64-encoded strings. To fix this, disable the NgOptimizedImage directive for this element by removing \`ngSrc\` and using a standard \`src\` attribute instead.`);
}
}
function assertNoComplexSizes(dir) {
let sizes = dir.sizes;
if (sizes?.match(/((\)|,)\s|^)\d+px/)) {
throw new RuntimeError(2952, `${imgDirectiveDetails(dir.ngSrc, false)} \`sizes\` was set to a string including pixel values. For automatic \`srcset\` generation, \`sizes\` must only include responsive values, such as \`sizes="50vw"\` or \`sizes="(min-width: 768px) 50vw, 100vw"\`. To fix this, modify the \`sizes\` attribute, or provide your own \`ngSrcset\` value directly.`);
}
}
function assertValidPlaceholder(dir, imageLoader) {
assertNoPlaceholderConfigWithoutPlaceholder(dir);
assertNoRelativePlaceholderWithoutLoader(dir, imageLoader);
assertNoOversizedDataUrl(dir);
}
function assertNoPlaceholderConfigWithoutPlaceholder(dir) {
if (dir.placeholderConfig && !dir.placeholder) {
throw new RuntimeError(2952, `${imgDirectiveDetails(dir.ngSrc, false)} \`placeholderConfig\` options were provided for an image that does not use the \`placeholder\` attribute, and will have no effect.`);
}
}
function assertNoRelativePlaceholderWithoutLoader(dir, imageLoader) {
if (dir.placeholder === true && imageLoader === noopImageLoader) {
throw new RuntimeError(2963, `${imgDirectiveDetails(dir.ngSrc)} the \`placeholder\` attribute is set to true but no image loader is configured (i.e. the default one is being used), which would result in the same image being used for the primary image and its placeholder. To fix this, provide a loader or remove the \`placeholder\` attribute from the image.`);
}
}
function assertNoOversizedDataUrl(dir) {
if (dir.placeholder && typeof dir.placeholder === "string" && dir.placeholder.startsWith("data:")) {
if (dir.placeholder.length > DATA_URL_ERROR_LIMIT) {
throw new RuntimeError(2965, `${imgDirectiveDetails(dir.ngSrc)} the \`placeholder\` attribute is set to a data URL which is longer than ${DATA_URL_ERROR_LIMIT} characters. This is strongly discouraged, as large inline placeholders directly increase the bundle size of Angular and hurt page load performance. To fix this, generate a smaller data URL placeholder.`);
}
if (dir.placeholder.length > DATA_URL_WARN_LIMIT) {
console.warn(formatRuntimeError(2965, `${imgDirectiveDetails(dir.ngSrc)} the \`placeholder\` attribute is set to a data URL which is longer than ${DATA_URL_WARN_LIMIT} characters. This is discouraged, as large inline placeholders directly increase the bundle size of Angular and hurt page load performance. For better loading performance, generate a smaller data URL placeholder.`));
}
}
}
function assertNotBlobUrl(dir) {
const ngSrc = dir.ngSrc.trim();
if (ngSrc.startsWith("blob:")) {
throw new RuntimeError(2952, `${imgDirectiveDetails(dir.ngSrc)} \`ngSrc\` was set to a blob URL (${ngSrc}). Blob URLs are not supported by the NgOptimizedImage directive. To fix this, disable the NgOptimizedImage directive for this element by removing \`ngSrc\` and using a regular \`src\` attribute instead.`);
}
}
function assertNonEmptyInput(dir, name2, value2) {
const isString = typeof value2 === "string";
const isEmptyString = isString && value2.trim() === "";
if (!isString || isEmptyString) {
throw new RuntimeError(2952, `${imgDirectiveDetails(dir.ngSrc)} \`${name2}\` has an invalid value (\`${value2}\`). To fix this, change the value to a non-empty string.`);
}
}
function assertValidNgSrcset(dir, value2) {
if (value2 == null)
return;
assertNonEmptyInput(dir, "ngSrcset", value2);
const stringVal = value2;
const isValidWidthDescriptor = VALID_WIDTH_DESCRIPTOR_SRCSET.test(stringVal);
const isValidDensityDescriptor = VALID_DENSITY_DESCRIPTOR_SRCSET.test(stringVal);
if (isValidDensityDescriptor) {
assertUnderDensityCap(dir, stringVal);
}
const isValidSrcset = isValidWidthDescriptor || isValidDensityDescriptor;
if (!isValidSrcset) {
throw new RuntimeError(2952, `${imgDirectiveDetails(dir.ngSrc)} \`ngSrcset\` has an invalid value (\`${value2}\`). To fix this, supply \`ngSrcset\` using a comma-separated list of one or more width descriptors (e.g. "100w, 200w") or density descriptors (e.g. "1x, 2x").`);
}
}
function assertUnderDensityCap(dir, value2) {
const underDensityCap = value2.split(",").every((num) => num === "" || parseFloat(num) <= ABSOLUTE_SRCSET_DENSITY_CAP);
if (!underDensityCap) {
throw new RuntimeError(2952, `${imgDirectiveDetails(dir.ngSrc)} the \`ngSrcset\` contains an unsupported image density:\`${value2}\`. NgOptimizedImage generally recommends a max image density of ${RECOMMENDED_SRCSET_DENSITY_CAP}x but supports image densities up to ${ABSOLUTE_SRCSET_DENSITY_CAP}x. The human eye cannot distinguish between image densities greater than ${RECOMMENDED_SRCSET_DENSITY_CAP}x - which makes them unnecessary for most use cases. Images that will be pinch-zoomed are typically the primary use case for ${ABSOLUTE_SRCSET_DENSITY_CAP}x images. Please remove the high density descriptor and try again.`);
}
}
function postInitInputChangeError(dir, inputName) {
let reason;
if (inputName === "width" || inputName === "height") {
reason = `Changing \`${inputName}\` may result in different attribute value applied to the underlying image element and cause layout shifts on a page.`;
} else {
reason = `Changing the \`${inputName}\` would have no effect on the underlying image element, because the resource loading has already occurred.`;
}
return new RuntimeError(2953, `${imgDirectiveDetails(dir.ngSrc)} \`${inputName}\` was updated after initialization. The NgOptimizedImage directive will not react to this input change. ${reason} To fix this, either switch \`${inputName}\` to a static value or wrap the image element in an *ngIf that is gated on the necessary value.`);
}
function assertNoPostInitInputChange(dir, changes, inputs) {
inputs.forEach((input2) => {
const isUpdated = changes.hasOwnProperty(input2);
if (isUpdated && !changes[input2].isFirstChange()) {
if (input2 === "ngSrc") {
dir = {
ngSrc: changes[input2].previousValue
};
}
throw postInitInputChangeError(dir, input2);
}
});
}
function assertGreaterThanZero(dir, inputValue, inputName) {
const validNumber = typeof inputValue === "number" && inputValue > 0;
const validString = typeof inputValue === "string" && /^\d+$/.test(inputValue.trim()) && parseInt(inputValue) > 0;
if (!validNumber && !validString) {
throw new RuntimeError(2952, `${imgDirectiveDetails(dir.ngSrc)} \`${inputName}\` has an invalid value. To fix this, provide \`${inputName}\` as a number greater than 0.`);
}
}
function assertNoImageDistortion(dir, img, renderer2) {
const removeLoadListenerFn = renderer2.listen(img, "load", () => {
removeLoadListenerFn();
removeErrorListenerFn();
const computedStyle = window.getComputedStyle(img);
let renderedWidth = parseFloat(computedStyle.getPropertyValue("width"));
let renderedHeight = parseFloat(computedStyle.getPropertyValue("height"));
const boxSizing = computedStyle.getPropertyValue("box-sizing");
if (boxSizing === "border-box") {
const paddingTop = computedStyle.getPropertyValue("padding-top");
const paddingRight = computedStyle.getPropertyValue("padding-right");
const paddingBottom = computedStyle.getPropertyValue("padding-bottom");
const paddingLeft = computedStyle.getPropertyValue("padding-left");
renderedWidth -= parseFloat(paddingRight) + parseFloat(paddingLeft);
renderedHeight -= parseFloat(paddingTop) + parseFloat(paddingBottom);
}
const renderedAspectRatio = renderedWidth / renderedHeight;
const nonZeroRenderedDimensions = renderedWidth !== 0 && renderedHeight !== 0;
const intrinsicWidth = img.naturalWidth;
const intrinsicHeight = img.naturalHeight;
const intrinsicAspectRatio = intrinsicWidth / intrinsicHeight;
const suppliedWidth = dir.width;
const suppliedHeight = dir.height;
const suppliedAspectRatio = suppliedWidth / suppliedHeight;
const inaccurateDimensions = Math.abs(suppliedAspectRatio - intrinsicAspectRatio) > ASPECT_RATIO_TOLERANCE;
const stylingDistortion = nonZeroRenderedDimensions && Math.abs(intrinsicAspectRatio - renderedAspectRatio) > ASPECT_RATIO_TOLERANCE;
if (inaccurateDimensions) {
console.warn(formatRuntimeError(2952, `${imgDirectiveDetails(dir.ngSrc)} the aspect ratio of the image does not match the aspect ratio indicated by the width and height attributes.
Intrinsic image size: ${intrinsicWidth}w x ${intrinsicHeight}h (aspect-ratio: ${round(intrinsicAspectRatio)}).
Supplied width and height attributes: ${suppliedWidth}w x ${suppliedHeight}h (aspect-ratio: ${round(suppliedAspectRatio)}).
To fix this, update the width and height attributes.`));
} else if (stylingDistortion) {
console.warn(formatRuntimeError(2952, `${imgDirectiveDetails(dir.ngSrc)} the aspect ratio of the rendered image does not match the image's intrinsic aspect ratio.
Intrinsic image size: ${intrinsicWidth}w x ${intrinsicHeight}h (aspect-ratio: ${round(intrinsicAspectRatio)}).
Rendered image size: ${renderedWidth}w x ${renderedHeight}h (aspect-ratio: ${round(renderedAspectRatio)}).
This issue can occur if "width" and "height" attributes are added to an image without updating the corresponding image styling. To fix this, adjust image styling. In most cases, adding "height: auto" or "width: auto" to the image styling will fix this issue.`));
} else if (!dir.ngSrcset && nonZeroRenderedDimensions) {
const recommendedWidth = RECOMMENDED_SRCSET_DENSITY_CAP * renderedWidth;
const recommendedHeight = RECOMMENDED_SRCSET_DENSITY_CAP * renderedHeight;
const oversizedWidth = intrinsicWidth - recommendedWidth >= OVERSIZED_IMAGE_TOLERANCE2;
const oversizedHeight = intrinsicHeight - recommendedHeight >= OVERSIZED_IMAGE_TOLERANCE2;
if (oversizedWidth || oversizedHeight) {
console.warn(formatRuntimeError(2960, `${imgDirectiveDetails(dir.ngSrc)} the intrinsic image is significantly larger than necessary.
Rendered image size: ${renderedWidth}w x ${renderedHeight}h.
Intrinsic image size: ${intrinsicWidth}w x ${intrinsicHeight}h.
Recommended intrinsic image size: ${recommendedWidth}w x ${recommendedHeight}h.
Note: Recommended intrinsic image size is calculated assuming a maximum DPR of ${RECOMMENDED_SRCSET_DENSITY_CAP}. To improve loading time, resize the image or consider using the "ngSrcset" and "sizes" attributes.`));
}
}
});
const removeErrorListenerFn = renderer2.listen(img, "error", () => {
removeLoadListenerFn();
removeErrorListenerFn();
});
}
function assertNonEmptyWidthAndHeight(dir) {
let missingAttributes = [];
if (dir.width === void 0)
missingAttributes.push("width");
if (dir.height === void 0)
missingAttributes.push("height");
if (missingAttributes.length > 0) {
throw new RuntimeError(2954, `${imgDirectiveDetails(dir.ngSrc)} these required attributes are missing: ${missingAttributes.map((attr) => `"${attr}"`).join(", ")}. Including "width" and "height" attributes will prevent image-related layout shifts. To fix this, include "width" and "height" attributes on the image tag or turn on "fill" mode with the \`fill\` attribute.`);
}
}
function assertEmptyWidthAndHeight(dir) {
if (dir.width || dir.height) {
throw new RuntimeError(2952, `${imgDirectiveDetails(dir.ngSrc)} the attributes \`height\` and/or \`width\` are present along with the \`fill\` attribute. Because \`fill\` mode causes an image to fill its containing element, the size attributes have no effect and should be removed.`);
}
}
function assertNonZeroRenderedHeight(dir, img, renderer2) {
const removeLoadListenerFn = renderer2.listen(img, "load", () => {
removeLoadListenerFn();
removeErrorListenerFn();
const renderedHeight = img.clientHeight;
if (dir.fill && renderedHeight === 0) {
console.warn(formatRuntimeError(2952, `${imgDirectiveDetails(dir.ngSrc)} the height of the fill-mode image is zero. This is likely because the containing element does not have the CSS 'position' property set to one of the following: "relative", "fixed", or "absolute". To fix this problem, make sure the container element has the CSS 'position' property defined and the height of the element is not zero.`));
}
});
const removeErrorListenerFn = renderer2.listen(img, "error", () => {
removeLoadListenerFn();
removeErrorListenerFn();
});
}
function assertValidLoadingInput(dir) {
if (dir.loading && dir.priority) {
throw new RuntimeError(2952, `${imgDirectiveDetails(dir.ngSrc)} the \`loading\` attribute was used on an image that was marked "priority". Setting \`loading\` on priority images is not allowed because these images will always be eagerly loaded. To fix this, remove the \u201Cloading\u201D attribute from the priority image.`);
}
const validInputs = ["auto", "eager", "lazy"];
if (typeof dir.loading === "string" && !validInputs.includes(dir.loading)) {
throw new RuntimeError(2952, `${imgDirectiveDetails(dir.ngSrc)} the \`loading\` attribute has an invalid value (\`${dir.loading}\`). To fix this, provide a valid value ("lazy", "eager", or "auto").`);
}
}
function assertNotMissingBuiltInLoader(ngSrc, imageLoader) {
if (imageLoader === noopImageLoader) {
let builtInLoaderName = "";
for (const loader of BUILT_IN_LOADERS) {
if (loader.testUrl(ngSrc)) {
builtInLoaderName = loader.name;
break;
}
}
if (builtInLoaderName) {
console.warn(formatRuntimeError(2962, `NgOptimizedImage: It looks like your images may be hosted on the ${builtInLoaderName} CDN, but your app is not using Angular's built-in loader for that CDN. We recommend switching to use the built-in by calling \`provide${builtInLoaderName}Loader()\` in your \`providers\` and passing it your instance's base URL. If you don't want to use the built-in loader, define a custom loader function using IMAGE_LOADER to silence this warning.`));
}
}
}
function assertNoNgSrcsetWithoutLoader(dir, imageLoader) {
if (dir.ngSrcset && imageLoader === noopImageLoader) {
console.warn(formatRuntimeError(2963, `${imgDirectiveDetails(dir.ngSrc)} the \`ngSrcset\` attribute is present but no image loader is configured (i.e. the default one is being used), which would result in the same image being used for all configured sizes. To fix this, provide a loader or remove the \`ngSrcset\` attribute from the image.`));
}
}
function assertNoLoaderParamsWithoutLoader(dir, imageLoader) {
if (dir.loaderParams && imageLoader === noopImageLoader) {
console.warn(formatRuntimeError(2963, `${imgDirectiveDetails(dir.ngSrc)} the \`loaderParams\` attribute is present but no image loader is configured (i.e. the default one is being used), which means that the loaderParams data will not be consumed and will not affect the URL. To fix this, provide a custom loader or remove the \`loaderParams\` attribute from the image.`));
}
}
function round(input2) {
return Number.isInteger(input2) ? input2 : input2.toFixed(2);
}
function unwrapSafeUrl(value2) {
if (typeof value2 === "string") {
return value2;
}
return unwrapSafeValue(value2);
}
function booleanOrDataUrlAttribute(value2) {
if (typeof value2 === "string" && value2.startsWith(`data:`)) {
return value2;
}
return booleanAttribute(value2);
}
// node_modules/@angular/common/fesm2022/http.mjs
var HttpHandler = class {
};
var HttpBackend = class {
};
var HttpHeaders = class _HttpHeaders {
/** Constructs a new HTTP header object with the given values.*/
constructor(headers) {
this.normalizedNames = /* @__PURE__ */ new Map();
this.lazyUpdate = null;
if (!headers) {
this.headers = /* @__PURE__ */ new Map();
} else if (typeof headers === "string") {
this.lazyInit = () => {
this.headers = /* @__PURE__ */ new Map();
headers.split("\n").forEach((line) => {
const index2 = line.indexOf(":");
if (index2 > 0) {
const name2 = line.slice(0, index2);
const key2 = name2.toLowerCase();
const value2 = line.slice(index2 + 1).trim();
this.maybeSetNormalizedName(name2, key2);
if (this.headers.has(key2)) {
this.headers.get(key2).push(value2);
} else {
this.headers.set(key2, [value2]);
}
}
});
};
} else if (typeof Headers !== "undefined" && headers instanceof Headers) {
this.headers = /* @__PURE__ */ new Map();
headers.forEach((values, name2) => {
this.setHeaderEntries(name2, values);
});
} else {
this.lazyInit = () => {
if (typeof ngDevMode === "undefined" || ngDevMode) {
assertValidHeaders(headers);
}
this.headers = /* @__PURE__ */ new Map();
Object.entries(headers).forEach(([name2, values]) => {
this.setHeaderEntries(name2, values);
});
};
}
}
/**
* Checks for existence of a given header.
*
* @param name The header name to check for existence.
*
* @returns True if the header exists, false otherwise.
*/
has(name2) {
this.init();
return this.headers.has(name2.toLowerCase());
}
/**
* Retrieves the first value of a given header.
*
* @param name The header name.
*
* @returns The value string if the header exists, null otherwise
*/
get(name2) {
this.init();
const values = this.headers.get(name2.toLowerCase());
return values && values.length > 0 ? values[0] : null;
}
/**
* Retrieves the names of the headers.
*
* @returns A list of header names.
*/
keys() {
this.init();
return Array.from(this.normalizedNames.values());
}
/**
* Retrieves a list of values for a given header.
*
* @param name The header name from which to retrieve values.
*
* @returns A string of values if the header exists, null otherwise.
*/
getAll(name2) {
this.init();
return this.headers.get(name2.toLowerCase()) || null;
}
/**
* Appends a new value to the existing set of values for a header
* and returns them in a clone of the original instance.
*
* @param name The header name for which to append the values.
* @param value The value to append.
*
* @returns A clone of the HTTP headers object with the value appended to the given header.
*/
append(name2, value2) {
return this.clone({
name: name2,
value: value2,
op: "a"
});
}
/**
* Sets or modifies a value for a given header in a clone of the original instance.
* If the header already exists, its value is replaced with the given value
* in the returned object.
*
* @param name The header name.
* @param value The value or values to set or override for the given header.
*
* @returns A clone of the HTTP headers object with the newly set header value.
*/
set(name2, value2) {
return this.clone({
name: name2,
value: value2,
op: "s"
});
}
/**
* Deletes values for a given header in a clone of the original instance.
*
* @param name The header name.
* @param value The value or values to delete for the given header.
*
* @returns A clone of the HTTP headers object with the given value deleted.
*/
delete(name2, value2) {
return this.clone({
name: name2,
value: value2,
op: "d"
});
}
maybeSetNormalizedName(name2, lcName) {
if (!this.normalizedNames.has(lcName)) {
this.normalizedNames.set(lcName, name2);
}
}
init() {
if (!!this.lazyInit) {
if (this.lazyInit instanceof _HttpHeaders) {
this.copyFrom(this.lazyInit);
} else {
this.lazyInit();
}
this.lazyInit = null;
if (!!this.lazyUpdate) {
this.lazyUpdate.forEach((update) => this.applyUpdate(update));
this.lazyUpdate = null;
}
}
}
copyFrom(other) {
other.init();
Array.from(other.headers.keys()).forEach((key2) => {
this.headers.set(key2, other.headers.get(key2));
this.normalizedNames.set(key2, other.normalizedNames.get(key2));
});
}
clone(update) {
const clone = new _HttpHeaders();
clone.lazyInit = !!this.lazyInit && this.lazyInit instanceof _HttpHeaders ? this.lazyInit : this;
clone.lazyUpdate = (this.lazyUpdate || []).concat([update]);
return clone;
}
applyUpdate(update) {
const key2 = update.name.toLowerCase();
switch (update.op) {
case "a":
case "s":
let value2 = update.value;
if (typeof value2 === "string") {
value2 = [value2];
}
if (value2.length === 0) {
return;
}
this.maybeSetNormalizedName(update.name, key2);
const base = (update.op === "a" ? this.headers.get(key2) : void 0) || [];
base.push(...value2);
this.headers.set(key2, base);
break;
case "d":
const toDelete = update.value;
if (!toDelete) {
this.headers.delete(key2);
this.normalizedNames.delete(key2);
} else {
let existing = this.headers.get(key2);
if (!existing) {
return;
}
existing = existing.filter((value3) => toDelete.indexOf(value3) === -1);
if (existing.length === 0) {
this.headers.delete(key2);
this.normalizedNames.delete(key2);
} else {
this.headers.set(key2, existing);
}
}
break;
}
}
setHeaderEntries(name2, values) {
const headerValues = (Array.isArray(values) ? values : [values]).map((value2) => value2.toString());
const key2 = name2.toLowerCase();
this.headers.set(key2, headerValues);
this.maybeSetNormalizedName(name2, key2);
}
/**
* @internal
*/
forEach(fn) {
this.init();
Array.from(this.normalizedNames.keys()).forEach((key2) => fn(this.normalizedNames.get(key2), this.headers.get(key2)));
}
};
function assertValidHeaders(headers) {
for (const [key2, value2] of Object.entries(headers)) {
if (!(typeof value2 === "string" || typeof value2 === "number") && !Array.isArray(value2)) {
throw new Error(`Unexpected value of the \`${key2}\` header provided. Expecting either a string, a number or an array, but got: \`${value2}\`.`);
}
}
}
var HttpUrlEncodingCodec = class {
/**
* Encodes a key name for a URL parameter or query-string.
* @param key The key name.
* @returns The encoded key name.
*/
encodeKey(key2) {
return standardEncoding(key2);
}
/**
* Encodes the value of a URL parameter or query-string.
* @param value The value.
* @returns The encoded value.
*/
encodeValue(value2) {
return standardEncoding(value2);
}
/**
* Decodes an encoded URL parameter or query-string key.
* @param key The encoded key name.
* @returns The decoded key name.
*/
decodeKey(key2) {
return decodeURIComponent(key2);
}
/**
* Decodes an encoded URL parameter or query-string value.
* @param value The encoded value.
* @returns The decoded value.
*/
decodeValue(value2) {
return decodeURIComponent(value2);
}
};
function paramParser(rawParams, codec) {
const map2 = /* @__PURE__ */ new Map();
if (rawParams.length > 0) {
const params = rawParams.replace(/^\?/, "").split("&");
params.forEach((param) => {
const eqIdx = param.indexOf("=");
const [key2, val2] = eqIdx == -1 ? [codec.decodeKey(param), ""] : [codec.decodeKey(param.slice(0, eqIdx)), codec.decodeValue(param.slice(eqIdx + 1))];
const list = map2.get(key2) || [];
list.push(val2);
map2.set(key2, list);
});
}
return map2;
}
var STANDARD_ENCODING_REGEX = /%(\d[a-f0-9])/gi;
var STANDARD_ENCODING_REPLACEMENTS = {
"40": "@",
"3A": ":",
"24": "$",
"2C": ",",
"3B": ";",
"3D": "=",
"3F": "?",
"2F": "/"
};
function standardEncoding(v) {
return encodeURIComponent(v).replace(STANDARD_ENCODING_REGEX, (s, t) => STANDARD_ENCODING_REPLACEMENTS[t] ?? s);
}
function valueToString(value2) {
return `${value2}`;
}
var HttpParams = class _HttpParams {
constructor(options = {}) {
this.updates = null;
this.cloneFrom = null;
this.encoder = options.encoder || new HttpUrlEncodingCodec();
if (!!options.fromString) {
if (!!options.fromObject) {
throw new Error(`Cannot specify both fromString and fromObject.`);
}
this.map = paramParser(options.fromString, this.encoder);
} else if (!!options.fromObject) {
this.map = /* @__PURE__ */ new Map();
Object.keys(options.fromObject).forEach((key2) => {
const value2 = options.fromObject[key2];
const values = Array.isArray(value2) ? value2.map(valueToString) : [valueToString(value2)];
this.map.set(key2, values);
});
} else {
this.map = null;
}
}
/**
* Reports whether the body includes one or more values for a given parameter.
* @param param The parameter name.
* @returns True if the parameter has one or more values,
* false if it has no value or is not present.
*/
has(param) {
this.init();
return this.map.has(param);
}
/**
* Retrieves the first value for a parameter.
* @param param The parameter name.
* @returns The first value of the given parameter,
* or `null` if the parameter is not present.
*/
get(param) {
this.init();
const res = this.map.get(param);
return !!res ? res[0] : null;
}
/**
* Retrieves all values for a parameter.
* @param param The parameter name.
* @returns All values in a string array,
* or `null` if the parameter not present.
*/
getAll(param) {
this.init();
return this.map.get(param) || null;
}
/**
* Retrieves all the parameters for this body.
* @returns The parameter names in a string array.
*/
keys() {
this.init();
return Array.from(this.map.keys());
}
/**
* Appends a new value to existing values for a parameter.
* @param param The parameter name.
* @param value The new value to add.
* @return A new body with the appended value.
*/
append(param, value2) {
return this.clone({
param,
value: value2,
op: "a"
});
}
/**
* Constructs a new body with appended values for the given parameter name.
* @param params parameters and values
* @return A new body with the new value.
*/
appendAll(params) {
const updates = [];
Object.keys(params).forEach((param) => {
const value2 = params[param];
if (Array.isArray(value2)) {
value2.forEach((_value) => {
updates.push({
param,
value: _value,
op: "a"
});
});
} else {
updates.push({
param,
value: value2,
op: "a"
});
}
});
return this.clone(updates);
}
/**
* Replaces the value for a parameter.
* @param param The parameter name.
* @param value The new value.
* @return A new body with the new value.
*/
set(param, value2) {
return this.clone({
param,
value: value2,
op: "s"
});
}
/**
* Removes a given value or all values from a parameter.
* @param param The parameter name.
* @param value The value to remove, if provided.
* @return A new body with the given value removed, or with all values
* removed if no value is specified.
*/
delete(param, value2) {
return this.clone({
param,
value: value2,
op: "d"
});
}
/**
* Serializes the body to an encoded string, where key-value pairs (separated by `=`) are
* separated by `&`s.
*/
toString() {
this.init();
return this.keys().map((key2) => {
const eKey = this.encoder.encodeKey(key2);
return this.map.get(key2).map((value2) => eKey + "=" + this.encoder.encodeValue(value2)).join("&");
}).filter((param) => param !== "").join("&");
}
clone(update) {
const clone = new _HttpParams({
encoder: this.encoder
});
clone.cloneFrom = this.cloneFrom || this;
clone.updates = (this.updates || []).concat(update);
return clone;
}
init() {
if (this.map === null) {
this.map = /* @__PURE__ */ new Map();
}
if (this.cloneFrom !== null) {
this.cloneFrom.init();
this.cloneFrom.keys().forEach((key2) => this.map.set(key2, this.cloneFrom.map.get(key2)));
this.updates.forEach((update) => {
switch (update.op) {
case "a":
case "s":
const base = (update.op === "a" ? this.map.get(update.param) : void 0) || [];
base.push(valueToString(update.value));
this.map.set(update.param, base);
break;
case "d":
if (update.value !== void 0) {
let base2 = this.map.get(update.param) || [];
const idx = base2.indexOf(valueToString(update.value));
if (idx !== -1) {
base2.splice(idx, 1);
}
if (base2.length > 0) {
this.map.set(update.param, base2);
} else {
this.map.delete(update.param);
}
} else {
this.map.delete(update.param);
break;
}
}
});
this.cloneFrom = this.updates = null;
}
}
};
var HttpContext = class {
constructor() {
this.map = /* @__PURE__ */ new Map();
}
/**
* Store a value in the context. If a value is already present it will be overwritten.
*
* @param token The reference to an instance of `HttpContextToken`.
* @param value The value to store.
*
* @returns A reference to itself for easy chaining.
*/
set(token, value2) {
this.map.set(token, value2);
return this;
}
/**
* Retrieve the value associated with the given token.
*
* @param token The reference to an instance of `HttpContextToken`.
*
* @returns The stored value or default if one is defined.
*/
get(token) {
if (!this.map.has(token)) {
this.map.set(token, token.defaultValue());
}
return this.map.get(token);
}
/**
* Delete the value associated with the given token.
*
* @param token The reference to an instance of `HttpContextToken`.
*
* @returns A reference to itself for easy chaining.
*/
delete(token) {
this.map.delete(token);
return this;
}
/**
* Checks for existence of a given token.
*
* @param token The reference to an instance of `HttpContextToken`.
*
* @returns True if the token exists, false otherwise.
*/
has(token) {
return this.map.has(token);
}
/**
* @returns a list of tokens currently stored in the context.
*/
keys() {
return this.map.keys();
}
};
function mightHaveBody(method) {
switch (method) {
case "DELETE":
case "GET":
case "HEAD":
case "OPTIONS":
case "JSONP":
return false;
default:
return true;
}
}
function isArrayBuffer(value2) {
return typeof ArrayBuffer !== "undefined" && value2 instanceof ArrayBuffer;
}
function isBlob(value2) {
return typeof Blob !== "undefined" && value2 instanceof Blob;
}
function isFormData(value2) {
return typeof FormData !== "undefined" && value2 instanceof FormData;
}
function isUrlSearchParams(value2) {
return typeof URLSearchParams !== "undefined" && value2 instanceof URLSearchParams;
}
var HttpRequest = class _HttpRequest {
constructor(method, url, third, fourth) {
this.url = url;
this.body = null;
this.reportProgress = false;
this.withCredentials = false;
this.responseType = "json";
this.method = method.toUpperCase();
let options;
if (mightHaveBody(this.method) || !!fourth) {
this.body = third !== void 0 ? third : null;
options = fourth;
} else {
options = third;
}
if (options) {
this.reportProgress = !!options.reportProgress;
this.withCredentials = !!options.withCredentials;
if (!!options.responseType) {
this.responseType = options.responseType;
}
if (!!options.headers) {
this.headers = options.headers;
}
if (!!options.context) {
this.context = options.context;
}
if (!!options.params) {
this.params = options.params;
}
this.transferCache = options.transferCache;
}
this.headers ??= new HttpHeaders();
this.context ??= new HttpContext();
if (!this.params) {
this.params = new HttpParams();
this.urlWithParams = url;
} else {
const params = this.params.toString();
if (params.length === 0) {
this.urlWithParams = url;
} else {
const qIdx = url.indexOf("?");
const sep = qIdx === -1 ? "?" : qIdx < url.length - 1 ? "&" : "";
this.urlWithParams = url + sep + params;
}
}
}
/**
* Transform the free-form body into a serialized format suitable for
* transmission to the server.
*/
serializeBody() {
if (this.body === null) {
return null;
}
if (typeof this.body === "string" || isArrayBuffer(this.body) || isBlob(this.body) || isFormData(this.body) || isUrlSearchParams(this.body)) {
return this.body;
}
if (this.body instanceof HttpParams) {
return this.body.toString();
}
if (typeof this.body === "object" || typeof this.body === "boolean" || Array.isArray(this.body)) {
return JSON.stringify(this.body);
}
return this.body.toString();
}
/**
* Examine the body and attempt to infer an appropriate MIME type
* for it.
*
* If no such type can be inferred, this method will return `null`.
*/
detectContentTypeHeader() {
if (this.body === null) {
return null;
}
if (isFormData(this.body)) {
return null;
}
if (isBlob(this.body)) {
return this.body.type || null;
}
if (isArrayBuffer(this.body)) {
return null;
}
if (typeof this.body === "string") {
return "text/plain";
}
if (this.body instanceof HttpParams) {
return "application/x-www-form-urlencoded;charset=UTF-8";
}
if (typeof this.body === "object" || typeof this.body === "number" || typeof this.body === "boolean") {
return "application/json";
}
return null;
}
clone(update = {}) {
const method = update.method || this.method;
const url = update.url || this.url;
const responseType = update.responseType || this.responseType;
const transferCache = update.transferCache ?? this.transferCache;
const body = update.body !== void 0 ? update.body : this.body;
const withCredentials = update.withCredentials ?? this.withCredentials;
const reportProgress = update.reportProgress ?? this.reportProgress;
let headers = update.headers || this.headers;
let params = update.params || this.params;
const context2 = update.context ?? this.context;
if (update.setHeaders !== void 0) {
headers = Object.keys(update.setHeaders).reduce((headers2, name2) => headers2.set(name2, update.setHeaders[name2]), headers);
}
if (update.setParams) {
params = Object.keys(update.setParams).reduce((params2, param) => params2.set(param, update.setParams[param]), params);
}
return new _HttpRequest(method, url, body, {
params,
headers,
context: context2,
reportProgress,
responseType,
withCredentials,
transferCache
});
}
};
var HttpEventType;
(function(HttpEventType2) {
HttpEventType2[HttpEventType2["Sent"] = 0] = "Sent";
HttpEventType2[HttpEventType2["UploadProgress"] = 1] = "UploadProgress";
HttpEventType2[HttpEventType2["ResponseHeader"] = 2] = "ResponseHeader";
HttpEventType2[HttpEventType2["DownloadProgress"] = 3] = "DownloadProgress";
HttpEventType2[HttpEventType2["Response"] = 4] = "Response";
HttpEventType2[HttpEventType2["User"] = 5] = "User";
})(HttpEventType || (HttpEventType = {}));
var HttpResponseBase = class {
/**
* Super-constructor for all responses.
*
* The single parameter accepted is an initialization hash. Any properties
* of the response passed there will override the default values.
*/
constructor(init, defaultStatus = HttpStatusCode.Ok, defaultStatusText = "OK") {
this.headers = init.headers || new HttpHeaders();
this.status = init.status !== void 0 ? init.status : defaultStatus;
this.statusText = init.statusText || defaultStatusText;
this.url = init.url || null;
this.ok = this.status >= 200 && this.status < 300;
}
};
var HttpHeaderResponse = class _HttpHeaderResponse extends HttpResponseBase {
/**
* Create a new `HttpHeaderResponse` with the given parameters.
*/
constructor(init = {}) {
super(init);
this.type = HttpEventType.ResponseHeader;
}
/**
* Copy this `HttpHeaderResponse`, overriding its contents with the
* given parameter hash.
*/
clone(update = {}) {
return new _HttpHeaderResponse({
headers: update.headers || this.headers,
status: update.status !== void 0 ? update.status : this.status,
statusText: update.statusText || this.statusText,
url: update.url || this.url || void 0
});
}
};
var HttpResponse = class _HttpResponse extends HttpResponseBase {
/**
* Construct a new `HttpResponse`.
*/
constructor(init = {}) {
super(init);
this.type = HttpEventType.Response;
this.body = init.body !== void 0 ? init.body : null;
}
clone(update = {}) {
return new _HttpResponse({
body: update.body !== void 0 ? update.body : this.body,
headers: update.headers || this.headers,
status: update.status !== void 0 ? update.status : this.status,
statusText: update.statusText || this.statusText,
url: update.url || this.url || void 0
});
}
};
var HttpErrorResponse = class extends HttpResponseBase {
constructor(init) {
super(init, 0, "Unknown Error");
this.name = "HttpErrorResponse";
this.ok = false;
if (this.status >= 200 && this.status < 300) {
this.message = `Http failure during parsing for ${init.url || "(unknown url)"}`;
} else {
this.message = `Http failure response for ${init.url || "(unknown url)"}: ${init.status} ${init.statusText}`;
}
this.error = init.error || null;
}
};
var HttpStatusCode;
(function(HttpStatusCode2) {
HttpStatusCode2[HttpStatusCode2["Continue"] = 100] = "Continue";
HttpStatusCode2[HttpStatusCode2["SwitchingProtocols"] = 101] = "SwitchingProtocols";
HttpStatusCode2[HttpStatusCode2["Processing"] = 102] = "Processing";
HttpStatusCode2[HttpStatusCode2["EarlyHints"] = 103] = "EarlyHints";
HttpStatusCode2[HttpStatusCode2["Ok"] = 200] = "Ok";
HttpStatusCode2[HttpStatusCode2["Created"] = 201] = "Created";
HttpStatusCode2[HttpStatusCode2["Accepted"] = 202] = "Accepted";
HttpStatusCode2[HttpStatusCode2["NonAuthoritativeInformation"] = 203] = "NonAuthoritativeInformation";
HttpStatusCode2[HttpStatusCode2["NoContent"] = 204] = "NoContent";
HttpStatusCode2[HttpStatusCode2["ResetContent"] = 205] = "ResetContent";
HttpStatusCode2[HttpStatusCode2["PartialContent"] = 206] = "PartialContent";
HttpStatusCode2[HttpStatusCode2["MultiStatus"] = 207] = "MultiStatus";
HttpStatusCode2[HttpStatusCode2["AlreadyReported"] = 208] = "AlreadyReported";
HttpStatusCode2[HttpStatusCode2["ImUsed"] = 226] = "ImUsed";
HttpStatusCode2[HttpStatusCode2["MultipleChoices"] = 300] = "MultipleChoices";
HttpStatusCode2[HttpStatusCode2["MovedPermanently"] = 301] = "MovedPermanently";
HttpStatusCode2[HttpStatusCode2["Found"] = 302] = "Found";
HttpStatusCode2[HttpStatusCode2["SeeOther"] = 303] = "SeeOther";
HttpStatusCode2[HttpStatusCode2["NotModified"] = 304] = "NotModified";
HttpStatusCode2[HttpStatusCode2["UseProxy"] = 305] = "UseProxy";
HttpStatusCode2[HttpStatusCode2["Unused"] = 306] = "Unused";
HttpStatusCode2[HttpStatusCode2["TemporaryRedirect"] = 307] = "TemporaryRedirect";
HttpStatusCode2[HttpStatusCode2["PermanentRedirect"] = 308] = "PermanentRedirect";
HttpStatusCode2[HttpStatusCode2["BadRequest"] = 400] = "BadRequest";
HttpStatusCode2[HttpStatusCode2["Unauthorized"] = 401] = "Unauthorized";
HttpStatusCode2[HttpStatusCode2["PaymentRequired"] = 402] = "PaymentRequired";
HttpStatusCode2[HttpStatusCode2["Forbidden"] = 403] = "Forbidden";
HttpStatusCode2[HttpStatusCode2["NotFound"] = 404] = "NotFound";
HttpStatusCode2[HttpStatusCode2["MethodNotAllowed"] = 405] = "MethodNotAllowed";
HttpStatusCode2[HttpStatusCode2["NotAcceptable"] = 406] = "NotAcceptable";
HttpStatusCode2[HttpStatusCode2["ProxyAuthenticationRequired"] = 407] = "ProxyAuthenticationRequired";
HttpStatusCode2[HttpStatusCode2["RequestTimeout"] = 408] = "RequestTimeout";
HttpStatusCode2[HttpStatusCode2["Conflict"] = 409] = "Conflict";
HttpStatusCode2[HttpStatusCode2["Gone"] = 410] = "Gone";
HttpStatusCode2[HttpStatusCode2["LengthRequired"] = 411] = "LengthRequired";
HttpStatusCode2[HttpStatusCode2["PreconditionFailed"] = 412] = "PreconditionFailed";
HttpStatusCode2[HttpStatusCode2["PayloadTooLarge"] = 413] = "PayloadTooLarge";
HttpStatusCode2[HttpStatusCode2["UriTooLong"] = 414] = "UriTooLong";
HttpStatusCode2[HttpStatusCode2["UnsupportedMediaType"] = 415] = "UnsupportedMediaType";
HttpStatusCode2[HttpStatusCode2["RangeNotSatisfiable"] = 416] = "RangeNotSatisfiable";
HttpStatusCode2[HttpStatusCode2["ExpectationFailed"] = 417] = "ExpectationFailed";
HttpStatusCode2[HttpStatusCode2["ImATeapot"] = 418] = "ImATeapot";
HttpStatusCode2[HttpStatusCode2["MisdirectedRequest"] = 421] = "MisdirectedRequest";
HttpStatusCode2[HttpStatusCode2["UnprocessableEntity"] = 422] = "UnprocessableEntity";
HttpStatusCode2[HttpStatusCode2["Locked"] = 423] = "Locked";
HttpStatusCode2[HttpStatusCode2["FailedDependency"] = 424] = "FailedDependency";
HttpStatusCode2[HttpStatusCode2["TooEarly"] = 425] = "TooEarly";
HttpStatusCode2[HttpStatusCode2["UpgradeRequired"] = 426] = "UpgradeRequired";
HttpStatusCode2[HttpStatusCode2["PreconditionRequired"] = 428] = "PreconditionRequired";
HttpStatusCode2[HttpStatusCode2["TooManyRequests"] = 429] = "TooManyRequests";
HttpStatusCode2[HttpStatusCode2["RequestHeaderFieldsTooLarge"] = 431] = "RequestHeaderFieldsTooLarge";
HttpStatusCode2[HttpStatusCode2["UnavailableForLegalReasons"] = 451] = "UnavailableForLegalReasons";
HttpStatusCode2[HttpStatusCode2["InternalServerError"] = 500] = "InternalServerError";
HttpStatusCode2[HttpStatusCode2["NotImplemented"] = 501] = "NotImplemented";
HttpStatusCode2[HttpStatusCode2["BadGateway"] = 502] = "BadGateway";
HttpStatusCode2[HttpStatusCode2["ServiceUnavailable"] = 503] = "ServiceUnavailable";
HttpStatusCode2[HttpStatusCode2["GatewayTimeout"] = 504] = "GatewayTimeout";
HttpStatusCode2[HttpStatusCode2["HttpVersionNotSupported"] = 505] = "HttpVersionNotSupported";
HttpStatusCode2[HttpStatusCode2["VariantAlsoNegotiates"] = 506] = "VariantAlsoNegotiates";
HttpStatusCode2[HttpStatusCode2["InsufficientStorage"] = 507] = "InsufficientStorage";
HttpStatusCode2[HttpStatusCode2["LoopDetected"] = 508] = "LoopDetected";
HttpStatusCode2[HttpStatusCode2["NotExtended"] = 510] = "NotExtended";
HttpStatusCode2[HttpStatusCode2["NetworkAuthenticationRequired"] = 511] = "NetworkAuthenticationRequired";
})(HttpStatusCode || (HttpStatusCode = {}));
function addBody(options, body) {
return {
body,
headers: options.headers,
context: options.context,
observe: options.observe,
params: options.params,
reportProgress: options.reportProgress,
responseType: options.responseType,
withCredentials: options.withCredentials,
transferCache: options.transferCache
};
}
var _HttpClient = class _HttpClient {
constructor(handler) {
this.handler = handler;
}
/**
* Constructs an observable for a generic HTTP request that, when subscribed,
* fires the request through the chain of registered interceptors and on to the
* server.
*
* You can pass an `HttpRequest` directly as the only parameter. In this case,
* the call returns an observable of the raw `HttpEvent` stream.
*
* Alternatively you can pass an HTTP method as the first parameter,
* a URL string as the second, and an options hash containing the request body as the third.
* See `addBody()`. In this case, the specified `responseType` and `observe` options determine the
* type of returned observable.
* * The `responseType` value determines how a successful response body is parsed.
* * If `responseType` is the default `json`, you can pass a type interface for the resulting
* object as a type parameter to the call.
*
* The `observe` value determines the return type, according to what you are interested in
* observing.
* * An `observe` value of events returns an observable of the raw `HttpEvent` stream, including
* progress events by default.
* * An `observe` value of response returns an observable of `HttpResponse<T>`,
* where the `T` parameter depends on the `responseType` and any optionally provided type
* parameter.
* * An `observe` value of body returns an observable of `<T>` with the same `T` body type.
*
*/
request(first2, url, options = {}) {
let req;
if (first2 instanceof HttpRequest) {
req = first2;
} else {
let headers = void 0;
if (options.headers instanceof HttpHeaders) {
headers = options.headers;
} else {
headers = new HttpHeaders(options.headers);
}
let params = void 0;
if (!!options.params) {
if (options.params instanceof HttpParams) {
params = options.params;
} else {
params = new HttpParams({
fromObject: options.params
});
}
}
req = new HttpRequest(first2, url, options.body !== void 0 ? options.body : null, {
headers,
context: options.context,
params,
reportProgress: options.reportProgress,
// By default, JSON is assumed to be returned for all calls.
responseType: options.responseType || "json",
withCredentials: options.withCredentials,
transferCache: options.transferCache
});
}
const events$ = of(req).pipe(concatMap((req2) => this.handler.handle(req2)));
if (first2 instanceof HttpRequest || options.observe === "events") {
return events$;
}
const res$ = events$.pipe(filter((event) => event instanceof HttpResponse));
switch (options.observe || "body") {
case "body":
switch (req.responseType) {
case "arraybuffer":
return res$.pipe(map((res) => {
if (res.body !== null && !(res.body instanceof ArrayBuffer)) {
throw new Error("Response is not an ArrayBuffer.");
}
return res.body;
}));
case "blob":
return res$.pipe(map((res) => {
if (res.body !== null && !(res.body instanceof Blob)) {
throw new Error("Response is not a Blob.");
}
return res.body;
}));
case "text":
return res$.pipe(map((res) => {
if (res.body !== null && typeof res.body !== "string") {
throw new Error("Response is not a string.");
}
return res.body;
}));
case "json":
default:
return res$.pipe(map((res) => res.body));
}
case "response":
return res$;
default:
throw new Error(`Unreachable: unhandled observe type ${options.observe}}`);
}
}
/**
* Constructs an observable that, when subscribed, causes the configured
* `DELETE` request to execute on the server. See the individual overloads for
* details on the return type.
*
* @param url The endpoint URL.
* @param options The HTTP options to send with the request.
*
*/
delete(url, options = {}) {
return this.request("DELETE", url, options);
}
/**
* Constructs an observable that, when subscribed, causes the configured
* `GET` request to execute on the server. See the individual overloads for
* details on the return type.
*/
get(url, options = {}) {
return this.request("GET", url, options);
}
/**
* Constructs an observable that, when subscribed, causes the configured
* `HEAD` request to execute on the server. The `HEAD` method returns
* meta information about the resource without transferring the
* resource itself. See the individual overloads for
* details on the return type.
*/
head(url, options = {}) {
return this.request("HEAD", url, options);
}
/**
* Constructs an `Observable` that, when subscribed, causes a request with the special method
* `JSONP` to be dispatched via the interceptor pipeline.
* The [JSONP pattern](https://en.wikipedia.org/wiki/JSONP) works around limitations of certain
* API endpoints that don't support newer,
* and preferable [CORS](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS) protocol.
* JSONP treats the endpoint API as a JavaScript file and tricks the browser to process the
* requests even if the API endpoint is not located on the same domain (origin) as the client-side
* application making the request.
* The endpoint API must support JSONP callback for JSONP requests to work.
* The resource API returns the JSON response wrapped in a callback function.
* You can pass the callback function name as one of the query parameters.
* Note that JSONP requests can only be used with `GET` requests.
*
* @param url The resource URL.
* @param callbackParam The callback function name.
*
*/
jsonp(url, callbackParam) {
return this.request("JSONP", url, {
params: new HttpParams().append(callbackParam, "JSONP_CALLBACK"),
observe: "body",
responseType: "json"
});
}
/**
* Constructs an `Observable` that, when subscribed, causes the configured
* `OPTIONS` request to execute on the server. This method allows the client
* to determine the supported HTTP methods and other capabilities of an endpoint,
* without implying a resource action. See the individual overloads for
* details on the return type.
*/
options(url, options = {}) {
return this.request("OPTIONS", url, options);
}
/**
* Constructs an observable that, when subscribed, causes the configured
* `PATCH` request to execute on the server. See the individual overloads for
* details on the return type.
*/
patch(url, body, options = {}) {
return this.request("PATCH", url, addBody(options, body));
}
/**
* Constructs an observable that, when subscribed, causes the configured
* `POST` request to execute on the server. The server responds with the location of
* the replaced resource. See the individual overloads for
* details on the return type.
*/
post(url, body, options = {}) {
return this.request("POST", url, addBody(options, body));
}
/**
* Constructs an observable that, when subscribed, causes the configured
* `PUT` request to execute on the server. The `PUT` method replaces an existing resource
* with a new set of values.
* See the individual overloads for details on the return type.
*/
put(url, body, options = {}) {
return this.request("PUT", url, addBody(options, body));
}
};
_HttpClient.\u0275fac = function HttpClient_Factory(t) {
return new (t || _HttpClient)(\u0275\u0275inject(HttpHandler));
};
_HttpClient.\u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
token: _HttpClient,
factory: _HttpClient.\u0275fac
});
var HttpClient = _HttpClient;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(HttpClient, [{
type: Injectable
}], () => [{
type: HttpHandler
}], null);
})();
var XSSI_PREFIX$1 = /^\)\]\}',?\n/;
var REQUEST_URL_HEADER = `X-Request-URL`;
function getResponseUrl$1(response) {
if (response.url) {
return response.url;
}
const xRequestUrl = REQUEST_URL_HEADER.toLocaleLowerCase();
return response.headers.get(xRequestUrl);
}
var _FetchBackend = class _FetchBackend {
constructor() {
this.fetchImpl = inject(FetchFactory, {
optional: true
})?.fetch ?? fetch.bind(globalThis);
this.ngZone = inject(NgZone);
}
handle(request) {
return new Observable((observer) => {
const aborter = new AbortController();
this.doRequest(request, aborter.signal, observer).then(noop3, (error) => observer.error(new HttpErrorResponse({
error
})));
return () => aborter.abort();
});
}
doRequest(request, signal2, observer) {
return __async(this, null, function* () {
const init = this.createRequestInit(request);
let response;
try {
const fetchPromise = this.fetchImpl(request.urlWithParams, __spreadValues({
signal: signal2
}, init));
silenceSuperfluousUnhandledPromiseRejection(fetchPromise);
observer.next({
type: HttpEventType.Sent
});
response = yield fetchPromise;
} catch (error) {
observer.error(new HttpErrorResponse({
error,
status: error.status ?? 0,
statusText: error.statusText,
url: request.urlWithParams,
headers: error.headers
}));
return;
}
const headers = new HttpHeaders(response.headers);
const statusText = response.statusText;
const url = getResponseUrl$1(response) ?? request.urlWithParams;
let status = response.status;
let body = null;
if (request.reportProgress) {
observer.next(new HttpHeaderResponse({
headers,
status,
statusText,
url
}));
}
if (response.body) {
const contentLength = response.headers.get("content-length");
const chunks = [];
const reader = response.body.getReader();
let receivedLength = 0;
let decoder;
let partialText;
const reqZone = typeof Zone !== "undefined" && Zone.current;
yield this.ngZone.runOutsideAngular(() => __async(this, null, function* () {
while (true) {
const {
done,
value: value2
} = yield reader.read();
if (done) {
break;
}
chunks.push(value2);
receivedLength += value2.length;
if (request.reportProgress) {
partialText = request.responseType === "text" ? (partialText ?? "") + (decoder ??= new TextDecoder()).decode(value2, {
stream: true
}) : void 0;
const reportProgress = () => observer.next({
type: HttpEventType.DownloadProgress,
total: contentLength ? +contentLength : void 0,
loaded: receivedLength,
partialText
});
reqZone ? reqZone.run(reportProgress) : reportProgress();
}
}
}));
const chunksAll = this.concatChunks(chunks, receivedLength);
try {
const contentType = response.headers.get("Content-Type") ?? "";
body = this.parseBody(request, chunksAll, contentType);
} catch (error) {
observer.error(new HttpErrorResponse({
error,
headers: new HttpHeaders(response.headers),
status: response.status,
statusText: response.statusText,
url: getResponseUrl$1(response) ?? request.urlWithParams
}));
return;
}
}
if (status === 0) {
status = body ? HttpStatusCode.Ok : 0;
}
const ok = status >= 200 && status < 300;
if (ok) {
observer.next(new HttpResponse({
body,
headers,
status,
statusText,
url
}));
observer.complete();
} else {
observer.error(new HttpErrorResponse({
error: body,
headers,
status,
statusText,
url
}));
}
});
}
parseBody(request, binContent, contentType) {
switch (request.responseType) {
case "json":
const text2 = new TextDecoder().decode(binContent).replace(XSSI_PREFIX$1, "");
return text2 === "" ? null : JSON.parse(text2);
case "text":
return new TextDecoder().decode(binContent);
case "blob":
return new Blob([binContent], {
type: contentType
});
case "arraybuffer":
return binContent.buffer;
}
}
createRequestInit(req) {
const headers = {};
const credentials = req.withCredentials ? "include" : void 0;
req.headers.forEach((name2, values) => headers[name2] = values.join(","));
headers["Accept"] ??= "application/json, text/plain, */*";
if (!headers["Content-Type"]) {
const detectedType = req.detectContentTypeHeader();
if (detectedType !== null) {
headers["Content-Type"] = detectedType;
}
}
return {
body: req.serializeBody(),
method: req.method,
headers,
credentials
};
}
concatChunks(chunks, totalLength) {
const chunksAll = new Uint8Array(totalLength);
let position2 = 0;
for (const chunk of chunks) {
chunksAll.set(chunk, position2);
position2 += chunk.length;
}
return chunksAll;
}
};
_FetchBackend.\u0275fac = function FetchBackend_Factory(t) {
return new (t || _FetchBackend)();
};
_FetchBackend.\u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
token: _FetchBackend,
factory: _FetchBackend.\u0275fac
});
var FetchBackend = _FetchBackend;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(FetchBackend, [{
type: Injectable
}], null, null);
})();
var FetchFactory = class {
};
function noop3() {
}
function silenceSuperfluousUnhandledPromiseRejection(promise) {
promise.then(noop3, noop3);
}
function interceptorChainEndFn(req, finalHandlerFn) {
return finalHandlerFn(req);
}
function adaptLegacyInterceptorToChain(chainTailFn, interceptor) {
return (initialRequest, finalHandlerFn) => interceptor.intercept(initialRequest, {
handle: (downstreamRequest) => chainTailFn(downstreamRequest, finalHandlerFn)
});
}
function chainedInterceptorFn(chainTailFn, interceptorFn, injector) {
return (initialRequest, finalHandlerFn) => runInInjectionContext(injector, () => interceptorFn(initialRequest, (downstreamRequest) => chainTailFn(downstreamRequest, finalHandlerFn)));
}
var HTTP_INTERCEPTORS = new InjectionToken(ngDevMode ? "HTTP_INTERCEPTORS" : "");
var HTTP_INTERCEPTOR_FNS = new InjectionToken(ngDevMode ? "HTTP_INTERCEPTOR_FNS" : "");
var HTTP_ROOT_INTERCEPTOR_FNS = new InjectionToken(ngDevMode ? "HTTP_ROOT_INTERCEPTOR_FNS" : "");
var PRIMARY_HTTP_BACKEND = new InjectionToken(ngDevMode ? "PRIMARY_HTTP_BACKEND" : "");
function legacyInterceptorFnFactory() {
let chain = null;
return (req, handler) => {
if (chain === null) {
const interceptors = inject(HTTP_INTERCEPTORS, {
optional: true
}) ?? [];
chain = interceptors.reduceRight(adaptLegacyInterceptorToChain, interceptorChainEndFn);
}
const pendingTasks = inject(PendingTasks);
const taskId = pendingTasks.add();
return chain(req, handler).pipe(finalize(() => pendingTasks.remove(taskId)));
};
}
var fetchBackendWarningDisplayed = false;
var _HttpInterceptorHandler = class _HttpInterceptorHandler extends HttpHandler {
constructor(backend, injector) {
super();
this.backend = backend;
this.injector = injector;
this.chain = null;
this.pendingTasks = inject(PendingTasks);
const primaryHttpBackend = inject(PRIMARY_HTTP_BACKEND, {
optional: true
});
this.backend = primaryHttpBackend ?? backend;
if ((typeof ngDevMode === "undefined" || ngDevMode) && !fetchBackendWarningDisplayed) {
const isServer = isPlatformServer(injector.get(PLATFORM_ID));
if (isServer && !(this.backend instanceof FetchBackend)) {
fetchBackendWarningDisplayed = true;
injector.get(Console).warn(formatRuntimeError(2801, "Angular detected that `HttpClient` is not configured to use `fetch` APIs. It's strongly recommended to enable `fetch` for applications that use Server-Side Rendering for better performance and compatibility. To enable `fetch`, add the `withFetch()` to the `provideHttpClient()` call at the root of the application."));
}
}
}
handle(initialRequest) {
if (this.chain === null) {
const dedupedInterceptorFns = Array.from(/* @__PURE__ */ new Set([...this.injector.get(HTTP_INTERCEPTOR_FNS), ...this.injector.get(HTTP_ROOT_INTERCEPTOR_FNS, [])]));
this.chain = dedupedInterceptorFns.reduceRight((nextSequencedFn, interceptorFn) => chainedInterceptorFn(nextSequencedFn, interceptorFn, this.injector), interceptorChainEndFn);
}
const taskId = this.pendingTasks.add();
return this.chain(initialRequest, (downstreamRequest) => this.backend.handle(downstreamRequest)).pipe(finalize(() => this.pendingTasks.remove(taskId)));
}
};
_HttpInterceptorHandler.\u0275fac = function HttpInterceptorHandler_Factory(t) {
return new (t || _HttpInterceptorHandler)(\u0275\u0275inject(HttpBackend), \u0275\u0275inject(EnvironmentInjector));
};
_HttpInterceptorHandler.\u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
token: _HttpInterceptorHandler,
factory: _HttpInterceptorHandler.\u0275fac
});
var HttpInterceptorHandler = _HttpInterceptorHandler;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(HttpInterceptorHandler, [{
type: Injectable
}], () => [{
type: HttpBackend
}, {
type: EnvironmentInjector
}], null);
})();
var nextRequestId = 0;
var foreignDocument;
var JSONP_ERR_NO_CALLBACK = "JSONP injected script did not invoke callback.";
var JSONP_ERR_WRONG_METHOD = "JSONP requests must use JSONP request method.";
var JSONP_ERR_WRONG_RESPONSE_TYPE = "JSONP requests must use Json response type.";
var JSONP_ERR_HEADERS_NOT_SUPPORTED = "JSONP requests do not support headers.";
var JsonpCallbackContext = class {
};
function jsonpCallbackContext() {
if (typeof window === "object") {
return window;
}
return {};
}
var _JsonpClientBackend = class _JsonpClientBackend {
constructor(callbackMap, document2) {
this.callbackMap = callbackMap;
this.document = document2;
this.resolvedPromise = Promise.resolve();
}
/**
* Get the name of the next callback method, by incrementing the global `nextRequestId`.
*/
nextCallback() {
return `ng_jsonp_callback_${nextRequestId++}`;
}
/**
* Processes a JSONP request and returns an event stream of the results.
* @param req The request object.
* @returns An observable of the response events.
*
*/
handle(req) {
if (req.method !== "JSONP") {
throw new Error(JSONP_ERR_WRONG_METHOD);
} else if (req.responseType !== "json") {
throw new Error(JSONP_ERR_WRONG_RESPONSE_TYPE);
}
if (req.headers.keys().length > 0) {
throw new Error(JSONP_ERR_HEADERS_NOT_SUPPORTED);
}
return new Observable((observer) => {
const callback = this.nextCallback();
const url = req.urlWithParams.replace(/=JSONP_CALLBACK(&|$)/, `=${callback}$1`);
const node = this.document.createElement("script");
node.src = url;
let body = null;
let finished = false;
this.callbackMap[callback] = (data2) => {
delete this.callbackMap[callback];
body = data2;
finished = true;
};
const cleanup = () => {
if (node.parentNode) {
node.parentNode.removeChild(node);
}
delete this.callbackMap[callback];
};
const onLoad = (event) => {
this.resolvedPromise.then(() => {
cleanup();
if (!finished) {
observer.error(new HttpErrorResponse({
url,
status: 0,
statusText: "JSONP Error",
error: new Error(JSONP_ERR_NO_CALLBACK)
}));
return;
}
observer.next(new HttpResponse({
body,
status: HttpStatusCode.Ok,
statusText: "OK",
url
}));
observer.complete();
});
};
const onError = (error) => {
cleanup();
observer.error(new HttpErrorResponse({
error,
status: 0,
statusText: "JSONP Error",
url
}));
};
node.addEventListener("load", onLoad);
node.addEventListener("error", onError);
this.document.body.appendChild(node);
observer.next({
type: HttpEventType.Sent
});
return () => {
if (!finished) {
this.removeListeners(node);
}
cleanup();
};
});
}
removeListeners(script) {
foreignDocument ??= this.document.implementation.createHTMLDocument();
foreignDocument.adoptNode(script);
}
};
_JsonpClientBackend.\u0275fac = function JsonpClientBackend_Factory(t) {
return new (t || _JsonpClientBackend)(\u0275\u0275inject(JsonpCallbackContext), \u0275\u0275inject(DOCUMENT2));
};
_JsonpClientBackend.\u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
token: _JsonpClientBackend,
factory: _JsonpClientBackend.\u0275fac
});
var JsonpClientBackend = _JsonpClientBackend;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(JsonpClientBackend, [{
type: Injectable
}], () => [{
type: JsonpCallbackContext
}, {
type: void 0,
decorators: [{
type: Inject,
args: [DOCUMENT2]
}]
}], null);
})();
function jsonpInterceptorFn(req, next) {
if (req.method === "JSONP") {
return inject(JsonpClientBackend).handle(req);
}
return next(req);
}
var _JsonpInterceptor = class _JsonpInterceptor {
constructor(injector) {
this.injector = injector;
}
/**
* Identifies and handles a given JSONP request.
* @param initialRequest The outgoing request object to handle.
* @param next The next interceptor in the chain, or the backend
* if no interceptors remain in the chain.
* @returns An observable of the event stream.
*/
intercept(initialRequest, next) {
return runInInjectionContext(this.injector, () => jsonpInterceptorFn(initialRequest, (downstreamRequest) => next.handle(downstreamRequest)));
}
};
_JsonpInterceptor.\u0275fac = function JsonpInterceptor_Factory(t) {
return new (t || _JsonpInterceptor)(\u0275\u0275inject(EnvironmentInjector));
};
_JsonpInterceptor.\u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
token: _JsonpInterceptor,
factory: _JsonpInterceptor.\u0275fac
});
var JsonpInterceptor = _JsonpInterceptor;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(JsonpInterceptor, [{
type: Injectable
}], () => [{
type: EnvironmentInjector
}], null);
})();
var XSSI_PREFIX = /^\)\]\}',?\n/;
function getResponseUrl(xhr) {
if ("responseURL" in xhr && xhr.responseURL) {
return xhr.responseURL;
}
if (/^X-Request-URL:/m.test(xhr.getAllResponseHeaders())) {
return xhr.getResponseHeader("X-Request-URL");
}
return null;
}
var _HttpXhrBackend = class _HttpXhrBackend {
constructor(xhrFactory) {
this.xhrFactory = xhrFactory;
}
/**
* Processes a request and returns a stream of response events.
* @param req The request object.
* @returns An observable of the response events.
*/
handle(req) {
if (req.method === "JSONP") {
throw new RuntimeError(-2800, (typeof ngDevMode === "undefined" || ngDevMode) && `Cannot make a JSONP request without JSONP support. To fix the problem, either add the \`withJsonpSupport()\` call (if \`provideHttpClient()\` is used) or import the \`HttpClientJsonpModule\` in the root NgModule.`);
}
const xhrFactory = this.xhrFactory;
const source = xhrFactory.\u0275loadImpl ? from(xhrFactory.\u0275loadImpl()) : of(null);
return source.pipe(switchMap(() => {
return new Observable((observer) => {
const xhr = xhrFactory.build();
xhr.open(req.method, req.urlWithParams);
if (req.withCredentials) {
xhr.withCredentials = true;
}
req.headers.forEach((name2, values) => xhr.setRequestHeader(name2, values.join(",")));
if (!req.headers.has("Accept")) {
xhr.setRequestHeader("Accept", "application/json, text/plain, */*");
}
if (!req.headers.has("Content-Type")) {
const detectedType = req.detectContentTypeHeader();
if (detectedType !== null) {
xhr.setRequestHeader("Content-Type", detectedType);
}
}
if (req.responseType) {
const responseType = req.responseType.toLowerCase();
xhr.responseType = responseType !== "json" ? responseType : "text";
}
const reqBody = req.serializeBody();
let headerResponse = null;
const partialFromXhr = () => {
if (headerResponse !== null) {
return headerResponse;
}
const statusText = xhr.statusText || "OK";
const headers = new HttpHeaders(xhr.getAllResponseHeaders());
const url = getResponseUrl(xhr) || req.url;
headerResponse = new HttpHeaderResponse({
headers,
status: xhr.status,
statusText,
url
});
return headerResponse;
};
const onLoad = () => {
let {
headers,
status,
statusText,
url
} = partialFromXhr();
let body = null;
if (status !== HttpStatusCode.NoContent) {
body = typeof xhr.response === "undefined" ? xhr.responseText : xhr.response;
}
if (status === 0) {
status = !!body ? HttpStatusCode.Ok : 0;
}
let ok = status >= 200 && status < 300;
if (req.responseType === "json" && typeof body === "string") {
const originalBody = body;
body = body.replace(XSSI_PREFIX, "");
try {
body = body !== "" ? JSON.parse(body) : null;
} catch (error) {
body = originalBody;
if (ok) {
ok = false;
body = {
error,
text: body
};
}
}
}
if (ok) {
observer.next(new HttpResponse({
body,
headers,
status,
statusText,
url: url || void 0
}));
observer.complete();
} else {
observer.error(new HttpErrorResponse({
// The error in this case is the response body (error from the server).
error: body,
headers,
status,
statusText,
url: url || void 0
}));
}
};
const onError = (error) => {
const {
url
} = partialFromXhr();
const res = new HttpErrorResponse({
error,
status: xhr.status || 0,
statusText: xhr.statusText || "Unknown Error",
url: url || void 0
});
observer.error(res);
};
let sentHeaders = false;
const onDownProgress = (event) => {
if (!sentHeaders) {
observer.next(partialFromXhr());
sentHeaders = true;
}
let progressEvent = {
type: HttpEventType.DownloadProgress,
loaded: event.loaded
};
if (event.lengthComputable) {
progressEvent.total = event.total;
}
if (req.responseType === "text" && !!xhr.responseText) {
progressEvent.partialText = xhr.responseText;
}
observer.next(progressEvent);
};
const onUpProgress = (event) => {
let progress = {
type: HttpEventType.UploadProgress,
loaded: event.loaded
};
if (event.lengthComputable) {
progress.total = event.total;
}
observer.next(progress);
};
xhr.addEventListener("load", onLoad);
xhr.addEventListener("error", onError);
xhr.addEventListener("timeout", onError);
xhr.addEventListener("abort", onError);
if (req.reportProgress) {
xhr.addEventListener("progress", onDownProgress);
if (reqBody !== null && xhr.upload) {
xhr.upload.addEventListener("progress", onUpProgress);
}
}
xhr.send(reqBody);
observer.next({
type: HttpEventType.Sent
});
return () => {
xhr.removeEventListener("error", onError);
xhr.removeEventListener("abort", onError);
xhr.removeEventListener("load", onLoad);
xhr.removeEventListener("timeout", onError);
if (req.reportProgress) {
xhr.removeEventListener("progress", onDownProgress);
if (reqBody !== null && xhr.upload) {
xhr.upload.removeEventListener("progress", onUpProgress);
}
}
if (xhr.readyState !== xhr.DONE) {
xhr.abort();
}
};
});
}));
}
};
_HttpXhrBackend.\u0275fac = function HttpXhrBackend_Factory(t) {
return new (t || _HttpXhrBackend)(\u0275\u0275inject(XhrFactory));
};
_HttpXhrBackend.\u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
token: _HttpXhrBackend,
factory: _HttpXhrBackend.\u0275fac
});
var HttpXhrBackend = _HttpXhrBackend;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(HttpXhrBackend, [{
type: Injectable
}], () => [{
type: XhrFactory
}], null);
})();
var XSRF_ENABLED = new InjectionToken(ngDevMode ? "XSRF_ENABLED" : "");
var XSRF_DEFAULT_COOKIE_NAME = "XSRF-TOKEN";
var XSRF_COOKIE_NAME = new InjectionToken(ngDevMode ? "XSRF_COOKIE_NAME" : "", {
providedIn: "root",
factory: () => XSRF_DEFAULT_COOKIE_NAME
});
var XSRF_DEFAULT_HEADER_NAME = "X-XSRF-TOKEN";
var XSRF_HEADER_NAME = new InjectionToken(ngDevMode ? "XSRF_HEADER_NAME" : "", {
providedIn: "root",
factory: () => XSRF_DEFAULT_HEADER_NAME
});
var HttpXsrfTokenExtractor = class {
};
var _HttpXsrfCookieExtractor = class _HttpXsrfCookieExtractor {
constructor(doc, platform, cookieName) {
this.doc = doc;
this.platform = platform;
this.cookieName = cookieName;
this.lastCookieString = "";
this.lastToken = null;
this.parseCount = 0;
}
getToken() {
if (this.platform === "server") {
return null;
}
const cookieString = this.doc.cookie || "";
if (cookieString !== this.lastCookieString) {
this.parseCount++;
this.lastToken = parseCookieValue(cookieString, this.cookieName);
this.lastCookieString = cookieString;
}
return this.lastToken;
}
};
_HttpXsrfCookieExtractor.\u0275fac = function HttpXsrfCookieExtractor_Factory(t) {
return new (t || _HttpXsrfCookieExtractor)(\u0275\u0275inject(DOCUMENT2), \u0275\u0275inject(PLATFORM_ID), \u0275\u0275inject(XSRF_COOKIE_NAME));
};
_HttpXsrfCookieExtractor.\u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
token: _HttpXsrfCookieExtractor,
factory: _HttpXsrfCookieExtractor.\u0275fac
});
var HttpXsrfCookieExtractor = _HttpXsrfCookieExtractor;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(HttpXsrfCookieExtractor, [{
type: Injectable
}], () => [{
type: void 0,
decorators: [{
type: Inject,
args: [DOCUMENT2]
}]
}, {
type: void 0,
decorators: [{
type: Inject,
args: [PLATFORM_ID]
}]
}, {
type: void 0,
decorators: [{
type: Inject,
args: [XSRF_COOKIE_NAME]
}]
}], null);
})();
function xsrfInterceptorFn(req, next) {
const lcUrl = req.url.toLowerCase();
if (!inject(XSRF_ENABLED) || req.method === "GET" || req.method === "HEAD" || lcUrl.startsWith("http://") || lcUrl.startsWith("https://")) {
return next(req);
}
const token = inject(HttpXsrfTokenExtractor).getToken();
const headerName = inject(XSRF_HEADER_NAME);
if (token != null && !req.headers.has(headerName)) {
req = req.clone({
headers: req.headers.set(headerName, token)
});
}
return next(req);
}
var _HttpXsrfInterceptor = class _HttpXsrfInterceptor {
constructor(injector) {
this.injector = injector;
}
intercept(initialRequest, next) {
return runInInjectionContext(this.injector, () => xsrfInterceptorFn(initialRequest, (downstreamRequest) => next.handle(downstreamRequest)));
}
};
_HttpXsrfInterceptor.\u0275fac = function HttpXsrfInterceptor_Factory(t) {
return new (t || _HttpXsrfInterceptor)(\u0275\u0275inject(EnvironmentInjector));
};
_HttpXsrfInterceptor.\u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
token: _HttpXsrfInterceptor,
factory: _HttpXsrfInterceptor.\u0275fac
});
var HttpXsrfInterceptor = _HttpXsrfInterceptor;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(HttpXsrfInterceptor, [{
type: Injectable
}], () => [{
type: EnvironmentInjector
}], null);
})();
var HttpFeatureKind;
(function(HttpFeatureKind2) {
HttpFeatureKind2[HttpFeatureKind2["Interceptors"] = 0] = "Interceptors";
HttpFeatureKind2[HttpFeatureKind2["LegacyInterceptors"] = 1] = "LegacyInterceptors";
HttpFeatureKind2[HttpFeatureKind2["CustomXsrfConfiguration"] = 2] = "CustomXsrfConfiguration";
HttpFeatureKind2[HttpFeatureKind2["NoXsrfProtection"] = 3] = "NoXsrfProtection";
HttpFeatureKind2[HttpFeatureKind2["JsonpSupport"] = 4] = "JsonpSupport";
HttpFeatureKind2[HttpFeatureKind2["RequestsMadeViaParent"] = 5] = "RequestsMadeViaParent";
HttpFeatureKind2[HttpFeatureKind2["Fetch"] = 6] = "Fetch";
})(HttpFeatureKind || (HttpFeatureKind = {}));
function makeHttpFeature(kind, providers) {
return {
\u0275kind: kind,
\u0275providers: providers
};
}
function provideHttpClient(...features) {
if (ngDevMode) {
const featureKinds = new Set(features.map((f) => f.\u0275kind));
if (featureKinds.has(HttpFeatureKind.NoXsrfProtection) && featureKinds.has(HttpFeatureKind.CustomXsrfConfiguration)) {
throw new Error(ngDevMode ? `Configuration error: found both withXsrfConfiguration() and withNoXsrfProtection() in the same call to provideHttpClient(), which is a contradiction.` : "");
}
}
const providers = [HttpClient, HttpXhrBackend, HttpInterceptorHandler, {
provide: HttpHandler,
useExisting: HttpInterceptorHandler
}, {
provide: HttpBackend,
useExisting: HttpXhrBackend
}, {
provide: HTTP_INTERCEPTOR_FNS,
useValue: xsrfInterceptorFn,
multi: true
}, {
provide: XSRF_ENABLED,
useValue: true
}, {
provide: HttpXsrfTokenExtractor,
useClass: HttpXsrfCookieExtractor
}];
for (const feature of features) {
providers.push(...feature.\u0275providers);
}
return makeEnvironmentProviders(providers);
}
function withInterceptors(interceptorFns) {
return makeHttpFeature(HttpFeatureKind.Interceptors, interceptorFns.map((interceptorFn) => {
return {
provide: HTTP_INTERCEPTOR_FNS,
useValue: interceptorFn,
multi: true
};
}));
}
var LEGACY_INTERCEPTOR_FN = new InjectionToken(ngDevMode ? "LEGACY_INTERCEPTOR_FN" : "");
function withInterceptorsFromDi() {
return makeHttpFeature(HttpFeatureKind.LegacyInterceptors, [{
provide: LEGACY_INTERCEPTOR_FN,
useFactory: legacyInterceptorFnFactory
}, {
provide: HTTP_INTERCEPTOR_FNS,
useExisting: LEGACY_INTERCEPTOR_FN,
multi: true
}]);
}
function withXsrfConfiguration({
cookieName,
headerName
}) {
const providers = [];
if (cookieName !== void 0) {
providers.push({
provide: XSRF_COOKIE_NAME,
useValue: cookieName
});
}
if (headerName !== void 0) {
providers.push({
provide: XSRF_HEADER_NAME,
useValue: headerName
});
}
return makeHttpFeature(HttpFeatureKind.CustomXsrfConfiguration, providers);
}
function withNoXsrfProtection() {
return makeHttpFeature(HttpFeatureKind.NoXsrfProtection, [{
provide: XSRF_ENABLED,
useValue: false
}]);
}
function withJsonpSupport() {
return makeHttpFeature(HttpFeatureKind.JsonpSupport, [JsonpClientBackend, {
provide: JsonpCallbackContext,
useFactory: jsonpCallbackContext
}, {
provide: HTTP_INTERCEPTOR_FNS,
useValue: jsonpInterceptorFn,
multi: true
}]);
}
var _HttpClientXsrfModule = class _HttpClientXsrfModule {
/**
* Disable the default XSRF protection.
*/
static disable() {
return {
ngModule: _HttpClientXsrfModule,
providers: [withNoXsrfProtection().\u0275providers]
};
}
/**
* Configure XSRF protection.
* @param options An object that can specify either or both
* cookie name or header name.
* - Cookie name default is `XSRF-TOKEN`.
* - Header name default is `X-XSRF-TOKEN`.
*
*/
static withOptions(options = {}) {
return {
ngModule: _HttpClientXsrfModule,
providers: withXsrfConfiguration(options).\u0275providers
};
}
};
_HttpClientXsrfModule.\u0275fac = function HttpClientXsrfModule_Factory(t) {
return new (t || _HttpClientXsrfModule)();
};
_HttpClientXsrfModule.\u0275mod = /* @__PURE__ */ \u0275\u0275defineNgModule({
type: _HttpClientXsrfModule
});
_HttpClientXsrfModule.\u0275inj = /* @__PURE__ */ \u0275\u0275defineInjector({
providers: [HttpXsrfInterceptor, {
provide: HTTP_INTERCEPTORS,
useExisting: HttpXsrfInterceptor,
multi: true
}, {
provide: HttpXsrfTokenExtractor,
useClass: HttpXsrfCookieExtractor
}, withXsrfConfiguration({
cookieName: XSRF_DEFAULT_COOKIE_NAME,
headerName: XSRF_DEFAULT_HEADER_NAME
}).\u0275providers, {
provide: XSRF_ENABLED,
useValue: true
}]
});
var HttpClientXsrfModule = _HttpClientXsrfModule;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(HttpClientXsrfModule, [{
type: NgModule,
args: [{
providers: [HttpXsrfInterceptor, {
provide: HTTP_INTERCEPTORS,
useExisting: HttpXsrfInterceptor,
multi: true
}, {
provide: HttpXsrfTokenExtractor,
useClass: HttpXsrfCookieExtractor
}, withXsrfConfiguration({
cookieName: XSRF_DEFAULT_COOKIE_NAME,
headerName: XSRF_DEFAULT_HEADER_NAME
}).\u0275providers, {
provide: XSRF_ENABLED,
useValue: true
}]
}]
}], null, null);
})();
var _HttpClientModule = class _HttpClientModule {
};
_HttpClientModule.\u0275fac = function HttpClientModule_Factory(t) {
return new (t || _HttpClientModule)();
};
_HttpClientModule.\u0275mod = /* @__PURE__ */ \u0275\u0275defineNgModule({
type: _HttpClientModule
});
_HttpClientModule.\u0275inj = /* @__PURE__ */ \u0275\u0275defineInjector({
providers: [provideHttpClient(withInterceptorsFromDi())]
});
var HttpClientModule = _HttpClientModule;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(HttpClientModule, [{
type: NgModule,
args: [{
/**
* Configures the [dependency injector](guide/glossary#injector) where it is imported
* with supporting services for HTTP communications.
*/
providers: [provideHttpClient(withInterceptorsFromDi())]
}]
}], null, null);
})();
var _HttpClientJsonpModule = class _HttpClientJsonpModule {
};
_HttpClientJsonpModule.\u0275fac = function HttpClientJsonpModule_Factory(t) {
return new (t || _HttpClientJsonpModule)();
};
_HttpClientJsonpModule.\u0275mod = /* @__PURE__ */ \u0275\u0275defineNgModule({
type: _HttpClientJsonpModule
});
_HttpClientJsonpModule.\u0275inj = /* @__PURE__ */ \u0275\u0275defineInjector({
providers: [withJsonpSupport().\u0275providers]
});
var HttpClientJsonpModule = _HttpClientJsonpModule;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(HttpClientJsonpModule, [{
type: NgModule,
args: [{
providers: [withJsonpSupport().\u0275providers]
}]
}], null, null);
})();
var CACHE_OPTIONS = new InjectionToken(ngDevMode ? "HTTP_TRANSFER_STATE_CACHE_OPTIONS" : "");
// node_modules/@angular/platform-browser/fesm2022/platform-browser.mjs
var GenericBrowserDomAdapter = class extends DomAdapter {
constructor() {
super(...arguments);
this.supportsDOMEvents = true;
}
};
var BrowserDomAdapter = class _BrowserDomAdapter extends GenericBrowserDomAdapter {
static makeCurrent() {
setRootDomAdapter(new _BrowserDomAdapter());
}
onAndCancel(el, evt, listener) {
el.addEventListener(evt, listener);
return () => {
el.removeEventListener(evt, listener);
};
}
dispatchEvent(el, evt) {
el.dispatchEvent(evt);
}
remove(node) {
if (node.parentNode) {
node.parentNode.removeChild(node);
}
}
createElement(tagName, doc) {
doc = doc || this.getDefaultDocument();
return doc.createElement(tagName);
}
createHtmlDocument() {
return document.implementation.createHTMLDocument("fakeTitle");
}
getDefaultDocument() {
return document;
}
isElementNode(node) {
return node.nodeType === Node.ELEMENT_NODE;
}
isShadowRoot(node) {
return node instanceof DocumentFragment;
}
/** @deprecated No longer being used in Ivy code. To be removed in version 14. */
getGlobalEventTarget(doc, target) {
if (target === "window") {
return window;
}
if (target === "document") {
return doc;
}
if (target === "body") {
return doc.body;
}
return null;
}
getBaseHref(doc) {
const href = getBaseElementHref();
return href == null ? null : relativePath(href);
}
resetBaseElement() {
baseElement = null;
}
getUserAgent() {
return window.navigator.userAgent;
}
getCookie(name2) {
return parseCookieValue(document.cookie, name2);
}
};
var baseElement = null;
function getBaseElementHref() {
baseElement = baseElement || document.querySelector("base");
return baseElement ? baseElement.getAttribute("href") : null;
}
function relativePath(url) {
return new URL(url, document.baseURI).pathname;
}
var BrowserGetTestability = class {
addToWindow(registry) {
_global["getAngularTestability"] = (elem2, findInAncestors = true) => {
const testability = registry.findTestabilityInTree(elem2, findInAncestors);
if (testability == null) {
throw new RuntimeError(5103, (typeof ngDevMode === "undefined" || ngDevMode) && "Could not find testability for element.");
}
return testability;
};
_global["getAllAngularTestabilities"] = () => registry.getAllTestabilities();
_global["getAllAngularRootElements"] = () => registry.getAllRootElements();
const whenAllStable = (callback) => {
const testabilities = _global["getAllAngularTestabilities"]();
let count = testabilities.length;
const decrement = function() {
count--;
if (count == 0) {
callback();
}
};
testabilities.forEach((testability) => {
testability.whenStable(decrement);
});
};
if (!_global["frameworkStabilizers"]) {
_global["frameworkStabilizers"] = [];
}
_global["frameworkStabilizers"].push(whenAllStable);
}
findTestabilityInTree(registry, elem2, findInAncestors) {
if (elem2 == null) {
return null;
}
const t = registry.getTestability(elem2);
if (t != null) {
return t;
} else if (!findInAncestors) {
return null;
}
if (getDOM().isShadowRoot(elem2)) {
return this.findTestabilityInTree(registry, elem2.host, true);
}
return this.findTestabilityInTree(registry, elem2.parentElement, true);
}
};
var _BrowserXhr = class _BrowserXhr {
build() {
return new XMLHttpRequest();
}
};
_BrowserXhr.\u0275fac = function BrowserXhr_Factory(t) {
return new (t || _BrowserXhr)();
};
_BrowserXhr.\u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
token: _BrowserXhr,
factory: _BrowserXhr.\u0275fac
});
var BrowserXhr = _BrowserXhr;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(BrowserXhr, [{
type: Injectable
}], null, null);
})();
var EVENT_MANAGER_PLUGINS = new InjectionToken(ngDevMode ? "EventManagerPlugins" : "");
var _EventManager = class _EventManager {
/**
* Initializes an instance of the event-manager service.
*/
constructor(plugins, _zone) {
this._zone = _zone;
this._eventNameToPlugin = /* @__PURE__ */ new Map();
plugins.forEach((plugin) => {
plugin.manager = this;
});
this._plugins = plugins.slice().reverse();
}
/**
* Registers a handler for a specific element and event.
*
* @param element The HTML element to receive event notifications.
* @param eventName The name of the event to listen for.
* @param handler A function to call when the notification occurs. Receives the
* event object as an argument.
* @returns A callback function that can be used to remove the handler.
*/
addEventListener(element, eventName, handler) {
const plugin = this._findPluginFor(eventName);
return plugin.addEventListener(element, eventName, handler);
}
/**
* Retrieves the compilation zone in which event listeners are registered.
*/
getZone() {
return this._zone;
}
/** @internal */
_findPluginFor(eventName) {
let plugin = this._eventNameToPlugin.get(eventName);
if (plugin) {
return plugin;
}
const plugins = this._plugins;
plugin = plugins.find((plugin2) => plugin2.supports(eventName));
if (!plugin) {
throw new RuntimeError(5101, (typeof ngDevMode === "undefined" || ngDevMode) && `No event manager plugin found for event ${eventName}`);
}
this._eventNameToPlugin.set(eventName, plugin);
return plugin;
}
};
_EventManager.\u0275fac = function EventManager_Factory(t) {
return new (t || _EventManager)(\u0275\u0275inject(EVENT_MANAGER_PLUGINS), \u0275\u0275inject(NgZone));
};
_EventManager.\u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
token: _EventManager,
factory: _EventManager.\u0275fac
});
var EventManager = _EventManager;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(EventManager, [{
type: Injectable
}], () => [{
type: void 0,
decorators: [{
type: Inject,
args: [EVENT_MANAGER_PLUGINS]
}]
}, {
type: NgZone
}], null);
})();
var EventManagerPlugin = class {
// TODO: remove (has some usage in G3)
constructor(_doc) {
this._doc = _doc;
}
};
var APP_ID_ATTRIBUTE_NAME = "ng-app-id";
var _SharedStylesHost = class _SharedStylesHost {
constructor(doc, appId, nonce, platformId = {}) {
this.doc = doc;
this.appId = appId;
this.nonce = nonce;
this.platformId = platformId;
this.styleRef = /* @__PURE__ */ new Map();
this.hostNodes = /* @__PURE__ */ new Set();
this.styleNodesInDOM = this.collectServerRenderedStyles();
this.platformIsServer = isPlatformServer(platformId);
this.resetHostNodes();
}
addStyles(styles) {
for (const style of styles) {
const usageCount = this.changeUsageCount(style, 1);
if (usageCount === 1) {
this.onStyleAdded(style);
}
}
}
removeStyles(styles) {
for (const style of styles) {
const usageCount = this.changeUsageCount(style, -1);
if (usageCount <= 0) {
this.onStyleRemoved(style);
}
}
}
ngOnDestroy() {
const styleNodesInDOM = this.styleNodesInDOM;
if (styleNodesInDOM) {
styleNodesInDOM.forEach((node) => node.remove());
styleNodesInDOM.clear();
}
for (const style of this.getAllStyles()) {
this.onStyleRemoved(style);
}
this.resetHostNodes();
}
addHost(hostNode) {
this.hostNodes.add(hostNode);
for (const style of this.getAllStyles()) {
this.addStyleToHost(hostNode, style);
}
}
removeHost(hostNode) {
this.hostNodes.delete(hostNode);
}
getAllStyles() {
return this.styleRef.keys();
}
onStyleAdded(style) {
for (const host of this.hostNodes) {
this.addStyleToHost(host, style);
}
}
onStyleRemoved(style) {
const styleRef = this.styleRef;
styleRef.get(style)?.elements?.forEach((node) => node.remove());
styleRef.delete(style);
}
collectServerRenderedStyles() {
const styles = this.doc.head?.querySelectorAll(`style[${APP_ID_ATTRIBUTE_NAME}="${this.appId}"]`);
if (styles?.length) {
const styleMap = /* @__PURE__ */ new Map();
styles.forEach((style) => {
if (style.textContent != null) {
styleMap.set(style.textContent, style);
}
});
return styleMap;
}
return null;
}
changeUsageCount(style, delta) {
const map2 = this.styleRef;
if (map2.has(style)) {
const styleRefValue = map2.get(style);
styleRefValue.usage += delta;
return styleRefValue.usage;
}
map2.set(style, {
usage: delta,
elements: []
});
return delta;
}
getStyleElement(host, style) {
const styleNodesInDOM = this.styleNodesInDOM;
const styleEl = styleNodesInDOM?.get(style);
if (styleEl?.parentNode === host) {
styleNodesInDOM.delete(style);
styleEl.removeAttribute(APP_ID_ATTRIBUTE_NAME);
if (typeof ngDevMode === "undefined" || ngDevMode) {
styleEl.setAttribute("ng-style-reused", "");
}
return styleEl;
} else {
const styleEl2 = this.doc.createElement("style");
if (this.nonce) {
styleEl2.setAttribute("nonce", this.nonce);
}
styleEl2.textContent = style;
if (this.platformIsServer) {
styleEl2.setAttribute(APP_ID_ATTRIBUTE_NAME, this.appId);
}
host.appendChild(styleEl2);
return styleEl2;
}
}
addStyleToHost(host, style) {
const styleEl = this.getStyleElement(host, style);
const styleRef = this.styleRef;
const styleElRef = styleRef.get(style)?.elements;
if (styleElRef) {
styleElRef.push(styleEl);
} else {
styleRef.set(style, {
elements: [styleEl],
usage: 1
});
}
}
resetHostNodes() {
const hostNodes = this.hostNodes;
hostNodes.clear();
hostNodes.add(this.doc.head);
}
};
_SharedStylesHost.\u0275fac = function SharedStylesHost_Factory(t) {
return new (t || _SharedStylesHost)(\u0275\u0275inject(DOCUMENT2), \u0275\u0275inject(APP_ID), \u0275\u0275inject(CSP_NONCE, 8), \u0275\u0275inject(PLATFORM_ID));
};
_SharedStylesHost.\u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
token: _SharedStylesHost,
factory: _SharedStylesHost.\u0275fac
});
var SharedStylesHost = _SharedStylesHost;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(SharedStylesHost, [{
type: Injectable
}], () => [{
type: Document,
decorators: [{
type: Inject,
args: [DOCUMENT2]
}]
}, {
type: void 0,
decorators: [{
type: Inject,
args: [APP_ID]
}]
}, {
type: void 0,
decorators: [{
type: Inject,
args: [CSP_NONCE]
}, {
type: Optional
}]
}, {
type: void 0,
decorators: [{
type: Inject,
args: [PLATFORM_ID]
}]
}], null);
})();
var NAMESPACE_URIS = {
"svg": "http://www.w3.org/2000/svg",
"xhtml": "http://www.w3.org/1999/xhtml",
"xlink": "http://www.w3.org/1999/xlink",
"xml": "http://www.w3.org/XML/1998/namespace",
"xmlns": "http://www.w3.org/2000/xmlns/",
"math": "http://www.w3.org/1998/MathML/"
};
var COMPONENT_REGEX = /%COMP%/g;
var COMPONENT_VARIABLE = "%COMP%";
var HOST_ATTR = `_nghost-${COMPONENT_VARIABLE}`;
var CONTENT_ATTR = `_ngcontent-${COMPONENT_VARIABLE}`;
var REMOVE_STYLES_ON_COMPONENT_DESTROY_DEFAULT = true;
var REMOVE_STYLES_ON_COMPONENT_DESTROY = new InjectionToken(ngDevMode ? "RemoveStylesOnCompDestroy" : "", {
providedIn: "root",
factory: () => REMOVE_STYLES_ON_COMPONENT_DESTROY_DEFAULT
});
function shimContentAttribute(componentShortId) {
return CONTENT_ATTR.replace(COMPONENT_REGEX, componentShortId);
}
function shimHostAttribute(componentShortId) {
return HOST_ATTR.replace(COMPONENT_REGEX, componentShortId);
}
function shimStylesContent(compId, styles) {
return styles.map((s) => s.replace(COMPONENT_REGEX, compId));
}
var _DomRendererFactory2 = class _DomRendererFactory2 {
constructor(eventManager, sharedStylesHost, appId, removeStylesOnCompDestroy, doc, platformId, ngZone, nonce = null) {
this.eventManager = eventManager;
this.sharedStylesHost = sharedStylesHost;
this.appId = appId;
this.removeStylesOnCompDestroy = removeStylesOnCompDestroy;
this.doc = doc;
this.platformId = platformId;
this.ngZone = ngZone;
this.nonce = nonce;
this.rendererByCompId = /* @__PURE__ */ new Map();
this.platformIsServer = isPlatformServer(platformId);
this.defaultRenderer = new DefaultDomRenderer2(eventManager, doc, ngZone, this.platformIsServer);
}
createRenderer(element, type) {
if (!element || !type) {
return this.defaultRenderer;
}
if (this.platformIsServer && type.encapsulation === ViewEncapsulation$1.ShadowDom) {
type = __spreadProps(__spreadValues({}, type), {
encapsulation: ViewEncapsulation$1.Emulated
});
}
const renderer2 = this.getOrCreateRenderer(element, type);
if (renderer2 instanceof EmulatedEncapsulationDomRenderer2) {
renderer2.applyToHost(element);
} else if (renderer2 instanceof NoneEncapsulationDomRenderer) {
renderer2.applyStyles();
}
return renderer2;
}
getOrCreateRenderer(element, type) {
const rendererByCompId = this.rendererByCompId;
let renderer2 = rendererByCompId.get(type.id);
if (!renderer2) {
const doc = this.doc;
const ngZone = this.ngZone;
const eventManager = this.eventManager;
const sharedStylesHost = this.sharedStylesHost;
const removeStylesOnCompDestroy = this.removeStylesOnCompDestroy;
const platformIsServer = this.platformIsServer;
switch (type.encapsulation) {
case ViewEncapsulation$1.Emulated:
renderer2 = new EmulatedEncapsulationDomRenderer2(eventManager, sharedStylesHost, type, this.appId, removeStylesOnCompDestroy, doc, ngZone, platformIsServer);
break;
case ViewEncapsulation$1.ShadowDom:
return new ShadowDomRenderer(eventManager, sharedStylesHost, element, type, doc, ngZone, this.nonce, platformIsServer);
default:
renderer2 = new NoneEncapsulationDomRenderer(eventManager, sharedStylesHost, type, removeStylesOnCompDestroy, doc, ngZone, platformIsServer);
break;
}
rendererByCompId.set(type.id, renderer2);
}
return renderer2;
}
ngOnDestroy() {
this.rendererByCompId.clear();
}
};
_DomRendererFactory2.\u0275fac = function DomRendererFactory2_Factory(t) {
return new (t || _DomRendererFactory2)(\u0275\u0275inject(EventManager), \u0275\u0275inject(SharedStylesHost), \u0275\u0275inject(APP_ID), \u0275\u0275inject(REMOVE_STYLES_ON_COMPONENT_DESTROY), \u0275\u0275inject(DOCUMENT2), \u0275\u0275inject(PLATFORM_ID), \u0275\u0275inject(NgZone), \u0275\u0275inject(CSP_NONCE));
};
_DomRendererFactory2.\u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
token: _DomRendererFactory2,
factory: _DomRendererFactory2.\u0275fac
});
var DomRendererFactory2 = _DomRendererFactory2;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(DomRendererFactory2, [{
type: Injectable
}], () => [{
type: EventManager
}, {
type: SharedStylesHost
}, {
type: void 0,
decorators: [{
type: Inject,
args: [APP_ID]
}]
}, {
type: void 0,
decorators: [{
type: Inject,
args: [REMOVE_STYLES_ON_COMPONENT_DESTROY]
}]
}, {
type: Document,
decorators: [{
type: Inject,
args: [DOCUMENT2]
}]
}, {
type: Object,
decorators: [{
type: Inject,
args: [PLATFORM_ID]
}]
}, {
type: NgZone
}, {
type: void 0,
decorators: [{
type: Inject,
args: [CSP_NONCE]
}]
}], null);
})();
var DefaultDomRenderer2 = class {
constructor(eventManager, doc, ngZone, platformIsServer) {
this.eventManager = eventManager;
this.doc = doc;
this.ngZone = ngZone;
this.platformIsServer = platformIsServer;
this.data = /* @__PURE__ */ Object.create(null);
this.throwOnSyntheticProps = true;
this.destroyNode = null;
}
destroy() {
}
createElement(name2, namespace) {
if (namespace) {
return this.doc.createElementNS(NAMESPACE_URIS[namespace] || namespace, name2);
}
return this.doc.createElement(name2);
}
createComment(value2) {
return this.doc.createComment(value2);
}
createText(value2) {
return this.doc.createTextNode(value2);
}
appendChild(parent2, newChild) {
const targetParent = isTemplateNode(parent2) ? parent2.content : parent2;
targetParent.appendChild(newChild);
}
insertBefore(parent2, newChild, refChild) {
if (parent2) {
const targetParent = isTemplateNode(parent2) ? parent2.content : parent2;
targetParent.insertBefore(newChild, refChild);
}
}
removeChild(parent2, oldChild) {
if (parent2) {
parent2.removeChild(oldChild);
}
}
selectRootElement(selectorOrNode, preserveContent) {
let el = typeof selectorOrNode === "string" ? this.doc.querySelector(selectorOrNode) : selectorOrNode;
if (!el) {
throw new RuntimeError(-5104, (typeof ngDevMode === "undefined" || ngDevMode) && `The selector "${selectorOrNode}" did not match any elements`);
}
if (!preserveContent) {
el.textContent = "";
}
return el;
}
parentNode(node) {
return node.parentNode;
}
nextSibling(node) {
return node.nextSibling;
}
setAttribute(el, name2, value2, namespace) {
if (namespace) {
name2 = namespace + ":" + name2;
const namespaceUri = NAMESPACE_URIS[namespace];
if (namespaceUri) {
el.setAttributeNS(namespaceUri, name2, value2);
} else {
el.setAttribute(name2, value2);
}
} else {
el.setAttribute(name2, value2);
}
}
removeAttribute(el, name2, namespace) {
if (namespace) {
const namespaceUri = NAMESPACE_URIS[namespace];
if (namespaceUri) {
el.removeAttributeNS(namespaceUri, name2);
} else {
el.removeAttribute(`${namespace}:${name2}`);
}
} else {
el.removeAttribute(name2);
}
}
addClass(el, name2) {
el.classList.add(name2);
}
removeClass(el, name2) {
el.classList.remove(name2);
}
setStyle(el, style, value2, flags) {
if (flags & (RendererStyleFlags2.DashCase | RendererStyleFlags2.Important)) {
el.style.setProperty(style, value2, flags & RendererStyleFlags2.Important ? "important" : "");
} else {
el.style[style] = value2;
}
}
removeStyle(el, style, flags) {
if (flags & RendererStyleFlags2.DashCase) {
el.style.removeProperty(style);
} else {
el.style[style] = "";
}
}
setProperty(el, name2, value2) {
if (el == null) {
return;
}
(typeof ngDevMode === "undefined" || ngDevMode) && this.throwOnSyntheticProps && checkNoSyntheticProp(name2, "property");
el[name2] = value2;
}
setValue(node, value2) {
node.nodeValue = value2;
}
listen(target, event, callback) {
(typeof ngDevMode === "undefined" || ngDevMode) && this.throwOnSyntheticProps && checkNoSyntheticProp(event, "listener");
if (typeof target === "string") {
target = getDOM().getGlobalEventTarget(this.doc, target);
if (!target) {
throw new Error(`Unsupported event target ${target} for event ${event}`);
}
}
return this.eventManager.addEventListener(target, event, this.decoratePreventDefault(callback));
}
decoratePreventDefault(eventHandler) {
return (event) => {
if (event === "__ngUnwrap__") {
return eventHandler;
}
const allowDefaultBehavior = this.platformIsServer ? this.ngZone.runGuarded(() => eventHandler(event)) : eventHandler(event);
if (allowDefaultBehavior === false) {
event.preventDefault();
}
return void 0;
};
}
};
var AT_CHARCODE = (() => "@".charCodeAt(0))();
function checkNoSyntheticProp(name2, nameKind) {
if (name2.charCodeAt(0) === AT_CHARCODE) {
throw new RuntimeError(5105, `Unexpected synthetic ${nameKind} ${name2} found. Please make sure that:
- Either \`BrowserAnimationsModule\` or \`NoopAnimationsModule\` are imported in your application.
- There is corresponding configuration for the animation named \`${name2}\` defined in the \`animations\` field of the \`@Component\` decorator (see https://angular.io/api/core/Component#animations).`);
}
}
function isTemplateNode(node) {
return node.tagName === "TEMPLATE" && node.content !== void 0;
}
var ShadowDomRenderer = class extends DefaultDomRenderer2 {
constructor(eventManager, sharedStylesHost, hostEl, component, doc, ngZone, nonce, platformIsServer) {
super(eventManager, doc, ngZone, platformIsServer);
this.sharedStylesHost = sharedStylesHost;
this.hostEl = hostEl;
this.shadowRoot = hostEl.attachShadow({
mode: "open"
});
this.sharedStylesHost.addHost(this.shadowRoot);
const styles = shimStylesContent(component.id, component.styles);
for (const style of styles) {
const styleEl = document.createElement("style");
if (nonce) {
styleEl.setAttribute("nonce", nonce);
}
styleEl.textContent = style;
this.shadowRoot.appendChild(styleEl);
}
}
nodeOrShadowRoot(node) {
return node === this.hostEl ? this.shadowRoot : node;
}
appendChild(parent2, newChild) {
return super.appendChild(this.nodeOrShadowRoot(parent2), newChild);
}
insertBefore(parent2, newChild, refChild) {
return super.insertBefore(this.nodeOrShadowRoot(parent2), newChild, refChild);
}
removeChild(parent2, oldChild) {
return super.removeChild(this.nodeOrShadowRoot(parent2), oldChild);
}
parentNode(node) {
return this.nodeOrShadowRoot(super.parentNode(this.nodeOrShadowRoot(node)));
}
destroy() {
this.sharedStylesHost.removeHost(this.shadowRoot);
}
};
var NoneEncapsulationDomRenderer = class extends DefaultDomRenderer2 {
constructor(eventManager, sharedStylesHost, component, removeStylesOnCompDestroy, doc, ngZone, platformIsServer, compId) {
super(eventManager, doc, ngZone, platformIsServer);
this.sharedStylesHost = sharedStylesHost;
this.removeStylesOnCompDestroy = removeStylesOnCompDestroy;
this.styles = compId ? shimStylesContent(compId, component.styles) : component.styles;
}
applyStyles() {
this.sharedStylesHost.addStyles(this.styles);
}
destroy() {
if (!this.removeStylesOnCompDestroy) {
return;
}
this.sharedStylesHost.removeStyles(this.styles);
}
};
var EmulatedEncapsulationDomRenderer2 = class extends NoneEncapsulationDomRenderer {
constructor(eventManager, sharedStylesHost, component, appId, removeStylesOnCompDestroy, doc, ngZone, platformIsServer) {
const compId = appId + "-" + component.id;
super(eventManager, sharedStylesHost, component, removeStylesOnCompDestroy, doc, ngZone, platformIsServer, compId);
this.contentAttr = shimContentAttribute(compId);
this.hostAttr = shimHostAttribute(compId);
}
applyToHost(element) {
this.applyStyles();
this.setAttribute(element, this.hostAttr, "");
}
createElement(parent2, name2) {
const el = super.createElement(parent2, name2);
super.setAttribute(el, this.contentAttr, "");
return el;
}
};
var _DomEventsPlugin = class _DomEventsPlugin extends EventManagerPlugin {
constructor(doc) {
super(doc);
}
// This plugin should come last in the list of plugins, because it accepts all
// events.
supports(eventName) {
return true;
}
addEventListener(element, eventName, handler) {
element.addEventListener(eventName, handler, false);
return () => this.removeEventListener(element, eventName, handler);
}
removeEventListener(target, eventName, callback) {
return target.removeEventListener(eventName, callback);
}
};
_DomEventsPlugin.\u0275fac = function DomEventsPlugin_Factory(t) {
return new (t || _DomEventsPlugin)(\u0275\u0275inject(DOCUMENT2));
};
_DomEventsPlugin.\u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
token: _DomEventsPlugin,
factory: _DomEventsPlugin.\u0275fac
});
var DomEventsPlugin = _DomEventsPlugin;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(DomEventsPlugin, [{
type: Injectable
}], () => [{
type: void 0,
decorators: [{
type: Inject,
args: [DOCUMENT2]
}]
}], null);
})();
var MODIFIER_KEYS = ["alt", "control", "meta", "shift"];
var _keyMap = {
"\b": "Backspace",
" ": "Tab",
"\x7F": "Delete",
"\x1B": "Escape",
"Del": "Delete",
"Esc": "Escape",
"Left": "ArrowLeft",
"Right": "ArrowRight",
"Up": "ArrowUp",
"Down": "ArrowDown",
"Menu": "ContextMenu",
"Scroll": "ScrollLock",
"Win": "OS"
};
var MODIFIER_KEY_GETTERS = {
"alt": (event) => event.altKey,
"control": (event) => event.ctrlKey,
"meta": (event) => event.metaKey,
"shift": (event) => event.shiftKey
};
var _KeyEventsPlugin = class _KeyEventsPlugin extends EventManagerPlugin {
/**
* Initializes an instance of the browser plug-in.
* @param doc The document in which key events will be detected.
*/
constructor(doc) {
super(doc);
}
/**
* Reports whether a named key event is supported.
* @param eventName The event name to query.
* @return True if the named key event is supported.
*/
supports(eventName) {
return _KeyEventsPlugin.parseEventName(eventName) != null;
}
/**
* Registers a handler for a specific element and key event.
* @param element The HTML element to receive event notifications.
* @param eventName The name of the key event to listen for.
* @param handler A function to call when the notification occurs. Receives the
* event object as an argument.
* @returns The key event that was registered.
*/
addEventListener(element, eventName, handler) {
const parsedEvent = _KeyEventsPlugin.parseEventName(eventName);
const outsideHandler = _KeyEventsPlugin.eventCallback(parsedEvent["fullKey"], handler, this.manager.getZone());
return this.manager.getZone().runOutsideAngular(() => {
return getDOM().onAndCancel(element, parsedEvent["domEventName"], outsideHandler);
});
}
/**
* Parses the user provided full keyboard event definition and normalizes it for
* later internal use. It ensures the string is all lowercase, converts special
* characters to a standard spelling, and orders all the values consistently.
*
* @param eventName The name of the key event to listen for.
* @returns an object with the full, normalized string, and the dom event name
* or null in the case when the event doesn't match a keyboard event.
*/
static parseEventName(eventName) {
const parts = eventName.toLowerCase().split(".");
const domEventName = parts.shift();
if (parts.length === 0 || !(domEventName === "keydown" || domEventName === "keyup")) {
return null;
}
const key2 = _KeyEventsPlugin._normalizeKey(parts.pop());
let fullKey = "";
let codeIX = parts.indexOf("code");
if (codeIX > -1) {
parts.splice(codeIX, 1);
fullKey = "code.";
}
MODIFIER_KEYS.forEach((modifierName) => {
const index2 = parts.indexOf(modifierName);
if (index2 > -1) {
parts.splice(index2, 1);
fullKey += modifierName + ".";
}
});
fullKey += key2;
if (parts.length != 0 || key2.length === 0) {
return null;
}
const result = {};
result["domEventName"] = domEventName;
result["fullKey"] = fullKey;
return result;
}
/**
* Determines whether the actual keys pressed match the configured key code string.
* The `fullKeyCode` event is normalized in the `parseEventName` method when the
* event is attached to the DOM during the `addEventListener` call. This is unseen
* by the end user and is normalized for internal consistency and parsing.
*
* @param event The keyboard event.
* @param fullKeyCode The normalized user defined expected key event string
* @returns boolean.
*/
static matchEventFullKeyCode(event, fullKeyCode) {
let keycode = _keyMap[event.key] || event.key;
let key2 = "";
if (fullKeyCode.indexOf("code.") > -1) {
keycode = event.code;
key2 = "code.";
}
if (keycode == null || !keycode)
return false;
keycode = keycode.toLowerCase();
if (keycode === " ") {
keycode = "space";
} else if (keycode === ".") {
keycode = "dot";
}
MODIFIER_KEYS.forEach((modifierName) => {
if (modifierName !== keycode) {
const modifierGetter = MODIFIER_KEY_GETTERS[modifierName];
if (modifierGetter(event)) {
key2 += modifierName + ".";
}
}
});
key2 += keycode;
return key2 === fullKeyCode;
}
/**
* Configures a handler callback for a key event.
* @param fullKey The event name that combines all simultaneous keystrokes.
* @param handler The function that responds to the key event.
* @param zone The zone in which the event occurred.
* @returns A callback function.
*/
static eventCallback(fullKey, handler, zone) {
return (event) => {
if (_KeyEventsPlugin.matchEventFullKeyCode(event, fullKey)) {
zone.runGuarded(() => handler(event));
}
};
}
/** @internal */
static _normalizeKey(keyName) {
return keyName === "esc" ? "escape" : keyName;
}
};
_KeyEventsPlugin.\u0275fac = function KeyEventsPlugin_Factory(t) {
return new (t || _KeyEventsPlugin)(\u0275\u0275inject(DOCUMENT2));
};
_KeyEventsPlugin.\u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
token: _KeyEventsPlugin,
factory: _KeyEventsPlugin.\u0275fac
});
var KeyEventsPlugin = _KeyEventsPlugin;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(KeyEventsPlugin, [{
type: Injectable
}], () => [{
type: void 0,
decorators: [{
type: Inject,
args: [DOCUMENT2]
}]
}], null);
})();
function bootstrapApplication(rootComponent, options) {
return internalCreateApplication(__spreadValues({
rootComponent
}, createProvidersConfig(options)));
}
function createProvidersConfig(options) {
return {
appProviders: [...BROWSER_MODULE_PROVIDERS, ...options?.providers ?? []],
platformProviders: INTERNAL_BROWSER_PLATFORM_PROVIDERS
};
}
function initDomAdapter() {
BrowserDomAdapter.makeCurrent();
}
function errorHandler() {
return new ErrorHandler();
}
function _document() {
setDocument(document);
return document;
}
var INTERNAL_BROWSER_PLATFORM_PROVIDERS = [{
provide: PLATFORM_ID,
useValue: PLATFORM_BROWSER_ID
}, {
provide: PLATFORM_INITIALIZER,
useValue: initDomAdapter,
multi: true
}, {
provide: DOCUMENT2,
useFactory: _document,
deps: []
}];
var platformBrowser = createPlatformFactory(platformCore, "browser", INTERNAL_BROWSER_PLATFORM_PROVIDERS);
var BROWSER_MODULE_PROVIDERS_MARKER = new InjectionToken(typeof ngDevMode === "undefined" || ngDevMode ? "BrowserModule Providers Marker" : "");
var TESTABILITY_PROVIDERS = [{
provide: TESTABILITY_GETTER,
useClass: BrowserGetTestability,
deps: []
}, {
provide: TESTABILITY,
useClass: Testability,
deps: [NgZone, TestabilityRegistry, TESTABILITY_GETTER]
}, {
provide: Testability,
// Also provide as `Testability` for backwards-compatibility.
useClass: Testability,
deps: [NgZone, TestabilityRegistry, TESTABILITY_GETTER]
}];
var BROWSER_MODULE_PROVIDERS = [{
provide: INJECTOR_SCOPE,
useValue: "root"
}, {
provide: ErrorHandler,
useFactory: errorHandler,
deps: []
}, {
provide: EVENT_MANAGER_PLUGINS,
useClass: DomEventsPlugin,
multi: true,
deps: [DOCUMENT2, NgZone, PLATFORM_ID]
}, {
provide: EVENT_MANAGER_PLUGINS,
useClass: KeyEventsPlugin,
multi: true,
deps: [DOCUMENT2]
}, DomRendererFactory2, SharedStylesHost, EventManager, {
provide: RendererFactory2,
useExisting: DomRendererFactory2
}, {
provide: XhrFactory,
useClass: BrowserXhr,
deps: []
}, typeof ngDevMode === "undefined" || ngDevMode ? {
provide: BROWSER_MODULE_PROVIDERS_MARKER,
useValue: true
} : []];
var _BrowserModule = class _BrowserModule {
constructor(providersAlreadyPresent) {
if ((typeof ngDevMode === "undefined" || ngDevMode) && providersAlreadyPresent) {
throw new RuntimeError(5100, `Providers from the \`BrowserModule\` have already been loaded. If you need access to common directives such as NgIf and NgFor, import the \`CommonModule\` instead.`);
}
}
/**
* Configures a browser-based app to transition from a server-rendered app, if
* one is present on the page.
*
* @param params An object containing an identifier for the app to transition.
* The ID must match between the client and server versions of the app.
* @returns The reconfigured `BrowserModule` to import into the app's root `AppModule`.
*
* @deprecated Use {@link APP_ID} instead to set the application ID.
*/
static withServerTransition(params) {
return {
ngModule: _BrowserModule,
providers: [{
provide: APP_ID,
useValue: params.appId
}]
};
}
};
_BrowserModule.\u0275fac = function BrowserModule_Factory(t) {
return new (t || _BrowserModule)(\u0275\u0275inject(BROWSER_MODULE_PROVIDERS_MARKER, 12));
};
_BrowserModule.\u0275mod = /* @__PURE__ */ \u0275\u0275defineNgModule({
type: _BrowserModule
});
_BrowserModule.\u0275inj = /* @__PURE__ */ \u0275\u0275defineInjector({
providers: [...BROWSER_MODULE_PROVIDERS, ...TESTABILITY_PROVIDERS],
imports: [CommonModule, ApplicationModule]
});
var BrowserModule = _BrowserModule;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(BrowserModule, [{
type: NgModule,
args: [{
providers: [...BROWSER_MODULE_PROVIDERS, ...TESTABILITY_PROVIDERS],
exports: [CommonModule, ApplicationModule]
}]
}], () => [{
type: void 0,
decorators: [{
type: Optional
}, {
type: SkipSelf
}, {
type: Inject,
args: [BROWSER_MODULE_PROVIDERS_MARKER]
}]
}], null);
})();
var _Meta = class _Meta {
constructor(_doc) {
this._doc = _doc;
this._dom = getDOM();
}
/**
* Retrieves or creates a specific `<meta>` tag element in the current HTML document.
* In searching for an existing tag, Angular attempts to match the `name` or `property` attribute
* values in the provided tag definition, and verifies that all other attribute values are equal.
* If an existing element is found, it is returned and is not modified in any way.
* @param tag The definition of a `<meta>` element to match or create.
* @param forceCreation True to create a new element without checking whether one already exists.
* @returns The existing element with the same attributes and values if found,
* the new element if no match is found, or `null` if the tag parameter is not defined.
*/
addTag(tag, forceCreation = false) {
if (!tag)
return null;
return this._getOrCreateElement(tag, forceCreation);
}
/**
* Retrieves or creates a set of `<meta>` tag elements in the current HTML document.
* In searching for an existing tag, Angular attempts to match the `name` or `property` attribute
* values in the provided tag definition, and verifies that all other attribute values are equal.
* @param tags An array of tag definitions to match or create.
* @param forceCreation True to create new elements without checking whether they already exist.
* @returns The matching elements if found, or the new elements.
*/
addTags(tags, forceCreation = false) {
if (!tags)
return [];
return tags.reduce((result, tag) => {
if (tag) {
result.push(this._getOrCreateElement(tag, forceCreation));
}
return result;
}, []);
}
/**
* Retrieves a `<meta>` tag element in the current HTML document.
* @param attrSelector The tag attribute and value to match against, in the format
* `"tag_attribute='value string'"`.
* @returns The matching element, if any.
*/
getTag(attrSelector) {
if (!attrSelector)
return null;
return this._doc.querySelector(`meta[${attrSelector}]`) || null;
}
/**
* Retrieves a set of `<meta>` tag elements in the current HTML document.
* @param attrSelector The tag attribute and value to match against, in the format
* `"tag_attribute='value string'"`.
* @returns The matching elements, if any.
*/
getTags(attrSelector) {
if (!attrSelector)
return [];
const list = this._doc.querySelectorAll(`meta[${attrSelector}]`);
return list ? [].slice.call(list) : [];
}
/**
* Modifies an existing `<meta>` tag element in the current HTML document.
* @param tag The tag description with which to replace the existing tag content.
* @param selector A tag attribute and value to match against, to identify
* an existing tag. A string in the format `"tag_attribute=`value string`"`.
* If not supplied, matches a tag with the same `name` or `property` attribute value as the
* replacement tag.
* @return The modified element.
*/
updateTag(tag, selector) {
if (!tag)
return null;
selector = selector || this._parseSelector(tag);
const meta = this.getTag(selector);
if (meta) {
return this._setMetaElementAttributes(tag, meta);
}
return this._getOrCreateElement(tag, true);
}
/**
* Removes an existing `<meta>` tag element from the current HTML document.
* @param attrSelector A tag attribute and value to match against, to identify
* an existing tag. A string in the format `"tag_attribute=`value string`"`.
*/
removeTag(attrSelector) {
this.removeTagElement(this.getTag(attrSelector));
}
/**
* Removes an existing `<meta>` tag element from the current HTML document.
* @param meta The tag definition to match against to identify an existing tag.
*/
removeTagElement(meta) {
if (meta) {
this._dom.remove(meta);
}
}
_getOrCreateElement(meta, forceCreation = false) {
if (!forceCreation) {
const selector = this._parseSelector(meta);
const elem2 = this.getTags(selector).filter((elem3) => this._containsAttributes(meta, elem3))[0];
if (elem2 !== void 0)
return elem2;
}
const element = this._dom.createElement("meta");
this._setMetaElementAttributes(meta, element);
const head = this._doc.getElementsByTagName("head")[0];
head.appendChild(element);
return element;
}
_setMetaElementAttributes(tag, el) {
Object.keys(tag).forEach((prop) => el.setAttribute(this._getMetaKeyMap(prop), tag[prop]));
return el;
}
_parseSelector(tag) {
const attr = tag.name ? "name" : "property";
return `${attr}="${tag[attr]}"`;
}
_containsAttributes(tag, elem2) {
return Object.keys(tag).every((key2) => elem2.getAttribute(this._getMetaKeyMap(key2)) === tag[key2]);
}
_getMetaKeyMap(prop) {
return META_KEYS_MAP[prop] || prop;
}
};
_Meta.\u0275fac = function Meta_Factory(t) {
return new (t || _Meta)(\u0275\u0275inject(DOCUMENT2));
};
_Meta.\u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
token: _Meta,
factory: _Meta.\u0275fac,
providedIn: "root"
});
var Meta = _Meta;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(Meta, [{
type: Injectable,
args: [{
providedIn: "root"
}]
}], () => [{
type: void 0,
decorators: [{
type: Inject,
args: [DOCUMENT2]
}]
}], null);
})();
var META_KEYS_MAP = {
httpEquiv: "http-equiv"
};
var _Title = class _Title {
constructor(_doc) {
this._doc = _doc;
}
/**
* Get the title of the current HTML document.
*/
getTitle() {
return this._doc.title;
}
/**
* Set the title of the current HTML document.
* @param newTitle
*/
setTitle(newTitle) {
this._doc.title = newTitle || "";
}
};
_Title.\u0275fac = function Title_Factory(t) {
return new (t || _Title)(\u0275\u0275inject(DOCUMENT2));
};
_Title.\u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
token: _Title,
factory: _Title.\u0275fac,
providedIn: "root"
});
var Title = _Title;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(Title, [{
type: Injectable,
args: [{
providedIn: "root"
}]
}], () => [{
type: void 0,
decorators: [{
type: Inject,
args: [DOCUMENT2]
}]
}], null);
})();
var EVENT_NAMES = {
// pan
"pan": true,
"panstart": true,
"panmove": true,
"panend": true,
"pancancel": true,
"panleft": true,
"panright": true,
"panup": true,
"pandown": true,
// pinch
"pinch": true,
"pinchstart": true,
"pinchmove": true,
"pinchend": true,
"pinchcancel": true,
"pinchin": true,
"pinchout": true,
// press
"press": true,
"pressup": true,
// rotate
"rotate": true,
"rotatestart": true,
"rotatemove": true,
"rotateend": true,
"rotatecancel": true,
// swipe
"swipe": true,
"swipeleft": true,
"swiperight": true,
"swipeup": true,
"swipedown": true,
// tap
"tap": true,
"doubletap": true
};
var HAMMER_GESTURE_CONFIG = new InjectionToken("HammerGestureConfig");
var HAMMER_LOADER = new InjectionToken("HammerLoader");
var _HammerGestureConfig = class _HammerGestureConfig {
constructor() {
this.events = [];
this.overrides = {};
}
/**
* Creates a [HammerJS Manager](https://hammerjs.github.io/api/#hammermanager)
* and attaches it to a given HTML element.
* @param element The element that will recognize gestures.
* @returns A HammerJS event-manager object.
*/
buildHammer(element) {
const mc = new Hammer(element, this.options);
mc.get("pinch").set({
enable: true
});
mc.get("rotate").set({
enable: true
});
for (const eventName in this.overrides) {
mc.get(eventName).set(this.overrides[eventName]);
}
return mc;
}
};
_HammerGestureConfig.\u0275fac = function HammerGestureConfig_Factory(t) {
return new (t || _HammerGestureConfig)();
};
_HammerGestureConfig.\u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
token: _HammerGestureConfig,
factory: _HammerGestureConfig.\u0275fac
});
var HammerGestureConfig = _HammerGestureConfig;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(HammerGestureConfig, [{
type: Injectable
}], null, null);
})();
var _HammerGesturesPlugin = class _HammerGesturesPlugin extends EventManagerPlugin {
constructor(doc, _config, console2, loader) {
super(doc);
this._config = _config;
this.console = console2;
this.loader = loader;
this._loaderPromise = null;
}
supports(eventName) {
if (!EVENT_NAMES.hasOwnProperty(eventName.toLowerCase()) && !this.isCustomEvent(eventName)) {
return false;
}
if (!window.Hammer && !this.loader) {
if (typeof ngDevMode === "undefined" || ngDevMode) {
this.console.warn(`The "${eventName}" event cannot be bound because Hammer.JS is not loaded and no custom loader has been specified.`);
}
return false;
}
return true;
}
addEventListener(element, eventName, handler) {
const zone = this.manager.getZone();
eventName = eventName.toLowerCase();
if (!window.Hammer && this.loader) {
this._loaderPromise = this._loaderPromise || zone.runOutsideAngular(() => this.loader());
let cancelRegistration = false;
let deregister = () => {
cancelRegistration = true;
};
zone.runOutsideAngular(() => this._loaderPromise.then(() => {
if (!window.Hammer) {
if (typeof ngDevMode === "undefined" || ngDevMode) {
this.console.warn(`The custom HAMMER_LOADER completed, but Hammer.JS is not present.`);
}
deregister = () => {
};
return;
}
if (!cancelRegistration) {
deregister = this.addEventListener(element, eventName, handler);
}
}).catch(() => {
if (typeof ngDevMode === "undefined" || ngDevMode) {
this.console.warn(`The "${eventName}" event cannot be bound because the custom Hammer.JS loader failed.`);
}
deregister = () => {
};
}));
return () => {
deregister();
};
}
return zone.runOutsideAngular(() => {
const mc = this._config.buildHammer(element);
const callback = function(eventObj) {
zone.runGuarded(function() {
handler(eventObj);
});
};
mc.on(eventName, callback);
return () => {
mc.off(eventName, callback);
if (typeof mc.destroy === "function") {
mc.destroy();
}
};
});
}
isCustomEvent(eventName) {
return this._config.events.indexOf(eventName) > -1;
}
};
_HammerGesturesPlugin.\u0275fac = function HammerGesturesPlugin_Factory(t) {
return new (t || _HammerGesturesPlugin)(\u0275\u0275inject(DOCUMENT2), \u0275\u0275inject(HAMMER_GESTURE_CONFIG), \u0275\u0275inject(Console), \u0275\u0275inject(HAMMER_LOADER, 8));
};
_HammerGesturesPlugin.\u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
token: _HammerGesturesPlugin,
factory: _HammerGesturesPlugin.\u0275fac
});
var HammerGesturesPlugin = _HammerGesturesPlugin;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(HammerGesturesPlugin, [{
type: Injectable
}], () => [{
type: void 0,
decorators: [{
type: Inject,
args: [DOCUMENT2]
}]
}, {
type: HammerGestureConfig,
decorators: [{
type: Inject,
args: [HAMMER_GESTURE_CONFIG]
}]
}, {
type: Console
}, {
type: void 0,
decorators: [{
type: Optional
}, {
type: Inject,
args: [HAMMER_LOADER]
}]
}], null);
})();
var _HammerModule = class _HammerModule {
};
_HammerModule.\u0275fac = function HammerModule_Factory(t) {
return new (t || _HammerModule)();
};
_HammerModule.\u0275mod = /* @__PURE__ */ \u0275\u0275defineNgModule({
type: _HammerModule
});
_HammerModule.\u0275inj = /* @__PURE__ */ \u0275\u0275defineInjector({
providers: [{
provide: EVENT_MANAGER_PLUGINS,
useClass: HammerGesturesPlugin,
multi: true,
deps: [DOCUMENT2, HAMMER_GESTURE_CONFIG, Console, [new Optional(), HAMMER_LOADER]]
}, {
provide: HAMMER_GESTURE_CONFIG,
useClass: HammerGestureConfig,
deps: []
}]
});
var HammerModule = _HammerModule;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(HammerModule, [{
type: NgModule,
args: [{
providers: [{
provide: EVENT_MANAGER_PLUGINS,
useClass: HammerGesturesPlugin,
multi: true,
deps: [DOCUMENT2, HAMMER_GESTURE_CONFIG, Console, [new Optional(), HAMMER_LOADER]]
}, {
provide: HAMMER_GESTURE_CONFIG,
useClass: HammerGestureConfig,
deps: []
}]
}]
}], null, null);
})();
var _DomSanitizer = class _DomSanitizer {
};
_DomSanitizer.\u0275fac = function DomSanitizer_Factory(t) {
return new (t || _DomSanitizer)();
};
_DomSanitizer.\u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
token: _DomSanitizer,
factory: function DomSanitizer_Factory(t) {
let r = null;
if (t) {
r = new (t || _DomSanitizer)();
} else {
r = \u0275\u0275inject(DomSanitizerImpl);
}
return r;
},
providedIn: "root"
});
var DomSanitizer = _DomSanitizer;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(DomSanitizer, [{
type: Injectable,
args: [{
providedIn: "root",
useExisting: forwardRef(() => DomSanitizerImpl)
}]
}], null, null);
})();
var _DomSanitizerImpl = class _DomSanitizerImpl extends DomSanitizer {
constructor(_doc) {
super();
this._doc = _doc;
}
sanitize(ctx, value2) {
if (value2 == null)
return null;
switch (ctx) {
case SecurityContext.NONE:
return value2;
case SecurityContext.HTML:
if (allowSanitizationBypassAndThrow(
value2,
"HTML"
/* BypassType.Html */
)) {
return unwrapSafeValue(value2);
}
return _sanitizeHtml(this._doc, String(value2)).toString();
case SecurityContext.STYLE:
if (allowSanitizationBypassAndThrow(
value2,
"Style"
/* BypassType.Style */
)) {
return unwrapSafeValue(value2);
}
return value2;
case SecurityContext.SCRIPT:
if (allowSanitizationBypassAndThrow(
value2,
"Script"
/* BypassType.Script */
)) {
return unwrapSafeValue(value2);
}
throw new RuntimeError(5200, (typeof ngDevMode === "undefined" || ngDevMode) && "unsafe value used in a script context");
case SecurityContext.URL:
if (allowSanitizationBypassAndThrow(
value2,
"URL"
/* BypassType.Url */
)) {
return unwrapSafeValue(value2);
}
return _sanitizeUrl(String(value2));
case SecurityContext.RESOURCE_URL:
if (allowSanitizationBypassAndThrow(
value2,
"ResourceURL"
/* BypassType.ResourceUrl */
)) {
return unwrapSafeValue(value2);
}
throw new RuntimeError(5201, (typeof ngDevMode === "undefined" || ngDevMode) && `unsafe value used in a resource URL context (see ${XSS_SECURITY_URL})`);
default:
throw new RuntimeError(5202, (typeof ngDevMode === "undefined" || ngDevMode) && `Unexpected SecurityContext ${ctx} (see ${XSS_SECURITY_URL})`);
}
}
bypassSecurityTrustHtml(value2) {
return bypassSanitizationTrustHtml(value2);
}
bypassSecurityTrustStyle(value2) {
return bypassSanitizationTrustStyle(value2);
}
bypassSecurityTrustScript(value2) {
return bypassSanitizationTrustScript(value2);
}
bypassSecurityTrustUrl(value2) {
return bypassSanitizationTrustUrl(value2);
}
bypassSecurityTrustResourceUrl(value2) {
return bypassSanitizationTrustResourceUrl(value2);
}
};
_DomSanitizerImpl.\u0275fac = function DomSanitizerImpl_Factory(t) {
return new (t || _DomSanitizerImpl)(\u0275\u0275inject(DOCUMENT2));
};
_DomSanitizerImpl.\u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
token: _DomSanitizerImpl,
factory: _DomSanitizerImpl.\u0275fac,
providedIn: "root"
});
var DomSanitizerImpl = _DomSanitizerImpl;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(DomSanitizerImpl, [{
type: Injectable,
args: [{
providedIn: "root"
}]
}], () => [{
type: void 0,
decorators: [{
type: Inject,
args: [DOCUMENT2]
}]
}], null);
})();
var HydrationFeatureKind;
(function(HydrationFeatureKind2) {
HydrationFeatureKind2[HydrationFeatureKind2["NoHttpTransferCache"] = 0] = "NoHttpTransferCache";
HydrationFeatureKind2[HydrationFeatureKind2["HttpTransferCacheOptions"] = 1] = "HttpTransferCacheOptions";
})(HydrationFeatureKind || (HydrationFeatureKind = {}));
var VERSION3 = new Version("17.3.12");
// node_modules/@angular/router/fesm2022/router.mjs
var PRIMARY_OUTLET = "primary";
var RouteTitleKey = /* @__PURE__ */ Symbol("RouteTitle");
var ParamsAsMap = class {
constructor(params) {
this.params = params || {};
}
has(name2) {
return Object.prototype.hasOwnProperty.call(this.params, name2);
}
get(name2) {
if (this.has(name2)) {
const v = this.params[name2];
return Array.isArray(v) ? v[0] : v;
}
return null;
}
getAll(name2) {
if (this.has(name2)) {
const v = this.params[name2];
return Array.isArray(v) ? v : [v];
}
return [];
}
get keys() {
return Object.keys(this.params);
}
};
function convertToParamMap(params) {
return new ParamsAsMap(params);
}
function defaultUrlMatcher(segments, segmentGroup, route) {
const parts = route.path.split("/");
if (parts.length > segments.length) {
return null;
}
if (route.pathMatch === "full" && (segmentGroup.hasChildren() || parts.length < segments.length)) {
return null;
}
const posParams = {};
for (let index2 = 0; index2 < parts.length; index2++) {
const part = parts[index2];
const segment = segments[index2];
const isParameter = part.startsWith(":");
if (isParameter) {
posParams[part.substring(1)] = segment;
} else if (part !== segment.path) {
return null;
}
}
return {
consumed: segments.slice(0, parts.length),
posParams
};
}
function shallowEqualArrays(a, b) {
if (a.length !== b.length)
return false;
for (let i = 0; i < a.length; ++i) {
if (!shallowEqual(a[i], b[i]))
return false;
}
return true;
}
function shallowEqual(a, b) {
const k1 = a ? getDataKeys(a) : void 0;
const k2 = b ? getDataKeys(b) : void 0;
if (!k1 || !k2 || k1.length != k2.length) {
return false;
}
let key2;
for (let i = 0; i < k1.length; i++) {
key2 = k1[i];
if (!equalArraysOrString(a[key2], b[key2])) {
return false;
}
}
return true;
}
function getDataKeys(obj) {
return [...Object.keys(obj), ...Object.getOwnPropertySymbols(obj)];
}
function equalArraysOrString(a, b) {
if (Array.isArray(a) && Array.isArray(b)) {
if (a.length !== b.length)
return false;
const aSorted = [...a].sort();
const bSorted = [...b].sort();
return aSorted.every((val2, index2) => bSorted[index2] === val2);
} else {
return a === b;
}
}
function last3(a) {
return a.length > 0 ? a[a.length - 1] : null;
}
function wrapIntoObservable(value2) {
if (isObservable(value2)) {
return value2;
}
if (isPromise2(value2)) {
return from(Promise.resolve(value2));
}
return of(value2);
}
var pathCompareMap = {
"exact": equalSegmentGroups,
"subset": containsSegmentGroup
};
var paramCompareMap = {
"exact": equalParams,
"subset": containsParams,
"ignored": () => true
};
function containsTree(container, containee, options) {
return pathCompareMap[options.paths](container.root, containee.root, options.matrixParams) && paramCompareMap[options.queryParams](container.queryParams, containee.queryParams) && !(options.fragment === "exact" && container.fragment !== containee.fragment);
}
function equalParams(container, containee) {
return shallowEqual(container, containee);
}
function equalSegmentGroups(container, containee, matrixParams) {
if (!equalPath(container.segments, containee.segments))
return false;
if (!matrixParamsMatch(container.segments, containee.segments, matrixParams)) {
return false;
}
if (container.numberOfChildren !== containee.numberOfChildren)
return false;
for (const c in containee.children) {
if (!container.children[c])
return false;
if (!equalSegmentGroups(container.children[c], containee.children[c], matrixParams))
return false;
}
return true;
}
function containsParams(container, containee) {
return Object.keys(containee).length <= Object.keys(container).length && Object.keys(containee).every((key2) => equalArraysOrString(container[key2], containee[key2]));
}
function containsSegmentGroup(container, containee, matrixParams) {
return containsSegmentGroupHelper(container, containee, containee.segments, matrixParams);
}
function containsSegmentGroupHelper(container, containee, containeePaths, matrixParams) {
if (container.segments.length > containeePaths.length) {
const current = container.segments.slice(0, containeePaths.length);
if (!equalPath(current, containeePaths))
return false;
if (containee.hasChildren())
return false;
if (!matrixParamsMatch(current, containeePaths, matrixParams))
return false;
return true;
} else if (container.segments.length === containeePaths.length) {
if (!equalPath(container.segments, containeePaths))
return false;
if (!matrixParamsMatch(container.segments, containeePaths, matrixParams))
return false;
for (const c in containee.children) {
if (!container.children[c])
return false;
if (!containsSegmentGroup(container.children[c], containee.children[c], matrixParams)) {
return false;
}
}
return true;
} else {
const current = containeePaths.slice(0, container.segments.length);
const next = containeePaths.slice(container.segments.length);
if (!equalPath(container.segments, current))
return false;
if (!matrixParamsMatch(container.segments, current, matrixParams))
return false;
if (!container.children[PRIMARY_OUTLET])
return false;
return containsSegmentGroupHelper(container.children[PRIMARY_OUTLET], containee, next, matrixParams);
}
}
function matrixParamsMatch(containerPaths, containeePaths, options) {
return containeePaths.every((containeeSegment, i) => {
return paramCompareMap[options](containerPaths[i].parameters, containeeSegment.parameters);
});
}
var UrlTree = class {
constructor(root = new UrlSegmentGroup([], {}), queryParams = {}, fragment = null) {
this.root = root;
this.queryParams = queryParams;
this.fragment = fragment;
if (typeof ngDevMode === "undefined" || ngDevMode) {
if (root.segments.length > 0) {
throw new RuntimeError(4015, "The root `UrlSegmentGroup` should not contain `segments`. Instead, these segments belong in the `children` so they can be associated with a named outlet.");
}
}
}
get queryParamMap() {
this._queryParamMap ??= convertToParamMap(this.queryParams);
return this._queryParamMap;
}
/** @docsNotRequired */
toString() {
return DEFAULT_SERIALIZER.serialize(this);
}
};
var UrlSegmentGroup = class {
constructor(segments, children) {
this.segments = segments;
this.children = children;
this.parent = null;
Object.values(children).forEach((v) => v.parent = this);
}
/** Whether the segment has child segments */
hasChildren() {
return this.numberOfChildren > 0;
}
/** Number of child segments */
get numberOfChildren() {
return Object.keys(this.children).length;
}
/** @docsNotRequired */
toString() {
return serializePaths(this);
}
};
var UrlSegment = class {
constructor(path, parameters) {
this.path = path;
this.parameters = parameters;
}
get parameterMap() {
this._parameterMap ??= convertToParamMap(this.parameters);
return this._parameterMap;
}
/** @docsNotRequired */
toString() {
return serializePath(this);
}
};
function equalSegments(as, bs) {
return equalPath(as, bs) && as.every((a, i) => shallowEqual(a.parameters, bs[i].parameters));
}
function equalPath(as, bs) {
if (as.length !== bs.length)
return false;
return as.every((a, i) => a.path === bs[i].path);
}
function mapChildrenIntoArray(segment, fn) {
let res = [];
Object.entries(segment.children).forEach(([childOutlet, child]) => {
if (childOutlet === PRIMARY_OUTLET) {
res = res.concat(fn(child, childOutlet));
}
});
Object.entries(segment.children).forEach(([childOutlet, child]) => {
if (childOutlet !== PRIMARY_OUTLET) {
res = res.concat(fn(child, childOutlet));
}
});
return res;
}
var _UrlSerializer = class _UrlSerializer {
};
_UrlSerializer.\u0275fac = function UrlSerializer_Factory(t) {
return new (t || _UrlSerializer)();
};
_UrlSerializer.\u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
token: _UrlSerializer,
factory: () => (() => new DefaultUrlSerializer())(),
providedIn: "root"
});
var UrlSerializer = _UrlSerializer;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(UrlSerializer, [{
type: Injectable,
args: [{
providedIn: "root",
useFactory: () => new DefaultUrlSerializer()
}]
}], null, null);
})();
var DefaultUrlSerializer = class {
/** Parses a url into a `UrlTree` */
parse(url) {
const p = new UrlParser(url);
return new UrlTree(p.parseRootSegment(), p.parseQueryParams(), p.parseFragment());
}
/** Converts a `UrlTree` into a url */
serialize(tree2) {
const segment = `/${serializeSegment(tree2.root, true)}`;
const query = serializeQueryParams(tree2.queryParams);
const fragment = typeof tree2.fragment === `string` ? `#${encodeUriFragment(tree2.fragment)}` : "";
return `${segment}${query}${fragment}`;
}
};
var DEFAULT_SERIALIZER = new DefaultUrlSerializer();
function serializePaths(segment) {
return segment.segments.map((p) => serializePath(p)).join("/");
}
function serializeSegment(segment, root) {
if (!segment.hasChildren()) {
return serializePaths(segment);
}
if (root) {
const primary = segment.children[PRIMARY_OUTLET] ? serializeSegment(segment.children[PRIMARY_OUTLET], false) : "";
const children = [];
Object.entries(segment.children).forEach(([k, v]) => {
if (k !== PRIMARY_OUTLET) {
children.push(`${k}:${serializeSegment(v, false)}`);
}
});
return children.length > 0 ? `${primary}(${children.join("//")})` : primary;
} else {
const children = mapChildrenIntoArray(segment, (v, k) => {
if (k === PRIMARY_OUTLET) {
return [serializeSegment(segment.children[PRIMARY_OUTLET], false)];
}
return [`${k}:${serializeSegment(v, false)}`];
});
if (Object.keys(segment.children).length === 1 && segment.children[PRIMARY_OUTLET] != null) {
return `${serializePaths(segment)}/${children[0]}`;
}
return `${serializePaths(segment)}/(${children.join("//")})`;
}
}
function encodeUriString(s) {
return encodeURIComponent(s).replace(/%40/g, "@").replace(/%3A/gi, ":").replace(/%24/g, "$").replace(/%2C/gi, ",");
}
function encodeUriQuery(s) {
return encodeUriString(s).replace(/%3B/gi, ";");
}
function encodeUriFragment(s) {
return encodeURI(s);
}
function encodeUriSegment(s) {
return encodeUriString(s).replace(/\(/g, "%28").replace(/\)/g, "%29").replace(/%26/gi, "&");
}
function decode(s) {
return decodeURIComponent(s);
}
function decodeQuery(s) {
return decode(s.replace(/\+/g, "%20"));
}
function serializePath(path) {
return `${encodeUriSegment(path.path)}${serializeMatrixParams(path.parameters)}`;
}
function serializeMatrixParams(params) {
return Object.entries(params).map(([key2, value2]) => `;${encodeUriSegment(key2)}=${encodeUriSegment(value2)}`).join("");
}
function serializeQueryParams(params) {
const strParams = Object.entries(params).map(([name2, value2]) => {
return Array.isArray(value2) ? value2.map((v) => `${encodeUriQuery(name2)}=${encodeUriQuery(v)}`).join("&") : `${encodeUriQuery(name2)}=${encodeUriQuery(value2)}`;
}).filter((s) => s);
return strParams.length ? `?${strParams.join("&")}` : "";
}
var SEGMENT_RE = /^[^\/()?;#]+/;
function matchSegments(str) {
const match2 = str.match(SEGMENT_RE);
return match2 ? match2[0] : "";
}
var MATRIX_PARAM_SEGMENT_RE = /^[^\/()?;=#]+/;
function matchMatrixKeySegments(str) {
const match2 = str.match(MATRIX_PARAM_SEGMENT_RE);
return match2 ? match2[0] : "";
}
var QUERY_PARAM_RE = /^[^=?&#]+/;
function matchQueryParams(str) {
const match2 = str.match(QUERY_PARAM_RE);
return match2 ? match2[0] : "";
}
var QUERY_PARAM_VALUE_RE = /^[^&#]+/;
function matchUrlQueryParamValue(str) {
const match2 = str.match(QUERY_PARAM_VALUE_RE);
return match2 ? match2[0] : "";
}
var UrlParser = class {
constructor(url) {
this.url = url;
this.remaining = url;
}
parseRootSegment() {
this.consumeOptional("/");
if (this.remaining === "" || this.peekStartsWith("?") || this.peekStartsWith("#")) {
return new UrlSegmentGroup([], {});
}
return new UrlSegmentGroup([], this.parseChildren());
}
parseQueryParams() {
const params = {};
if (this.consumeOptional("?")) {
do {
this.parseQueryParam(params);
} while (this.consumeOptional("&"));
}
return params;
}
parseFragment() {
return this.consumeOptional("#") ? decodeURIComponent(this.remaining) : null;
}
parseChildren() {
if (this.remaining === "") {
return {};
}
this.consumeOptional("/");
const segments = [];
if (!this.peekStartsWith("(")) {
segments.push(this.parseSegment());
}
while (this.peekStartsWith("/") && !this.peekStartsWith("//") && !this.peekStartsWith("/(")) {
this.capture("/");
segments.push(this.parseSegment());
}
let children = {};
if (this.peekStartsWith("/(")) {
this.capture("/");
children = this.parseParens(true);
}
let res = {};
if (this.peekStartsWith("(")) {
res = this.parseParens(false);
}
if (segments.length > 0 || Object.keys(children).length > 0) {
res[PRIMARY_OUTLET] = new UrlSegmentGroup(segments, children);
}
return res;
}
// parse a segment with its matrix parameters
// ie `name;k1=v1;k2`
parseSegment() {
const path = matchSegments(this.remaining);
if (path === "" && this.peekStartsWith(";")) {
throw new RuntimeError(4009, (typeof ngDevMode === "undefined" || ngDevMode) && `Empty path url segment cannot have parameters: '${this.remaining}'.`);
}
this.capture(path);
return new UrlSegment(decode(path), this.parseMatrixParams());
}
parseMatrixParams() {
const params = {};
while (this.consumeOptional(";")) {
this.parseParam(params);
}
return params;
}
parseParam(params) {
const key2 = matchMatrixKeySegments(this.remaining);
if (!key2) {
return;
}
this.capture(key2);
let value2 = "";
if (this.consumeOptional("=")) {
const valueMatch = matchSegments(this.remaining);
if (valueMatch) {
value2 = valueMatch;
this.capture(value2);
}
}
params[decode(key2)] = decode(value2);
}
// Parse a single query parameter `name[=value]`
parseQueryParam(params) {
const key2 = matchQueryParams(this.remaining);
if (!key2) {
return;
}
this.capture(key2);
let value2 = "";
if (this.consumeOptional("=")) {
const valueMatch = matchUrlQueryParamValue(this.remaining);
if (valueMatch) {
value2 = valueMatch;
this.capture(value2);
}
}
const decodedKey = decodeQuery(key2);
const decodedVal = decodeQuery(value2);
if (params.hasOwnProperty(decodedKey)) {
let currentVal = params[decodedKey];
if (!Array.isArray(currentVal)) {
currentVal = [currentVal];
params[decodedKey] = currentVal;
}
currentVal.push(decodedVal);
} else {
params[decodedKey] = decodedVal;
}
}
// parse `(a/b//outlet_name:c/d)`
parseParens(allowPrimary) {
const segments = {};
this.capture("(");
while (!this.consumeOptional(")") && this.remaining.length > 0) {
const path = matchSegments(this.remaining);
const next = this.remaining[path.length];
if (next !== "/" && next !== ")" && next !== ";") {
throw new RuntimeError(4010, (typeof ngDevMode === "undefined" || ngDevMode) && `Cannot parse url '${this.url}'`);
}
let outletName = void 0;
if (path.indexOf(":") > -1) {
outletName = path.slice(0, path.indexOf(":"));
this.capture(outletName);
this.capture(":");
} else if (allowPrimary) {
outletName = PRIMARY_OUTLET;
}
const children = this.parseChildren();
segments[outletName] = Object.keys(children).length === 1 ? children[PRIMARY_OUTLET] : new UrlSegmentGroup([], children);
this.consumeOptional("//");
}
return segments;
}
peekStartsWith(str) {
return this.remaining.startsWith(str);
}
// Consumes the prefix when it is present and returns whether it has been consumed
consumeOptional(str) {
if (this.peekStartsWith(str)) {
this.remaining = this.remaining.substring(str.length);
return true;
}
return false;
}
capture(str) {
if (!this.consumeOptional(str)) {
throw new RuntimeError(4011, (typeof ngDevMode === "undefined" || ngDevMode) && `Expected "${str}".`);
}
}
};
function createRoot(rootCandidate) {
return rootCandidate.segments.length > 0 ? new UrlSegmentGroup([], {
[PRIMARY_OUTLET]: rootCandidate
}) : rootCandidate;
}
function squashSegmentGroup(segmentGroup) {
const newChildren = {};
for (const [childOutlet, child] of Object.entries(segmentGroup.children)) {
const childCandidate = squashSegmentGroup(child);
if (childOutlet === PRIMARY_OUTLET && childCandidate.segments.length === 0 && childCandidate.hasChildren()) {
for (const [grandChildOutlet, grandChild] of Object.entries(childCandidate.children)) {
newChildren[grandChildOutlet] = grandChild;
}
} else if (childCandidate.segments.length > 0 || childCandidate.hasChildren()) {
newChildren[childOutlet] = childCandidate;
}
}
const s = new UrlSegmentGroup(segmentGroup.segments, newChildren);
return mergeTrivialChildren(s);
}
function mergeTrivialChildren(s) {
if (s.numberOfChildren === 1 && s.children[PRIMARY_OUTLET]) {
const c = s.children[PRIMARY_OUTLET];
return new UrlSegmentGroup(s.segments.concat(c.segments), c.children);
}
return s;
}
function isUrlTree(v) {
return v instanceof UrlTree;
}
function createUrlTreeFromSnapshot(relativeTo, commands, queryParams = null, fragment = null) {
const relativeToUrlSegmentGroup = createSegmentGroupFromRoute(relativeTo);
return createUrlTreeFromSegmentGroup(relativeToUrlSegmentGroup, commands, queryParams, fragment);
}
function createSegmentGroupFromRoute(route) {
let targetGroup;
function createSegmentGroupFromRouteRecursive(currentRoute) {
const childOutlets = {};
for (const childSnapshot of currentRoute.children) {
const root = createSegmentGroupFromRouteRecursive(childSnapshot);
childOutlets[childSnapshot.outlet] = root;
}
const segmentGroup = new UrlSegmentGroup(currentRoute.url, childOutlets);
if (currentRoute === route) {
targetGroup = segmentGroup;
}
return segmentGroup;
}
const rootCandidate = createSegmentGroupFromRouteRecursive(route.root);
const rootSegmentGroup = createRoot(rootCandidate);
return targetGroup ?? rootSegmentGroup;
}
function createUrlTreeFromSegmentGroup(relativeTo, commands, queryParams, fragment) {
let root = relativeTo;
while (root.parent) {
root = root.parent;
}
if (commands.length === 0) {
return tree(root, root, root, queryParams, fragment);
}
const nav = computeNavigation(commands);
if (nav.toRoot()) {
return tree(root, root, new UrlSegmentGroup([], {}), queryParams, fragment);
}
const position2 = findStartingPositionForTargetGroup(nav, root, relativeTo);
const newSegmentGroup = position2.processChildren ? updateSegmentGroupChildren(position2.segmentGroup, position2.index, nav.commands) : updateSegmentGroup(position2.segmentGroup, position2.index, nav.commands);
return tree(root, position2.segmentGroup, newSegmentGroup, queryParams, fragment);
}
function isMatrixParams(command) {
return typeof command === "object" && command != null && !command.outlets && !command.segmentPath;
}
function isCommandWithOutlets(command) {
return typeof command === "object" && command != null && command.outlets;
}
function tree(oldRoot, oldSegmentGroup, newSegmentGroup, queryParams, fragment) {
let qp = {};
if (queryParams) {
Object.entries(queryParams).forEach(([name2, value2]) => {
qp[name2] = Array.isArray(value2) ? value2.map((v) => `${v}`) : `${value2}`;
});
}
let rootCandidate;
if (oldRoot === oldSegmentGroup) {
rootCandidate = newSegmentGroup;
} else {
rootCandidate = replaceSegment(oldRoot, oldSegmentGroup, newSegmentGroup);
}
const newRoot = createRoot(squashSegmentGroup(rootCandidate));
return new UrlTree(newRoot, qp, fragment);
}
function replaceSegment(current, oldSegment, newSegment) {
const children = {};
Object.entries(current.children).forEach(([outletName, c]) => {
if (c === oldSegment) {
children[outletName] = newSegment;
} else {
children[outletName] = replaceSegment(c, oldSegment, newSegment);
}
});
return new UrlSegmentGroup(current.segments, children);
}
var Navigation = class {
constructor(isAbsolute, numberOfDoubleDots, commands) {
this.isAbsolute = isAbsolute;
this.numberOfDoubleDots = numberOfDoubleDots;
this.commands = commands;
if (isAbsolute && commands.length > 0 && isMatrixParams(commands[0])) {
throw new RuntimeError(4003, (typeof ngDevMode === "undefined" || ngDevMode) && "Root segment cannot have matrix parameters");
}
const cmdWithOutlet = commands.find(isCommandWithOutlets);
if (cmdWithOutlet && cmdWithOutlet !== last3(commands)) {
throw new RuntimeError(4004, (typeof ngDevMode === "undefined" || ngDevMode) && "{outlets:{}} has to be the last command");
}
}
toRoot() {
return this.isAbsolute && this.commands.length === 1 && this.commands[0] == "/";
}
};
function computeNavigation(commands) {
if (typeof commands[0] === "string" && commands.length === 1 && commands[0] === "/") {
return new Navigation(true, 0, commands);
}
let numberOfDoubleDots = 0;
let isAbsolute = false;
const res = commands.reduce((res2, cmd, cmdIdx) => {
if (typeof cmd === "object" && cmd != null) {
if (cmd.outlets) {
const outlets = {};
Object.entries(cmd.outlets).forEach(([name2, commands2]) => {
outlets[name2] = typeof commands2 === "string" ? commands2.split("/") : commands2;
});
return [...res2, {
outlets
}];
}
if (cmd.segmentPath) {
return [...res2, cmd.segmentPath];
}
}
if (!(typeof cmd === "string")) {
return [...res2, cmd];
}
if (cmdIdx === 0) {
cmd.split("/").forEach((urlPart, partIndex) => {
if (partIndex == 0 && urlPart === ".") {
} else if (partIndex == 0 && urlPart === "") {
isAbsolute = true;
} else if (urlPart === "..") {
numberOfDoubleDots++;
} else if (urlPart != "") {
res2.push(urlPart);
}
});
return res2;
}
return [...res2, cmd];
}, []);
return new Navigation(isAbsolute, numberOfDoubleDots, res);
}
var Position = class {
constructor(segmentGroup, processChildren, index2) {
this.segmentGroup = segmentGroup;
this.processChildren = processChildren;
this.index = index2;
}
};
function findStartingPositionForTargetGroup(nav, root, target) {
if (nav.isAbsolute) {
return new Position(root, true, 0);
}
if (!target) {
return new Position(root, false, NaN);
}
if (target.parent === null) {
return new Position(target, true, 0);
}
const modifier = isMatrixParams(nav.commands[0]) ? 0 : 1;
const index2 = target.segments.length - 1 + modifier;
return createPositionApplyingDoubleDots(target, index2, nav.numberOfDoubleDots);
}
function createPositionApplyingDoubleDots(group, index2, numberOfDoubleDots) {
let g = group;
let ci = index2;
let dd = numberOfDoubleDots;
while (dd > ci) {
dd -= ci;
g = g.parent;
if (!g) {
throw new RuntimeError(4005, (typeof ngDevMode === "undefined" || ngDevMode) && "Invalid number of '../'");
}
ci = g.segments.length;
}
return new Position(g, false, ci - dd);
}
function getOutlets(commands) {
if (isCommandWithOutlets(commands[0])) {
return commands[0].outlets;
}
return {
[PRIMARY_OUTLET]: commands
};
}
function updateSegmentGroup(segmentGroup, startIndex, commands) {
segmentGroup ??= new UrlSegmentGroup([], {});
if (segmentGroup.segments.length === 0 && segmentGroup.hasChildren()) {
return updateSegmentGroupChildren(segmentGroup, startIndex, commands);
}
const m = prefixedWith(segmentGroup, startIndex, commands);
const slicedCommands = commands.slice(m.commandIndex);
if (m.match && m.pathIndex < segmentGroup.segments.length) {
const g = new UrlSegmentGroup(segmentGroup.segments.slice(0, m.pathIndex), {});
g.children[PRIMARY_OUTLET] = new UrlSegmentGroup(segmentGroup.segments.slice(m.pathIndex), segmentGroup.children);
return updateSegmentGroupChildren(g, 0, slicedCommands);
} else if (m.match && slicedCommands.length === 0) {
return new UrlSegmentGroup(segmentGroup.segments, {});
} else if (m.match && !segmentGroup.hasChildren()) {
return createNewSegmentGroup(segmentGroup, startIndex, commands);
} else if (m.match) {
return updateSegmentGroupChildren(segmentGroup, 0, slicedCommands);
} else {
return createNewSegmentGroup(segmentGroup, startIndex, commands);
}
}
function updateSegmentGroupChildren(segmentGroup, startIndex, commands) {
if (commands.length === 0) {
return new UrlSegmentGroup(segmentGroup.segments, {});
} else {
const outlets = getOutlets(commands);
const children = {};
if (Object.keys(outlets).some((o) => o !== PRIMARY_OUTLET) && segmentGroup.children[PRIMARY_OUTLET] && segmentGroup.numberOfChildren === 1 && segmentGroup.children[PRIMARY_OUTLET].segments.length === 0) {
const childrenOfEmptyChild = updateSegmentGroupChildren(segmentGroup.children[PRIMARY_OUTLET], startIndex, commands);
return new UrlSegmentGroup(segmentGroup.segments, childrenOfEmptyChild.children);
}
Object.entries(outlets).forEach(([outlet, commands2]) => {
if (typeof commands2 === "string") {
commands2 = [commands2];
}
if (commands2 !== null) {
children[outlet] = updateSegmentGroup(segmentGroup.children[outlet], startIndex, commands2);
}
});
Object.entries(segmentGroup.children).forEach(([childOutlet, child]) => {
if (outlets[childOutlet] === void 0) {
children[childOutlet] = child;
}
});
return new UrlSegmentGroup(segmentGroup.segments, children);
}
}
function prefixedWith(segmentGroup, startIndex, commands) {
let currentCommandIndex = 0;
let currentPathIndex = startIndex;
const noMatch2 = {
match: false,
pathIndex: 0,
commandIndex: 0
};
while (currentPathIndex < segmentGroup.segments.length) {
if (currentCommandIndex >= commands.length)
return noMatch2;
const path = segmentGroup.segments[currentPathIndex];
const command = commands[currentCommandIndex];
if (isCommandWithOutlets(command)) {
break;
}
const curr = `${command}`;
const next = currentCommandIndex < commands.length - 1 ? commands[currentCommandIndex + 1] : null;
if (currentPathIndex > 0 && curr === void 0)
break;
if (curr && next && typeof next === "object" && next.outlets === void 0) {
if (!compare(curr, next, path))
return noMatch2;
currentCommandIndex += 2;
} else {
if (!compare(curr, {}, path))
return noMatch2;
currentCommandIndex++;
}
currentPathIndex++;
}
return {
match: true,
pathIndex: currentPathIndex,
commandIndex: currentCommandIndex
};
}
function createNewSegmentGroup(segmentGroup, startIndex, commands) {
const paths = segmentGroup.segments.slice(0, startIndex);
let i = 0;
while (i < commands.length) {
const command = commands[i];
if (isCommandWithOutlets(command)) {
const children = createNewSegmentChildren(command.outlets);
return new UrlSegmentGroup(paths, children);
}
if (i === 0 && isMatrixParams(commands[0])) {
const p = segmentGroup.segments[startIndex];
paths.push(new UrlSegment(p.path, stringify2(commands[0])));
i++;
continue;
}
const curr = isCommandWithOutlets(command) ? command.outlets[PRIMARY_OUTLET] : `${command}`;
const next = i < commands.length - 1 ? commands[i + 1] : null;
if (curr && next && isMatrixParams(next)) {
paths.push(new UrlSegment(curr, stringify2(next)));
i += 2;
} else {
paths.push(new UrlSegment(curr, {}));
i++;
}
}
return new UrlSegmentGroup(paths, {});
}
function createNewSegmentChildren(outlets) {
const children = {};
Object.entries(outlets).forEach(([outlet, commands]) => {
if (typeof commands === "string") {
commands = [commands];
}
if (commands !== null) {
children[outlet] = createNewSegmentGroup(new UrlSegmentGroup([], {}), 0, commands);
}
});
return children;
}
function stringify2(params) {
const res = {};
Object.entries(params).forEach(([k, v]) => res[k] = `${v}`);
return res;
}
function compare(path, params, segment) {
return path == segment.path && shallowEqual(params, segment.parameters);
}
var IMPERATIVE_NAVIGATION = "imperative";
var EventType;
(function(EventType2) {
EventType2[EventType2["NavigationStart"] = 0] = "NavigationStart";
EventType2[EventType2["NavigationEnd"] = 1] = "NavigationEnd";
EventType2[EventType2["NavigationCancel"] = 2] = "NavigationCancel";
EventType2[EventType2["NavigationError"] = 3] = "NavigationError";
EventType2[EventType2["RoutesRecognized"] = 4] = "RoutesRecognized";
EventType2[EventType2["ResolveStart"] = 5] = "ResolveStart";
EventType2[EventType2["ResolveEnd"] = 6] = "ResolveEnd";
EventType2[EventType2["GuardsCheckStart"] = 7] = "GuardsCheckStart";
EventType2[EventType2["GuardsCheckEnd"] = 8] = "GuardsCheckEnd";
EventType2[EventType2["RouteConfigLoadStart"] = 9] = "RouteConfigLoadStart";
EventType2[EventType2["RouteConfigLoadEnd"] = 10] = "RouteConfigLoadEnd";
EventType2[EventType2["ChildActivationStart"] = 11] = "ChildActivationStart";
EventType2[EventType2["ChildActivationEnd"] = 12] = "ChildActivationEnd";
EventType2[EventType2["ActivationStart"] = 13] = "ActivationStart";
EventType2[EventType2["ActivationEnd"] = 14] = "ActivationEnd";
EventType2[EventType2["Scroll"] = 15] = "Scroll";
EventType2[EventType2["NavigationSkipped"] = 16] = "NavigationSkipped";
})(EventType || (EventType = {}));
var RouterEvent = class {
constructor(id, url) {
this.id = id;
this.url = url;
}
};
var NavigationStart = class extends RouterEvent {
constructor(id, url, navigationTrigger = "imperative", restoredState = null) {
super(id, url);
this.type = EventType.NavigationStart;
this.navigationTrigger = navigationTrigger;
this.restoredState = restoredState;
}
/** @docsNotRequired */
toString() {
return `NavigationStart(id: ${this.id}, url: '${this.url}')`;
}
};
var NavigationEnd = class extends RouterEvent {
constructor(id, url, urlAfterRedirects) {
super(id, url);
this.urlAfterRedirects = urlAfterRedirects;
this.type = EventType.NavigationEnd;
}
/** @docsNotRequired */
toString() {
return `NavigationEnd(id: ${this.id}, url: '${this.url}', urlAfterRedirects: '${this.urlAfterRedirects}')`;
}
};
var NavigationCancellationCode;
(function(NavigationCancellationCode2) {
NavigationCancellationCode2[NavigationCancellationCode2["Redirect"] = 0] = "Redirect";
NavigationCancellationCode2[NavigationCancellationCode2["SupersededByNewNavigation"] = 1] = "SupersededByNewNavigation";
NavigationCancellationCode2[NavigationCancellationCode2["NoDataFromResolver"] = 2] = "NoDataFromResolver";
NavigationCancellationCode2[NavigationCancellationCode2["GuardRejected"] = 3] = "GuardRejected";
})(NavigationCancellationCode || (NavigationCancellationCode = {}));
var NavigationSkippedCode;
(function(NavigationSkippedCode2) {
NavigationSkippedCode2[NavigationSkippedCode2["IgnoredSameUrlNavigation"] = 0] = "IgnoredSameUrlNavigation";
NavigationSkippedCode2[NavigationSkippedCode2["IgnoredByUrlHandlingStrategy"] = 1] = "IgnoredByUrlHandlingStrategy";
})(NavigationSkippedCode || (NavigationSkippedCode = {}));
var NavigationCancel = class extends RouterEvent {
constructor(id, url, reason, code) {
super(id, url);
this.reason = reason;
this.code = code;
this.type = EventType.NavigationCancel;
}
/** @docsNotRequired */
toString() {
return `NavigationCancel(id: ${this.id}, url: '${this.url}')`;
}
};
var NavigationSkipped = class extends RouterEvent {
constructor(id, url, reason, code) {
super(id, url);
this.reason = reason;
this.code = code;
this.type = EventType.NavigationSkipped;
}
};
var NavigationError = class extends RouterEvent {
constructor(id, url, error, target) {
super(id, url);
this.error = error;
this.target = target;
this.type = EventType.NavigationError;
}
/** @docsNotRequired */
toString() {
return `NavigationError(id: ${this.id}, url: '${this.url}', error: ${this.error})`;
}
};
var RoutesRecognized = class extends RouterEvent {
constructor(id, url, urlAfterRedirects, state) {
super(id, url);
this.urlAfterRedirects = urlAfterRedirects;
this.state = state;
this.type = EventType.RoutesRecognized;
}
/** @docsNotRequired */
toString() {
return `RoutesRecognized(id: ${this.id}, url: '${this.url}', urlAfterRedirects: '${this.urlAfterRedirects}', state: ${this.state})`;
}
};
var GuardsCheckStart = class extends RouterEvent {
constructor(id, url, urlAfterRedirects, state) {
super(id, url);
this.urlAfterRedirects = urlAfterRedirects;
this.state = state;
this.type = EventType.GuardsCheckStart;
}
toString() {
return `GuardsCheckStart(id: ${this.id}, url: '${this.url}', urlAfterRedirects: '${this.urlAfterRedirects}', state: ${this.state})`;
}
};
var GuardsCheckEnd = class extends RouterEvent {
constructor(id, url, urlAfterRedirects, state, shouldActivate) {
super(id, url);
this.urlAfterRedirects = urlAfterRedirects;
this.state = state;
this.shouldActivate = shouldActivate;
this.type = EventType.GuardsCheckEnd;
}
toString() {
return `GuardsCheckEnd(id: ${this.id}, url: '${this.url}', urlAfterRedirects: '${this.urlAfterRedirects}', state: ${this.state}, shouldActivate: ${this.shouldActivate})`;
}
};
var ResolveStart = class extends RouterEvent {
constructor(id, url, urlAfterRedirects, state) {
super(id, url);
this.urlAfterRedirects = urlAfterRedirects;
this.state = state;
this.type = EventType.ResolveStart;
}
toString() {
return `ResolveStart(id: ${this.id}, url: '${this.url}', urlAfterRedirects: '${this.urlAfterRedirects}', state: ${this.state})`;
}
};
var ResolveEnd = class extends RouterEvent {
constructor(id, url, urlAfterRedirects, state) {
super(id, url);
this.urlAfterRedirects = urlAfterRedirects;
this.state = state;
this.type = EventType.ResolveEnd;
}
toString() {
return `ResolveEnd(id: ${this.id}, url: '${this.url}', urlAfterRedirects: '${this.urlAfterRedirects}', state: ${this.state})`;
}
};
var RouteConfigLoadStart = class {
constructor(route) {
this.route = route;
this.type = EventType.RouteConfigLoadStart;
}
toString() {
return `RouteConfigLoadStart(path: ${this.route.path})`;
}
};
var RouteConfigLoadEnd = class {
constructor(route) {
this.route = route;
this.type = EventType.RouteConfigLoadEnd;
}
toString() {
return `RouteConfigLoadEnd(path: ${this.route.path})`;
}
};
var ChildActivationStart = class {
constructor(snapshot) {
this.snapshot = snapshot;
this.type = EventType.ChildActivationStart;
}
toString() {
const path = this.snapshot.routeConfig && this.snapshot.routeConfig.path || "";
return `ChildActivationStart(path: '${path}')`;
}
};
var ChildActivationEnd = class {
constructor(snapshot) {
this.snapshot = snapshot;
this.type = EventType.ChildActivationEnd;
}
toString() {
const path = this.snapshot.routeConfig && this.snapshot.routeConfig.path || "";
return `ChildActivationEnd(path: '${path}')`;
}
};
var ActivationStart = class {
constructor(snapshot) {
this.snapshot = snapshot;
this.type = EventType.ActivationStart;
}
toString() {
const path = this.snapshot.routeConfig && this.snapshot.routeConfig.path || "";
return `ActivationStart(path: '${path}')`;
}
};
var ActivationEnd = class {
constructor(snapshot) {
this.snapshot = snapshot;
this.type = EventType.ActivationEnd;
}
toString() {
const path = this.snapshot.routeConfig && this.snapshot.routeConfig.path || "";
return `ActivationEnd(path: '${path}')`;
}
};
var Scroll = class {
constructor(routerEvent, position2, anchor) {
this.routerEvent = routerEvent;
this.position = position2;
this.anchor = anchor;
this.type = EventType.Scroll;
}
toString() {
const pos = this.position ? `${this.position[0]}, ${this.position[1]}` : null;
return `Scroll(anchor: '${this.anchor}', position: '${pos}')`;
}
};
var BeforeActivateRoutes = class {
};
var RedirectRequest = class {
constructor(url) {
this.url = url;
}
};
function stringifyEvent(routerEvent) {
switch (routerEvent.type) {
case EventType.ActivationEnd:
return `ActivationEnd(path: '${routerEvent.snapshot.routeConfig?.path || ""}')`;
case EventType.ActivationStart:
return `ActivationStart(path: '${routerEvent.snapshot.routeConfig?.path || ""}')`;
case EventType.ChildActivationEnd:
return `ChildActivationEnd(path: '${routerEvent.snapshot.routeConfig?.path || ""}')`;
case EventType.ChildActivationStart:
return `ChildActivationStart(path: '${routerEvent.snapshot.routeConfig?.path || ""}')`;
case EventType.GuardsCheckEnd:
return `GuardsCheckEnd(id: ${routerEvent.id}, url: '${routerEvent.url}', urlAfterRedirects: '${routerEvent.urlAfterRedirects}', state: ${routerEvent.state}, shouldActivate: ${routerEvent.shouldActivate})`;
case EventType.GuardsCheckStart:
return `GuardsCheckStart(id: ${routerEvent.id}, url: '${routerEvent.url}', urlAfterRedirects: '${routerEvent.urlAfterRedirects}', state: ${routerEvent.state})`;
case EventType.NavigationCancel:
return `NavigationCancel(id: ${routerEvent.id}, url: '${routerEvent.url}')`;
case EventType.NavigationSkipped:
return `NavigationSkipped(id: ${routerEvent.id}, url: '${routerEvent.url}')`;
case EventType.NavigationEnd:
return `NavigationEnd(id: ${routerEvent.id}, url: '${routerEvent.url}', urlAfterRedirects: '${routerEvent.urlAfterRedirects}')`;
case EventType.NavigationError:
return `NavigationError(id: ${routerEvent.id}, url: '${routerEvent.url}', error: ${routerEvent.error})`;
case EventType.NavigationStart:
return `NavigationStart(id: ${routerEvent.id}, url: '${routerEvent.url}')`;
case EventType.ResolveEnd:
return `ResolveEnd(id: ${routerEvent.id}, url: '${routerEvent.url}', urlAfterRedirects: '${routerEvent.urlAfterRedirects}', state: ${routerEvent.state})`;
case EventType.ResolveStart:
return `ResolveStart(id: ${routerEvent.id}, url: '${routerEvent.url}', urlAfterRedirects: '${routerEvent.urlAfterRedirects}', state: ${routerEvent.state})`;
case EventType.RouteConfigLoadEnd:
return `RouteConfigLoadEnd(path: ${routerEvent.route.path})`;
case EventType.RouteConfigLoadStart:
return `RouteConfigLoadStart(path: ${routerEvent.route.path})`;
case EventType.RoutesRecognized:
return `RoutesRecognized(id: ${routerEvent.id}, url: '${routerEvent.url}', urlAfterRedirects: '${routerEvent.urlAfterRedirects}', state: ${routerEvent.state})`;
case EventType.Scroll:
const pos = routerEvent.position ? `${routerEvent.position[0]}, ${routerEvent.position[1]}` : null;
return `Scroll(anchor: '${routerEvent.anchor}', position: '${pos}')`;
}
}
var OutletContext = class {
constructor() {
this.outlet = null;
this.route = null;
this.injector = null;
this.children = new ChildrenOutletContexts();
this.attachRef = null;
}
};
var _ChildrenOutletContexts = class _ChildrenOutletContexts {
constructor() {
this.contexts = /* @__PURE__ */ new Map();
}
/** Called when a `RouterOutlet` directive is instantiated */
onChildOutletCreated(childName, outlet) {
const context2 = this.getOrCreateContext(childName);
context2.outlet = outlet;
this.contexts.set(childName, context2);
}
/**
* Called when a `RouterOutlet` directive is destroyed.
* We need to keep the context as the outlet could be destroyed inside a NgIf and might be
* re-created later.
*/
onChildOutletDestroyed(childName) {
const context2 = this.getContext(childName);
if (context2) {
context2.outlet = null;
context2.attachRef = null;
}
}
/**
* Called when the corresponding route is deactivated during navigation.
* Because the component get destroyed, all children outlet are destroyed.
*/
onOutletDeactivated() {
const contexts = this.contexts;
this.contexts = /* @__PURE__ */ new Map();
return contexts;
}
onOutletReAttached(contexts) {
this.contexts = contexts;
}
getOrCreateContext(childName) {
let context2 = this.getContext(childName);
if (!context2) {
context2 = new OutletContext();
this.contexts.set(childName, context2);
}
return context2;
}
getContext(childName) {
return this.contexts.get(childName) || null;
}
};
_ChildrenOutletContexts.\u0275fac = function ChildrenOutletContexts_Factory(t) {
return new (t || _ChildrenOutletContexts)();
};
_ChildrenOutletContexts.\u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
token: _ChildrenOutletContexts,
factory: _ChildrenOutletContexts.\u0275fac,
providedIn: "root"
});
var ChildrenOutletContexts = _ChildrenOutletContexts;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(ChildrenOutletContexts, [{
type: Injectable,
args: [{
providedIn: "root"
}]
}], null, null);
})();
var Tree = class {
constructor(root) {
this._root = root;
}
get root() {
return this._root.value;
}
/**
* @internal
*/
parent(t) {
const p = this.pathFromRoot(t);
return p.length > 1 ? p[p.length - 2] : null;
}
/**
* @internal
*/
children(t) {
const n = findNode(t, this._root);
return n ? n.children.map((t2) => t2.value) : [];
}
/**
* @internal
*/
firstChild(t) {
const n = findNode(t, this._root);
return n && n.children.length > 0 ? n.children[0].value : null;
}
/**
* @internal
*/
siblings(t) {
const p = findPath(t, this._root);
if (p.length < 2)
return [];
const c = p[p.length - 2].children.map((c2) => c2.value);
return c.filter((cc) => cc !== t);
}
/**
* @internal
*/
pathFromRoot(t) {
return findPath(t, this._root).map((s) => s.value);
}
};
function findNode(value2, node) {
if (value2 === node.value)
return node;
for (const child of node.children) {
const node2 = findNode(value2, child);
if (node2)
return node2;
}
return null;
}
function findPath(value2, node) {
if (value2 === node.value)
return [node];
for (const child of node.children) {
const path = findPath(value2, child);
if (path.length) {
path.unshift(node);
return path;
}
}
return [];
}
var TreeNode = class {
constructor(value2, children) {
this.value = value2;
this.children = children;
}
toString() {
return `TreeNode(${this.value})`;
}
};
function nodeChildrenAsMap(node) {
const map2 = {};
if (node) {
node.children.forEach((child) => map2[child.value.outlet] = child);
}
return map2;
}
var RouterState = class extends Tree {
/** @internal */
constructor(root, snapshot) {
super(root);
this.snapshot = snapshot;
setRouterState(this, root);
}
toString() {
return this.snapshot.toString();
}
};
function createEmptyState(rootComponent) {
const snapshot = createEmptyStateSnapshot(rootComponent);
const emptyUrl = new BehaviorSubject([new UrlSegment("", {})]);
const emptyParams = new BehaviorSubject({});
const emptyData = new BehaviorSubject({});
const emptyQueryParams = new BehaviorSubject({});
const fragment = new BehaviorSubject("");
const activated = new ActivatedRoute(emptyUrl, emptyParams, emptyQueryParams, fragment, emptyData, PRIMARY_OUTLET, rootComponent, snapshot.root);
activated.snapshot = snapshot.root;
return new RouterState(new TreeNode(activated, []), snapshot);
}
function createEmptyStateSnapshot(rootComponent) {
const emptyParams = {};
const emptyData = {};
const emptyQueryParams = {};
const fragment = "";
const activated = new ActivatedRouteSnapshot([], emptyParams, emptyQueryParams, fragment, emptyData, PRIMARY_OUTLET, rootComponent, null, {});
return new RouterStateSnapshot("", new TreeNode(activated, []));
}
var ActivatedRoute = class {
/** @internal */
constructor(urlSubject, paramsSubject, queryParamsSubject, fragmentSubject, dataSubject, outlet, component, futureSnapshot) {
this.urlSubject = urlSubject;
this.paramsSubject = paramsSubject;
this.queryParamsSubject = queryParamsSubject;
this.fragmentSubject = fragmentSubject;
this.dataSubject = dataSubject;
this.outlet = outlet;
this.component = component;
this._futureSnapshot = futureSnapshot;
this.title = this.dataSubject?.pipe(map((d) => d[RouteTitleKey])) ?? of(void 0);
this.url = urlSubject;
this.params = paramsSubject;
this.queryParams = queryParamsSubject;
this.fragment = fragmentSubject;
this.data = dataSubject;
}
/** The configuration used to match this route. */
get routeConfig() {
return this._futureSnapshot.routeConfig;
}
/** The root of the router state. */
get root() {
return this._routerState.root;
}
/** The parent of this route in the router state tree. */
get parent() {
return this._routerState.parent(this);
}
/** The first child of this route in the router state tree. */
get firstChild() {
return this._routerState.firstChild(this);
}
/** The children of this route in the router state tree. */
get children() {
return this._routerState.children(this);
}
/** The path from the root of the router state tree to this route. */
get pathFromRoot() {
return this._routerState.pathFromRoot(this);
}
/**
* An Observable that contains a map of the required and optional parameters
* specific to the route.
* The map supports retrieving single and multiple values from the same parameter.
*/
get paramMap() {
this._paramMap ??= this.params.pipe(map((p) => convertToParamMap(p)));
return this._paramMap;
}
/**
* An Observable that contains a map of the query parameters available to all routes.
* The map supports retrieving single and multiple values from the query parameter.
*/
get queryParamMap() {
this._queryParamMap ??= this.queryParams.pipe(map((p) => convertToParamMap(p)));
return this._queryParamMap;
}
toString() {
return this.snapshot ? this.snapshot.toString() : `Future(${this._futureSnapshot})`;
}
};
function getInherited(route, parent2, paramsInheritanceStrategy = "emptyOnly") {
let inherited;
const {
routeConfig
} = route;
if (parent2 !== null && (paramsInheritanceStrategy === "always" || // inherit parent data if route is empty path
routeConfig?.path === "" || // inherit parent data if parent was componentless
!parent2.component && !parent2.routeConfig?.loadComponent)) {
inherited = {
params: __spreadValues(__spreadValues({}, parent2.params), route.params),
data: __spreadValues(__spreadValues({}, parent2.data), route.data),
resolve: __spreadValues(__spreadValues(__spreadValues(__spreadValues({}, route.data), parent2.data), routeConfig?.data), route._resolvedData)
};
} else {
inherited = {
params: __spreadValues({}, route.params),
data: __spreadValues({}, route.data),
resolve: __spreadValues(__spreadValues({}, route.data), route._resolvedData ?? {})
};
}
if (routeConfig && hasStaticTitle(routeConfig)) {
inherited.resolve[RouteTitleKey] = routeConfig.title;
}
return inherited;
}
var ActivatedRouteSnapshot = class {
/** The resolved route title */
get title() {
return this.data?.[RouteTitleKey];
}
/** @internal */
constructor(url, params, queryParams, fragment, data2, outlet, component, routeConfig, resolve) {
this.url = url;
this.params = params;
this.queryParams = queryParams;
this.fragment = fragment;
this.data = data2;
this.outlet = outlet;
this.component = component;
this.routeConfig = routeConfig;
this._resolve = resolve;
}
/** The root of the router state */
get root() {
return this._routerState.root;
}
/** The parent of this route in the router state tree */
get parent() {
return this._routerState.parent(this);
}
/** The first child of this route in the router state tree */
get firstChild() {
return this._routerState.firstChild(this);
}
/** The children of this route in the router state tree */
get children() {
return this._routerState.children(this);
}
/** The path from the root of the router state tree to this route */
get pathFromRoot() {
return this._routerState.pathFromRoot(this);
}
get paramMap() {
this._paramMap ??= convertToParamMap(this.params);
return this._paramMap;
}
get queryParamMap() {
this._queryParamMap ??= convertToParamMap(this.queryParams);
return this._queryParamMap;
}
toString() {
const url = this.url.map((segment) => segment.toString()).join("/");
const matched = this.routeConfig ? this.routeConfig.path : "";
return `Route(url:'${url}', path:'${matched}')`;
}
};
var RouterStateSnapshot = class extends Tree {
/** @internal */
constructor(url, root) {
super(root);
this.url = url;
setRouterState(this, root);
}
toString() {
return serializeNode(this._root);
}
};
function setRouterState(state, node) {
node.value._routerState = state;
node.children.forEach((c) => setRouterState(state, c));
}
function serializeNode(node) {
const c = node.children.length > 0 ? ` { ${node.children.map(serializeNode).join(", ")} } ` : "";
return `${node.value}${c}`;
}
function advanceActivatedRoute(route) {
if (route.snapshot) {
const currentSnapshot = route.snapshot;
const nextSnapshot = route._futureSnapshot;
route.snapshot = nextSnapshot;
if (!shallowEqual(currentSnapshot.queryParams, nextSnapshot.queryParams)) {
route.queryParamsSubject.next(nextSnapshot.queryParams);
}
if (currentSnapshot.fragment !== nextSnapshot.fragment) {
route.fragmentSubject.next(nextSnapshot.fragment);
}
if (!shallowEqual(currentSnapshot.params, nextSnapshot.params)) {
route.paramsSubject.next(nextSnapshot.params);
}
if (!shallowEqualArrays(currentSnapshot.url, nextSnapshot.url)) {
route.urlSubject.next(nextSnapshot.url);
}
if (!shallowEqual(currentSnapshot.data, nextSnapshot.data)) {
route.dataSubject.next(nextSnapshot.data);
}
} else {
route.snapshot = route._futureSnapshot;
route.dataSubject.next(route._futureSnapshot.data);
}
}
function equalParamsAndUrlSegments(a, b) {
const equalUrlParams = shallowEqual(a.params, b.params) && equalSegments(a.url, b.url);
const parentsMismatch = !a.parent !== !b.parent;
return equalUrlParams && !parentsMismatch && (!a.parent || equalParamsAndUrlSegments(a.parent, b.parent));
}
function hasStaticTitle(config2) {
return typeof config2.title === "string" || config2.title === null;
}
var _RouterOutlet = class _RouterOutlet {
constructor() {
this.activated = null;
this._activatedRoute = null;
this.name = PRIMARY_OUTLET;
this.activateEvents = new EventEmitter();
this.deactivateEvents = new EventEmitter();
this.attachEvents = new EventEmitter();
this.detachEvents = new EventEmitter();
this.parentContexts = inject(ChildrenOutletContexts);
this.location = inject(ViewContainerRef);
this.changeDetector = inject(ChangeDetectorRef);
this.environmentInjector = inject(EnvironmentInjector);
this.inputBinder = inject(INPUT_BINDER, {
optional: true
});
this.supportsBindingToComponentInputs = true;
}
/** @internal */
get activatedComponentRef() {
return this.activated;
}
/** @nodoc */
ngOnChanges(changes) {
if (changes["name"]) {
const {
firstChange,
previousValue
} = changes["name"];
if (firstChange) {
return;
}
if (this.isTrackedInParentContexts(previousValue)) {
this.deactivate();
this.parentContexts.onChildOutletDestroyed(previousValue);
}
this.initializeOutletWithName();
}
}
/** @nodoc */
ngOnDestroy() {
if (this.isTrackedInParentContexts(this.name)) {
this.parentContexts.onChildOutletDestroyed(this.name);
}
this.inputBinder?.unsubscribeFromRouteData(this);
}
isTrackedInParentContexts(outletName) {
return this.parentContexts.getContext(outletName)?.outlet === this;
}
/** @nodoc */
ngOnInit() {
this.initializeOutletWithName();
}
initializeOutletWithName() {
this.parentContexts.onChildOutletCreated(this.name, this);
if (this.activated) {
return;
}
const context2 = this.parentContexts.getContext(this.name);
if (context2?.route) {
if (context2.attachRef) {
this.attach(context2.attachRef, context2.route);
} else {
this.activateWith(context2.route, context2.injector);
}
}
}
get isActivated() {
return !!this.activated;
}
/**
* @returns The currently activated component instance.
* @throws An error if the outlet is not activated.
*/
get component() {
if (!this.activated)
throw new RuntimeError(4012, (typeof ngDevMode === "undefined" || ngDevMode) && "Outlet is not activated");
return this.activated.instance;
}
get activatedRoute() {
if (!this.activated)
throw new RuntimeError(4012, (typeof ngDevMode === "undefined" || ngDevMode) && "Outlet is not activated");
return this._activatedRoute;
}
get activatedRouteData() {
if (this._activatedRoute) {
return this._activatedRoute.snapshot.data;
}
return {};
}
/**
* Called when the `RouteReuseStrategy` instructs to detach the subtree
*/
detach() {
if (!this.activated)
throw new RuntimeError(4012, (typeof ngDevMode === "undefined" || ngDevMode) && "Outlet is not activated");
this.location.detach();
const cmp = this.activated;
this.activated = null;
this._activatedRoute = null;
this.detachEvents.emit(cmp.instance);
return cmp;
}
/**
* Called when the `RouteReuseStrategy` instructs to re-attach a previously detached subtree
*/
attach(ref, activatedRoute) {
this.activated = ref;
this._activatedRoute = activatedRoute;
this.location.insert(ref.hostView);
this.inputBinder?.bindActivatedRouteToOutletComponent(this);
this.attachEvents.emit(ref.instance);
}
deactivate() {
if (this.activated) {
const c = this.component;
this.activated.destroy();
this.activated = null;
this._activatedRoute = null;
this.deactivateEvents.emit(c);
}
}
activateWith(activatedRoute, environmentInjector) {
if (this.isActivated) {
throw new RuntimeError(4013, (typeof ngDevMode === "undefined" || ngDevMode) && "Cannot activate an already activated outlet");
}
this._activatedRoute = activatedRoute;
const location2 = this.location;
const snapshot = activatedRoute.snapshot;
const component = snapshot.component;
const childContexts = this.parentContexts.getOrCreateContext(this.name).children;
const injector = new OutletInjector(activatedRoute, childContexts, location2.injector);
this.activated = location2.createComponent(component, {
index: location2.length,
injector,
environmentInjector: environmentInjector ?? this.environmentInjector
});
this.changeDetector.markForCheck();
this.inputBinder?.bindActivatedRouteToOutletComponent(this);
this.activateEvents.emit(this.activated.instance);
}
};
_RouterOutlet.\u0275fac = function RouterOutlet_Factory(t) {
return new (t || _RouterOutlet)();
};
_RouterOutlet.\u0275dir = /* @__PURE__ */ \u0275\u0275defineDirective({
type: _RouterOutlet,
selectors: [["router-outlet"]],
inputs: {
name: "name"
},
outputs: {
activateEvents: "activate",
deactivateEvents: "deactivate",
attachEvents: "attach",
detachEvents: "detach"
},
exportAs: ["outlet"],
standalone: true,
features: [\u0275\u0275NgOnChangesFeature]
});
var RouterOutlet = _RouterOutlet;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(RouterOutlet, [{
type: Directive,
args: [{
selector: "router-outlet",
exportAs: "outlet",
standalone: true
}]
}], null, {
name: [{
type: Input
}],
activateEvents: [{
type: Output,
args: ["activate"]
}],
deactivateEvents: [{
type: Output,
args: ["deactivate"]
}],
attachEvents: [{
type: Output,
args: ["attach"]
}],
detachEvents: [{
type: Output,
args: ["detach"]
}]
});
})();
var OutletInjector = class _OutletInjector {
/**
* This injector has a special handing for the `ActivatedRoute` and
* `ChildrenOutletContexts` tokens: it returns corresponding values for those
* tokens dynamically. This behavior is different from the regular injector logic,
* when we initialize and store a value, which is later returned for all inject
* requests.
*
* In some cases (e.g. when using `@defer`), this dynamic behavior requires special
* handling. This function allows to identify an instance of the `OutletInjector` and
* create an instance of it without referring to the class itself (so this logic can
* be invoked from the `core` package). This helps to retain dynamic behavior for the
* mentioned tokens.
*
* Note: it's a temporary solution and we should explore how to support this case better.
*/
__ngOutletInjector(parentInjector) {
return new _OutletInjector(this.route, this.childContexts, parentInjector);
}
constructor(route, childContexts, parent2) {
this.route = route;
this.childContexts = childContexts;
this.parent = parent2;
}
get(token, notFoundValue) {
if (token === ActivatedRoute) {
return this.route;
}
if (token === ChildrenOutletContexts) {
return this.childContexts;
}
return this.parent.get(token, notFoundValue);
}
};
var INPUT_BINDER = new InjectionToken("");
var _RoutedComponentInputBinder = class _RoutedComponentInputBinder {
constructor() {
this.outletDataSubscriptions = /* @__PURE__ */ new Map();
}
bindActivatedRouteToOutletComponent(outlet) {
this.unsubscribeFromRouteData(outlet);
this.subscribeToRouteData(outlet);
}
unsubscribeFromRouteData(outlet) {
this.outletDataSubscriptions.get(outlet)?.unsubscribe();
this.outletDataSubscriptions.delete(outlet);
}
subscribeToRouteData(outlet) {
const {
activatedRoute
} = outlet;
const dataSubscription = combineLatest([activatedRoute.queryParams, activatedRoute.params, activatedRoute.data]).pipe(switchMap(([queryParams, params, data2], index2) => {
data2 = __spreadValues(__spreadValues(__spreadValues({}, queryParams), params), data2);
if (index2 === 0) {
return of(data2);
}
return Promise.resolve(data2);
})).subscribe((data2) => {
if (!outlet.isActivated || !outlet.activatedComponentRef || outlet.activatedRoute !== activatedRoute || activatedRoute.component === null) {
this.unsubscribeFromRouteData(outlet);
return;
}
const mirror = reflectComponentType(activatedRoute.component);
if (!mirror) {
this.unsubscribeFromRouteData(outlet);
return;
}
for (const {
templateName
} of mirror.inputs) {
outlet.activatedComponentRef.setInput(templateName, data2[templateName]);
}
});
this.outletDataSubscriptions.set(outlet, dataSubscription);
}
};
_RoutedComponentInputBinder.\u0275fac = function RoutedComponentInputBinder_Factory(t) {
return new (t || _RoutedComponentInputBinder)();
};
_RoutedComponentInputBinder.\u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
token: _RoutedComponentInputBinder,
factory: _RoutedComponentInputBinder.\u0275fac
});
var RoutedComponentInputBinder = _RoutedComponentInputBinder;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(RoutedComponentInputBinder, [{
type: Injectable
}], null, null);
})();
function createRouterState(routeReuseStrategy, curr, prevState) {
const root = createNode(routeReuseStrategy, curr._root, prevState ? prevState._root : void 0);
return new RouterState(root, curr);
}
function createNode(routeReuseStrategy, curr, prevState) {
if (prevState && routeReuseStrategy.shouldReuseRoute(curr.value, prevState.value.snapshot)) {
const value2 = prevState.value;
value2._futureSnapshot = curr.value;
const children = createOrReuseChildren(routeReuseStrategy, curr, prevState);
return new TreeNode(value2, children);
} else {
if (routeReuseStrategy.shouldAttach(curr.value)) {
const detachedRouteHandle = routeReuseStrategy.retrieve(curr.value);
if (detachedRouteHandle !== null) {
const tree2 = detachedRouteHandle.route;
tree2.value._futureSnapshot = curr.value;
tree2.children = curr.children.map((c) => createNode(routeReuseStrategy, c));
return tree2;
}
}
const value2 = createActivatedRoute(curr.value);
const children = curr.children.map((c) => createNode(routeReuseStrategy, c));
return new TreeNode(value2, children);
}
}
function createOrReuseChildren(routeReuseStrategy, curr, prevState) {
return curr.children.map((child) => {
for (const p of prevState.children) {
if (routeReuseStrategy.shouldReuseRoute(child.value, p.value.snapshot)) {
return createNode(routeReuseStrategy, child, p);
}
}
return createNode(routeReuseStrategy, child);
});
}
function createActivatedRoute(c) {
return new ActivatedRoute(new BehaviorSubject(c.url), new BehaviorSubject(c.params), new BehaviorSubject(c.queryParams), new BehaviorSubject(c.fragment), new BehaviorSubject(c.data), c.outlet, c.component, c);
}
var NAVIGATION_CANCELING_ERROR = "ngNavigationCancelingError";
function redirectingNavigationError(urlSerializer, redirect) {
const {
redirectTo,
navigationBehaviorOptions
} = isUrlTree(redirect) ? {
redirectTo: redirect,
navigationBehaviorOptions: void 0
} : redirect;
const error = navigationCancelingError(ngDevMode && `Redirecting to "${urlSerializer.serialize(redirectTo)}"`, NavigationCancellationCode.Redirect);
error.url = redirectTo;
error.navigationBehaviorOptions = navigationBehaviorOptions;
return error;
}
function navigationCancelingError(message, code) {
const error = new Error(`NavigationCancelingError: ${message || ""}`);
error[NAVIGATION_CANCELING_ERROR] = true;
error.cancellationCode = code;
return error;
}
function isRedirectingNavigationCancelingError(error) {
return isNavigationCancelingError(error) && isUrlTree(error.url);
}
function isNavigationCancelingError(error) {
return !!error && error[NAVIGATION_CANCELING_ERROR];
}
var _\u0275EmptyOutletComponent = class _\u0275EmptyOutletComponent {
};
_\u0275EmptyOutletComponent.\u0275fac = function \u0275EmptyOutletComponent_Factory(t) {
return new (t || _\u0275EmptyOutletComponent)();
};
_\u0275EmptyOutletComponent.\u0275cmp = /* @__PURE__ */ \u0275\u0275defineComponent({
type: _\u0275EmptyOutletComponent,
selectors: [["ng-component"]],
standalone: true,
features: [\u0275\u0275StandaloneFeature],
decls: 1,
vars: 0,
template: function _EmptyOutletComponent_Template(rf, ctx) {
if (rf & 1) {
\u0275\u0275element(0, "router-outlet");
}
},
dependencies: [RouterOutlet],
encapsulation: 2
});
var \u0275EmptyOutletComponent = _\u0275EmptyOutletComponent;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(\u0275EmptyOutletComponent, [{
type: Component,
args: [{
template: `<router-outlet></router-outlet>`,
imports: [RouterOutlet],
standalone: true
}]
}], null, null);
})();
function getOrCreateRouteInjectorIfNeeded(route, currentInjector) {
if (route.providers && !route._injector) {
route._injector = createEnvironmentInjector(route.providers, currentInjector, `Route: ${route.path}`);
}
return route._injector ?? currentInjector;
}
function validateConfig(config2, parentPath = "", requireStandaloneComponents = false) {
for (let i = 0; i < config2.length; i++) {
const route = config2[i];
const fullPath = getFullPath(parentPath, route);
validateNode(route, fullPath, requireStandaloneComponents);
}
}
function assertStandalone(fullPath, component) {
if (component && isNgModule(component)) {
throw new RuntimeError(4014, `Invalid configuration of route '${fullPath}'. You are using 'loadComponent' with a module, but it must be used with standalone components. Use 'loadChildren' instead.`);
} else if (component && !isStandalone(component)) {
throw new RuntimeError(4014, `Invalid configuration of route '${fullPath}'. The component must be standalone.`);
}
}
function validateNode(route, fullPath, requireStandaloneComponents) {
if (typeof ngDevMode === "undefined" || ngDevMode) {
if (!route) {
throw new RuntimeError(4014, `
Invalid configuration of route '${fullPath}': Encountered undefined route.
The reason might be an extra comma.
Example:
const routes: Routes = [
{ path: '', redirectTo: '/dashboard', pathMatch: 'full' },
{ path: 'dashboard', component: DashboardComponent },, << two commas
{ path: 'detail/:id', component: HeroDetailComponent }
];
`);
}
if (Array.isArray(route)) {
throw new RuntimeError(4014, `Invalid configuration of route '${fullPath}': Array cannot be specified`);
}
if (!route.redirectTo && !route.component && !route.loadComponent && !route.children && !route.loadChildren && route.outlet && route.outlet !== PRIMARY_OUTLET) {
throw new RuntimeError(4014, `Invalid configuration of route '${fullPath}': a componentless route without children or loadChildren cannot have a named outlet set`);
}
if (route.redirectTo && route.children) {
throw new RuntimeError(4014, `Invalid configuration of route '${fullPath}': redirectTo and children cannot be used together`);
}
if (route.redirectTo && route.loadChildren) {
throw new RuntimeError(4014, `Invalid configuration of route '${fullPath}': redirectTo and loadChildren cannot be used together`);
}
if (route.children && route.loadChildren) {
throw new RuntimeError(4014, `Invalid configuration of route '${fullPath}': children and loadChildren cannot be used together`);
}
if (route.redirectTo && (route.component || route.loadComponent)) {
throw new RuntimeError(4014, `Invalid configuration of route '${fullPath}': redirectTo and component/loadComponent cannot be used together`);
}
if (route.component && route.loadComponent) {
throw new RuntimeError(4014, `Invalid configuration of route '${fullPath}': component and loadComponent cannot be used together`);
}
if (route.redirectTo && route.canActivate) {
throw new RuntimeError(4014, `Invalid configuration of route '${fullPath}': redirectTo and canActivate cannot be used together. Redirects happen before activation so canActivate will never be executed.`);
}
if (route.path && route.matcher) {
throw new RuntimeError(4014, `Invalid configuration of route '${fullPath}': path and matcher cannot be used together`);
}
if (route.redirectTo === void 0 && !route.component && !route.loadComponent && !route.children && !route.loadChildren) {
throw new RuntimeError(4014, `Invalid configuration of route '${fullPath}'. One of the following must be provided: component, loadComponent, redirectTo, children or loadChildren`);
}
if (route.path === void 0 && route.matcher === void 0) {
throw new RuntimeError(4014, `Invalid configuration of route '${fullPath}': routes must have either a path or a matcher specified`);
}
if (typeof route.path === "string" && route.path.charAt(0) === "/") {
throw new RuntimeError(4014, `Invalid configuration of route '${fullPath}': path cannot start with a slash`);
}
if (route.path === "" && route.redirectTo !== void 0 && route.pathMatch === void 0) {
const exp = `The default value of 'pathMatch' is 'prefix', but often the intent is to use 'full'.`;
throw new RuntimeError(4014, `Invalid configuration of route '{path: "${fullPath}", redirectTo: "${route.redirectTo}"}': please provide 'pathMatch'. ${exp}`);
}
if (requireStandaloneComponents) {
assertStandalone(fullPath, route.component);
}
}
if (route.children) {
validateConfig(route.children, fullPath, requireStandaloneComponents);
}
}
function getFullPath(parentPath, currentRoute) {
if (!currentRoute) {
return parentPath;
}
if (!parentPath && !currentRoute.path) {
return "";
} else if (parentPath && !currentRoute.path) {
return `${parentPath}/`;
} else if (!parentPath && currentRoute.path) {
return currentRoute.path;
} else {
return `${parentPath}/${currentRoute.path}`;
}
}
function standardizeConfig(r) {
const children = r.children && r.children.map(standardizeConfig);
const c = children ? __spreadProps(__spreadValues({}, r), {
children
}) : __spreadValues({}, r);
if (!c.component && !c.loadComponent && (children || c.loadChildren) && c.outlet && c.outlet !== PRIMARY_OUTLET) {
c.component = \u0275EmptyOutletComponent;
}
return c;
}
function getOutlet(route) {
return route.outlet || PRIMARY_OUTLET;
}
function sortByMatchingOutlets(routes2, outletName) {
const sortedConfig = routes2.filter((r) => getOutlet(r) === outletName);
sortedConfig.push(...routes2.filter((r) => getOutlet(r) !== outletName));
return sortedConfig;
}
function getClosestRouteInjector(snapshot) {
if (!snapshot)
return null;
if (snapshot.routeConfig?._injector) {
return snapshot.routeConfig._injector;
}
for (let s = snapshot.parent; s; s = s.parent) {
const route = s.routeConfig;
if (route?._loadedInjector)
return route._loadedInjector;
if (route?._injector)
return route._injector;
}
return null;
}
var warnedAboutUnsupportedInputBinding = false;
var activateRoutes = (rootContexts, routeReuseStrategy, forwardEvent, inputBindingEnabled) => map((t) => {
new ActivateRoutes(routeReuseStrategy, t.targetRouterState, t.currentRouterState, forwardEvent, inputBindingEnabled).activate(rootContexts);
return t;
});
var ActivateRoutes = class {
constructor(routeReuseStrategy, futureState, currState, forwardEvent, inputBindingEnabled) {
this.routeReuseStrategy = routeReuseStrategy;
this.futureState = futureState;
this.currState = currState;
this.forwardEvent = forwardEvent;
this.inputBindingEnabled = inputBindingEnabled;
}
activate(parentContexts) {
const futureRoot = this.futureState._root;
const currRoot = this.currState ? this.currState._root : null;
this.deactivateChildRoutes(futureRoot, currRoot, parentContexts);
advanceActivatedRoute(this.futureState.root);
this.activateChildRoutes(futureRoot, currRoot, parentContexts);
}
// De-activate the child route that are not re-used for the future state
deactivateChildRoutes(futureNode, currNode, contexts) {
const children = nodeChildrenAsMap(currNode);
futureNode.children.forEach((futureChild) => {
const childOutletName = futureChild.value.outlet;
this.deactivateRoutes(futureChild, children[childOutletName], contexts);
delete children[childOutletName];
});
Object.values(children).forEach((v) => {
this.deactivateRouteAndItsChildren(v, contexts);
});
}
deactivateRoutes(futureNode, currNode, parentContext) {
const future = futureNode.value;
const curr = currNode ? currNode.value : null;
if (future === curr) {
if (future.component) {
const context2 = parentContext.getContext(future.outlet);
if (context2) {
this.deactivateChildRoutes(futureNode, currNode, context2.children);
}
} else {
this.deactivateChildRoutes(futureNode, currNode, parentContext);
}
} else {
if (curr) {
this.deactivateRouteAndItsChildren(currNode, parentContext);
}
}
}
deactivateRouteAndItsChildren(route, parentContexts) {
if (route.value.component && this.routeReuseStrategy.shouldDetach(route.value.snapshot)) {
this.detachAndStoreRouteSubtree(route, parentContexts);
} else {
this.deactivateRouteAndOutlet(route, parentContexts);
}
}
detachAndStoreRouteSubtree(route, parentContexts) {
const context2 = parentContexts.getContext(route.value.outlet);
const contexts = context2 && route.value.component ? context2.children : parentContexts;
const children = nodeChildrenAsMap(route);
for (const treeNode of Object.values(children)) {
this.deactivateRouteAndItsChildren(treeNode, contexts);
}
if (context2 && context2.outlet) {
const componentRef = context2.outlet.detach();
const contexts2 = context2.children.onOutletDeactivated();
this.routeReuseStrategy.store(route.value.snapshot, {
componentRef,
route,
contexts: contexts2
});
}
}
deactivateRouteAndOutlet(route, parentContexts) {
const context2 = parentContexts.getContext(route.value.outlet);
const contexts = context2 && route.value.component ? context2.children : parentContexts;
const children = nodeChildrenAsMap(route);
for (const treeNode of Object.values(children)) {
this.deactivateRouteAndItsChildren(treeNode, contexts);
}
if (context2) {
if (context2.outlet) {
context2.outlet.deactivate();
context2.children.onOutletDeactivated();
}
context2.attachRef = null;
context2.route = null;
}
}
activateChildRoutes(futureNode, currNode, contexts) {
const children = nodeChildrenAsMap(currNode);
futureNode.children.forEach((c) => {
this.activateRoutes(c, children[c.value.outlet], contexts);
this.forwardEvent(new ActivationEnd(c.value.snapshot));
});
if (futureNode.children.length) {
this.forwardEvent(new ChildActivationEnd(futureNode.value.snapshot));
}
}
activateRoutes(futureNode, currNode, parentContexts) {
const future = futureNode.value;
const curr = currNode ? currNode.value : null;
advanceActivatedRoute(future);
if (future === curr) {
if (future.component) {
const context2 = parentContexts.getOrCreateContext(future.outlet);
this.activateChildRoutes(futureNode, currNode, context2.children);
} else {
this.activateChildRoutes(futureNode, currNode, parentContexts);
}
} else {
if (future.component) {
const context2 = parentContexts.getOrCreateContext(future.outlet);
if (this.routeReuseStrategy.shouldAttach(future.snapshot)) {
const stored = this.routeReuseStrategy.retrieve(future.snapshot);
this.routeReuseStrategy.store(future.snapshot, null);
context2.children.onOutletReAttached(stored.contexts);
context2.attachRef = stored.componentRef;
context2.route = stored.route.value;
if (context2.outlet) {
context2.outlet.attach(stored.componentRef, stored.route.value);
}
advanceActivatedRoute(stored.route.value);
this.activateChildRoutes(futureNode, null, context2.children);
} else {
const injector = getClosestRouteInjector(future.snapshot);
context2.attachRef = null;
context2.route = future;
context2.injector = injector;
if (context2.outlet) {
context2.outlet.activateWith(future, context2.injector);
}
this.activateChildRoutes(futureNode, null, context2.children);
}
} else {
this.activateChildRoutes(futureNode, null, parentContexts);
}
}
if (typeof ngDevMode === "undefined" || ngDevMode) {
const context2 = parentContexts.getOrCreateContext(future.outlet);
const outlet = context2.outlet;
if (outlet && this.inputBindingEnabled && !outlet.supportsBindingToComponentInputs && !warnedAboutUnsupportedInputBinding) {
console.warn(`'withComponentInputBinding' feature is enabled but this application is using an outlet that may not support binding to component inputs.`);
warnedAboutUnsupportedInputBinding = true;
}
}
}
};
var CanActivate = class {
constructor(path) {
this.path = path;
this.route = this.path[this.path.length - 1];
}
};
var CanDeactivate = class {
constructor(component, route) {
this.component = component;
this.route = route;
}
};
function getAllRouteGuards(future, curr, parentContexts) {
const futureRoot = future._root;
const currRoot = curr ? curr._root : null;
return getChildRouteGuards(futureRoot, currRoot, parentContexts, [futureRoot.value]);
}
function getCanActivateChild(p) {
const canActivateChild = p.routeConfig ? p.routeConfig.canActivateChild : null;
if (!canActivateChild || canActivateChild.length === 0)
return null;
return {
node: p,
guards: canActivateChild
};
}
function getTokenOrFunctionIdentity(tokenOrFunction, injector) {
const NOT_FOUND2 = Symbol();
const result = injector.get(tokenOrFunction, NOT_FOUND2);
if (result === NOT_FOUND2) {
if (typeof tokenOrFunction === "function" && !isInjectable(tokenOrFunction)) {
return tokenOrFunction;
} else {
return injector.get(tokenOrFunction);
}
}
return result;
}
function getChildRouteGuards(futureNode, currNode, contexts, futurePath, checks = {
canDeactivateChecks: [],
canActivateChecks: []
}) {
const prevChildren = nodeChildrenAsMap(currNode);
futureNode.children.forEach((c) => {
getRouteGuards(c, prevChildren[c.value.outlet], contexts, futurePath.concat([c.value]), checks);
delete prevChildren[c.value.outlet];
});
Object.entries(prevChildren).forEach(([k, v]) => deactivateRouteAndItsChildren(v, contexts.getContext(k), checks));
return checks;
}
function getRouteGuards(futureNode, currNode, parentContexts, futurePath, checks = {
canDeactivateChecks: [],
canActivateChecks: []
}) {
const future = futureNode.value;
const curr = currNode ? currNode.value : null;
const context2 = parentContexts ? parentContexts.getContext(futureNode.value.outlet) : null;
if (curr && future.routeConfig === curr.routeConfig) {
const shouldRun = shouldRunGuardsAndResolvers(curr, future, future.routeConfig.runGuardsAndResolvers);
if (shouldRun) {
checks.canActivateChecks.push(new CanActivate(futurePath));
} else {
future.data = curr.data;
future._resolvedData = curr._resolvedData;
}
if (future.component) {
getChildRouteGuards(futureNode, currNode, context2 ? context2.children : null, futurePath, checks);
} else {
getChildRouteGuards(futureNode, currNode, parentContexts, futurePath, checks);
}
if (shouldRun && context2 && context2.outlet && context2.outlet.isActivated) {
checks.canDeactivateChecks.push(new CanDeactivate(context2.outlet.component, curr));
}
} else {
if (curr) {
deactivateRouteAndItsChildren(currNode, context2, checks);
}
checks.canActivateChecks.push(new CanActivate(futurePath));
if (future.component) {
getChildRouteGuards(futureNode, null, context2 ? context2.children : null, futurePath, checks);
} else {
getChildRouteGuards(futureNode, null, parentContexts, futurePath, checks);
}
}
return checks;
}
function shouldRunGuardsAndResolvers(curr, future, mode) {
if (typeof mode === "function") {
return mode(curr, future);
}
switch (mode) {
case "pathParamsChange":
return !equalPath(curr.url, future.url);
case "pathParamsOrQueryParamsChange":
return !equalPath(curr.url, future.url) || !shallowEqual(curr.queryParams, future.queryParams);
case "always":
return true;
case "paramsOrQueryParamsChange":
return !equalParamsAndUrlSegments(curr, future) || !shallowEqual(curr.queryParams, future.queryParams);
case "paramsChange":
default:
return !equalParamsAndUrlSegments(curr, future);
}
}
function deactivateRouteAndItsChildren(route, context2, checks) {
const children = nodeChildrenAsMap(route);
const r = route.value;
Object.entries(children).forEach(([childName, node]) => {
if (!r.component) {
deactivateRouteAndItsChildren(node, context2, checks);
} else if (context2) {
deactivateRouteAndItsChildren(node, context2.children.getContext(childName), checks);
} else {
deactivateRouteAndItsChildren(node, null, checks);
}
});
if (!r.component) {
checks.canDeactivateChecks.push(new CanDeactivate(null, r));
} else if (context2 && context2.outlet && context2.outlet.isActivated) {
checks.canDeactivateChecks.push(new CanDeactivate(context2.outlet.component, r));
} else {
checks.canDeactivateChecks.push(new CanDeactivate(null, r));
}
}
function isFunction2(v) {
return typeof v === "function";
}
function isBoolean(v) {
return typeof v === "boolean";
}
function isCanLoad(guard) {
return guard && isFunction2(guard.canLoad);
}
function isCanActivate(guard) {
return guard && isFunction2(guard.canActivate);
}
function isCanActivateChild(guard) {
return guard && isFunction2(guard.canActivateChild);
}
function isCanDeactivate(guard) {
return guard && isFunction2(guard.canDeactivate);
}
function isCanMatch(guard) {
return guard && isFunction2(guard.canMatch);
}
function isEmptyError(e) {
return e instanceof EmptyError || e?.name === "EmptyError";
}
var INITIAL_VALUE = /* @__PURE__ */ Symbol("INITIAL_VALUE");
function prioritizedGuardValue() {
return switchMap((obs) => {
return combineLatest(obs.map((o) => o.pipe(take(1), startWith(INITIAL_VALUE)))).pipe(map((results) => {
for (const result of results) {
if (result === true) {
continue;
} else if (result === INITIAL_VALUE) {
return INITIAL_VALUE;
} else if (result === false || result instanceof UrlTree) {
return result;
}
}
return true;
}), filter((item) => item !== INITIAL_VALUE), take(1));
});
}
function checkGuards(injector, forwardEvent) {
return mergeMap((t) => {
const {
targetSnapshot,
currentSnapshot,
guards: {
canActivateChecks,
canDeactivateChecks
}
} = t;
if (canDeactivateChecks.length === 0 && canActivateChecks.length === 0) {
return of(__spreadProps(__spreadValues({}, t), {
guardsResult: true
}));
}
return runCanDeactivateChecks(canDeactivateChecks, targetSnapshot, currentSnapshot, injector).pipe(mergeMap((canDeactivate) => {
return canDeactivate && isBoolean(canDeactivate) ? runCanActivateChecks(targetSnapshot, canActivateChecks, injector, forwardEvent) : of(canDeactivate);
}), map((guardsResult) => __spreadProps(__spreadValues({}, t), {
guardsResult
})));
});
}
function runCanDeactivateChecks(checks, futureRSS, currRSS, injector) {
return from(checks).pipe(mergeMap((check) => runCanDeactivate(check.component, check.route, currRSS, futureRSS, injector)), first((result) => {
return result !== true;
}, true));
}
function runCanActivateChecks(futureSnapshot, checks, injector, forwardEvent) {
return from(checks).pipe(concatMap((check) => {
return concat(fireChildActivationStart(check.route.parent, forwardEvent), fireActivationStart(check.route, forwardEvent), runCanActivateChild(futureSnapshot, check.path, injector), runCanActivate(futureSnapshot, check.route, injector));
}), first((result) => {
return result !== true;
}, true));
}
function fireActivationStart(snapshot, forwardEvent) {
if (snapshot !== null && forwardEvent) {
forwardEvent(new ActivationStart(snapshot));
}
return of(true);
}
function fireChildActivationStart(snapshot, forwardEvent) {
if (snapshot !== null && forwardEvent) {
forwardEvent(new ChildActivationStart(snapshot));
}
return of(true);
}
function runCanActivate(futureRSS, futureARS, injector) {
const canActivate = futureARS.routeConfig ? futureARS.routeConfig.canActivate : null;
if (!canActivate || canActivate.length === 0)
return of(true);
const canActivateObservables = canActivate.map((canActivate2) => {
return defer(() => {
const closestInjector = getClosestRouteInjector(futureARS) ?? injector;
const guard = getTokenOrFunctionIdentity(canActivate2, closestInjector);
const guardVal = isCanActivate(guard) ? guard.canActivate(futureARS, futureRSS) : runInInjectionContext(closestInjector, () => guard(futureARS, futureRSS));
return wrapIntoObservable(guardVal).pipe(first());
});
});
return of(canActivateObservables).pipe(prioritizedGuardValue());
}
function runCanActivateChild(futureRSS, path, injector) {
const futureARS = path[path.length - 1];
const canActivateChildGuards = path.slice(0, path.length - 1).reverse().map((p) => getCanActivateChild(p)).filter((_) => _ !== null);
const canActivateChildGuardsMapped = canActivateChildGuards.map((d) => {
return defer(() => {
const guardsMapped = d.guards.map((canActivateChild) => {
const closestInjector = getClosestRouteInjector(d.node) ?? injector;
const guard = getTokenOrFunctionIdentity(canActivateChild, closestInjector);
const guardVal = isCanActivateChild(guard) ? guard.canActivateChild(futureARS, futureRSS) : runInInjectionContext(closestInjector, () => guard(futureARS, futureRSS));
return wrapIntoObservable(guardVal).pipe(first());
});
return of(guardsMapped).pipe(prioritizedGuardValue());
});
});
return of(canActivateChildGuardsMapped).pipe(prioritizedGuardValue());
}
function runCanDeactivate(component, currARS, currRSS, futureRSS, injector) {
const canDeactivate = currARS && currARS.routeConfig ? currARS.routeConfig.canDeactivate : null;
if (!canDeactivate || canDeactivate.length === 0)
return of(true);
const canDeactivateObservables = canDeactivate.map((c) => {
const closestInjector = getClosestRouteInjector(currARS) ?? injector;
const guard = getTokenOrFunctionIdentity(c, closestInjector);
const guardVal = isCanDeactivate(guard) ? guard.canDeactivate(component, currARS, currRSS, futureRSS) : runInInjectionContext(closestInjector, () => guard(component, currARS, currRSS, futureRSS));
return wrapIntoObservable(guardVal).pipe(first());
});
return of(canDeactivateObservables).pipe(prioritizedGuardValue());
}
function runCanLoadGuards(injector, route, segments, urlSerializer) {
const canLoad = route.canLoad;
if (canLoad === void 0 || canLoad.length === 0) {
return of(true);
}
const canLoadObservables = canLoad.map((injectionToken) => {
const guard = getTokenOrFunctionIdentity(injectionToken, injector);
const guardVal = isCanLoad(guard) ? guard.canLoad(route, segments) : runInInjectionContext(injector, () => guard(route, segments));
return wrapIntoObservable(guardVal);
});
return of(canLoadObservables).pipe(prioritizedGuardValue(), redirectIfUrlTree(urlSerializer));
}
function redirectIfUrlTree(urlSerializer) {
return pipe(tap((result) => {
if (!isUrlTree(result))
return;
throw redirectingNavigationError(urlSerializer, result);
}), map((result) => result === true));
}
function runCanMatchGuards(injector, route, segments, urlSerializer) {
const canMatch = route.canMatch;
if (!canMatch || canMatch.length === 0)
return of(true);
const canMatchObservables = canMatch.map((injectionToken) => {
const guard = getTokenOrFunctionIdentity(injectionToken, injector);
const guardVal = isCanMatch(guard) ? guard.canMatch(route, segments) : runInInjectionContext(injector, () => guard(route, segments));
return wrapIntoObservable(guardVal);
});
return of(canMatchObservables).pipe(prioritizedGuardValue(), redirectIfUrlTree(urlSerializer));
}
var NoMatch = class {
constructor(segmentGroup) {
this.segmentGroup = segmentGroup || null;
}
};
var AbsoluteRedirect = class extends Error {
constructor(urlTree) {
super();
this.urlTree = urlTree;
}
};
function noMatch$1(segmentGroup) {
return throwError(new NoMatch(segmentGroup));
}
function namedOutletsRedirect(redirectTo) {
return throwError(new RuntimeError(4e3, (typeof ngDevMode === "undefined" || ngDevMode) && `Only absolute redirects can have named outlets. redirectTo: '${redirectTo}'`));
}
function canLoadFails(route) {
return throwError(navigationCancelingError((typeof ngDevMode === "undefined" || ngDevMode) && `Cannot load children because the guard of the route "path: '${route.path}'" returned false`, NavigationCancellationCode.GuardRejected));
}
var ApplyRedirects = class {
constructor(urlSerializer, urlTree) {
this.urlSerializer = urlSerializer;
this.urlTree = urlTree;
}
lineralizeSegments(route, urlTree) {
let res = [];
let c = urlTree.root;
while (true) {
res = res.concat(c.segments);
if (c.numberOfChildren === 0) {
return of(res);
}
if (c.numberOfChildren > 1 || !c.children[PRIMARY_OUTLET]) {
return namedOutletsRedirect(route.redirectTo);
}
c = c.children[PRIMARY_OUTLET];
}
}
applyRedirectCommands(segments, redirectTo, posParams) {
const newTree = this.applyRedirectCreateUrlTree(redirectTo, this.urlSerializer.parse(redirectTo), segments, posParams);
if (redirectTo.startsWith("/")) {
throw new AbsoluteRedirect(newTree);
}
return newTree;
}
applyRedirectCreateUrlTree(redirectTo, urlTree, segments, posParams) {
const newRoot = this.createSegmentGroup(redirectTo, urlTree.root, segments, posParams);
return new UrlTree(newRoot, this.createQueryParams(urlTree.queryParams, this.urlTree.queryParams), urlTree.fragment);
}
createQueryParams(redirectToParams, actualParams) {
const res = {};
Object.entries(redirectToParams).forEach(([k, v]) => {
const copySourceValue = typeof v === "string" && v.startsWith(":");
if (copySourceValue) {
const sourceName = v.substring(1);
res[k] = actualParams[sourceName];
} else {
res[k] = v;
}
});
return res;
}
createSegmentGroup(redirectTo, group, segments, posParams) {
const updatedSegments = this.createSegments(redirectTo, group.segments, segments, posParams);
let children = {};
Object.entries(group.children).forEach(([name2, child]) => {
children[name2] = this.createSegmentGroup(redirectTo, child, segments, posParams);
});
return new UrlSegmentGroup(updatedSegments, children);
}
createSegments(redirectTo, redirectToSegments, actualSegments, posParams) {
return redirectToSegments.map((s) => s.path.startsWith(":") ? this.findPosParam(redirectTo, s, posParams) : this.findOrReturn(s, actualSegments));
}
findPosParam(redirectTo, redirectToUrlSegment, posParams) {
const pos = posParams[redirectToUrlSegment.path.substring(1)];
if (!pos)
throw new RuntimeError(4001, (typeof ngDevMode === "undefined" || ngDevMode) && `Cannot redirect to '${redirectTo}'. Cannot find '${redirectToUrlSegment.path}'.`);
return pos;
}
findOrReturn(redirectToUrlSegment, actualSegments) {
let idx = 0;
for (const s of actualSegments) {
if (s.path === redirectToUrlSegment.path) {
actualSegments.splice(idx);
return s;
}
idx++;
}
return redirectToUrlSegment;
}
};
var noMatch = {
matched: false,
consumedSegments: [],
remainingSegments: [],
parameters: {},
positionalParamSegments: {}
};
function matchWithChecks(segmentGroup, route, segments, injector, urlSerializer) {
const result = match(segmentGroup, route, segments);
if (!result.matched) {
return of(result);
}
injector = getOrCreateRouteInjectorIfNeeded(route, injector);
return runCanMatchGuards(injector, route, segments, urlSerializer).pipe(map((v) => v === true ? result : __spreadValues({}, noMatch)));
}
function match(segmentGroup, route, segments) {
if (route.path === "**") {
return createWildcardMatchResult(segments);
}
if (route.path === "") {
if (route.pathMatch === "full" && (segmentGroup.hasChildren() || segments.length > 0)) {
return __spreadValues({}, noMatch);
}
return {
matched: true,
consumedSegments: [],
remainingSegments: segments,
parameters: {},
positionalParamSegments: {}
};
}
const matcher = route.matcher || defaultUrlMatcher;
const res = matcher(segments, segmentGroup, route);
if (!res)
return __spreadValues({}, noMatch);
const posParams = {};
Object.entries(res.posParams ?? {}).forEach(([k, v]) => {
posParams[k] = v.path;
});
const parameters = res.consumed.length > 0 ? __spreadValues(__spreadValues({}, posParams), res.consumed[res.consumed.length - 1].parameters) : posParams;
return {
matched: true,
consumedSegments: res.consumed,
remainingSegments: segments.slice(res.consumed.length),
// TODO(atscott): investigate combining parameters and positionalParamSegments
parameters,
positionalParamSegments: res.posParams ?? {}
};
}
function createWildcardMatchResult(segments) {
return {
matched: true,
parameters: segments.length > 0 ? last3(segments).parameters : {},
consumedSegments: segments,
remainingSegments: [],
positionalParamSegments: {}
};
}
function split(segmentGroup, consumedSegments, slicedSegments, config2) {
if (slicedSegments.length > 0 && containsEmptyPathMatchesWithNamedOutlets(segmentGroup, slicedSegments, config2)) {
const s2 = new UrlSegmentGroup(consumedSegments, createChildrenForEmptyPaths(config2, new UrlSegmentGroup(slicedSegments, segmentGroup.children)));
return {
segmentGroup: s2,
slicedSegments: []
};
}
if (slicedSegments.length === 0 && containsEmptyPathMatches(segmentGroup, slicedSegments, config2)) {
const s2 = new UrlSegmentGroup(segmentGroup.segments, addEmptyPathsToChildrenIfNeeded(segmentGroup, slicedSegments, config2, segmentGroup.children));
return {
segmentGroup: s2,
slicedSegments
};
}
const s = new UrlSegmentGroup(segmentGroup.segments, segmentGroup.children);
return {
segmentGroup: s,
slicedSegments
};
}
function addEmptyPathsToChildrenIfNeeded(segmentGroup, slicedSegments, routes2, children) {
const res = {};
for (const r of routes2) {
if (emptyPathMatch(segmentGroup, slicedSegments, r) && !children[getOutlet(r)]) {
const s = new UrlSegmentGroup([], {});
res[getOutlet(r)] = s;
}
}
return __spreadValues(__spreadValues({}, children), res);
}
function createChildrenForEmptyPaths(routes2, primarySegment) {
const res = {};
res[PRIMARY_OUTLET] = primarySegment;
for (const r of routes2) {
if (r.path === "" && getOutlet(r) !== PRIMARY_OUTLET) {
const s = new UrlSegmentGroup([], {});
res[getOutlet(r)] = s;
}
}
return res;
}
function containsEmptyPathMatchesWithNamedOutlets(segmentGroup, slicedSegments, routes2) {
return routes2.some((r) => emptyPathMatch(segmentGroup, slicedSegments, r) && getOutlet(r) !== PRIMARY_OUTLET);
}
function containsEmptyPathMatches(segmentGroup, slicedSegments, routes2) {
return routes2.some((r) => emptyPathMatch(segmentGroup, slicedSegments, r));
}
function emptyPathMatch(segmentGroup, slicedSegments, r) {
if ((segmentGroup.hasChildren() || slicedSegments.length > 0) && r.pathMatch === "full") {
return false;
}
return r.path === "";
}
function isImmediateMatch(route, rawSegment, segments, outlet) {
if (getOutlet(route) !== outlet && (outlet === PRIMARY_OUTLET || !emptyPathMatch(rawSegment, segments, route))) {
return false;
}
return match(rawSegment, route, segments).matched;
}
function noLeftoversInUrl(segmentGroup, segments, outlet) {
return segments.length === 0 && !segmentGroup.children[outlet];
}
var NoLeftoversInUrl = class {
};
function recognize$1(injector, configLoader, rootComponentType, config2, urlTree, urlSerializer, paramsInheritanceStrategy = "emptyOnly") {
return new Recognizer(injector, configLoader, rootComponentType, config2, urlTree, paramsInheritanceStrategy, urlSerializer).recognize();
}
var MAX_ALLOWED_REDIRECTS = 31;
var Recognizer = class {
constructor(injector, configLoader, rootComponentType, config2, urlTree, paramsInheritanceStrategy, urlSerializer) {
this.injector = injector;
this.configLoader = configLoader;
this.rootComponentType = rootComponentType;
this.config = config2;
this.urlTree = urlTree;
this.paramsInheritanceStrategy = paramsInheritanceStrategy;
this.urlSerializer = urlSerializer;
this.applyRedirects = new ApplyRedirects(this.urlSerializer, this.urlTree);
this.absoluteRedirectCount = 0;
this.allowRedirects = true;
}
noMatchError(e) {
return new RuntimeError(4002, typeof ngDevMode === "undefined" || ngDevMode ? `Cannot match any routes. URL Segment: '${e.segmentGroup}'` : `'${e.segmentGroup}'`);
}
recognize() {
const rootSegmentGroup = split(this.urlTree.root, [], [], this.config).segmentGroup;
return this.match(rootSegmentGroup).pipe(map((children) => {
const root = new ActivatedRouteSnapshot([], Object.freeze({}), Object.freeze(__spreadValues({}, this.urlTree.queryParams)), this.urlTree.fragment, {}, PRIMARY_OUTLET, this.rootComponentType, null, {});
const rootNode = new TreeNode(root, children);
const routeState = new RouterStateSnapshot("", rootNode);
const tree2 = createUrlTreeFromSnapshot(root, [], this.urlTree.queryParams, this.urlTree.fragment);
tree2.queryParams = this.urlTree.queryParams;
routeState.url = this.urlSerializer.serialize(tree2);
this.inheritParamsAndData(routeState._root, null);
return {
state: routeState,
tree: tree2
};
}));
}
match(rootSegmentGroup) {
const expanded$ = this.processSegmentGroup(this.injector, this.config, rootSegmentGroup, PRIMARY_OUTLET);
return expanded$.pipe(catchError((e) => {
if (e instanceof AbsoluteRedirect) {
this.urlTree = e.urlTree;
return this.match(e.urlTree.root);
}
if (e instanceof NoMatch) {
throw this.noMatchError(e);
}
throw e;
}));
}
inheritParamsAndData(routeNode, parent2) {
const route = routeNode.value;
const i = getInherited(route, parent2, this.paramsInheritanceStrategy);
route.params = Object.freeze(i.params);
route.data = Object.freeze(i.data);
routeNode.children.forEach((n) => this.inheritParamsAndData(n, route));
}
processSegmentGroup(injector, config2, segmentGroup, outlet) {
if (segmentGroup.segments.length === 0 && segmentGroup.hasChildren()) {
return this.processChildren(injector, config2, segmentGroup);
}
return this.processSegment(injector, config2, segmentGroup, segmentGroup.segments, outlet, true).pipe(map((child) => child instanceof TreeNode ? [child] : []));
}
/**
* Matches every child outlet in the `segmentGroup` to a `Route` in the config. Returns `null` if
* we cannot find a match for _any_ of the children.
*
* @param config - The `Routes` to match against
* @param segmentGroup - The `UrlSegmentGroup` whose children need to be matched against the
* config.
*/
processChildren(injector, config2, segmentGroup) {
const childOutlets = [];
for (const child of Object.keys(segmentGroup.children)) {
if (child === "primary") {
childOutlets.unshift(child);
} else {
childOutlets.push(child);
}
}
return from(childOutlets).pipe(concatMap((childOutlet) => {
const child = segmentGroup.children[childOutlet];
const sortedConfig = sortByMatchingOutlets(config2, childOutlet);
return this.processSegmentGroup(injector, sortedConfig, child, childOutlet);
}), scan((children, outletChildren) => {
children.push(...outletChildren);
return children;
}), defaultIfEmpty(null), last2(), mergeMap((children) => {
if (children === null)
return noMatch$1(segmentGroup);
const mergedChildren = mergeEmptyPathMatches(children);
if (typeof ngDevMode === "undefined" || ngDevMode) {
checkOutletNameUniqueness(mergedChildren);
}
sortActivatedRouteSnapshots(mergedChildren);
return of(mergedChildren);
}));
}
processSegment(injector, routes2, segmentGroup, segments, outlet, allowRedirects) {
return from(routes2).pipe(concatMap((r) => {
return this.processSegmentAgainstRoute(r._injector ?? injector, routes2, r, segmentGroup, segments, outlet, allowRedirects).pipe(catchError((e) => {
if (e instanceof NoMatch) {
return of(null);
}
throw e;
}));
}), first((x) => !!x), catchError((e) => {
if (isEmptyError(e)) {
if (noLeftoversInUrl(segmentGroup, segments, outlet)) {
return of(new NoLeftoversInUrl());
}
return noMatch$1(segmentGroup);
}
throw e;
}));
}
processSegmentAgainstRoute(injector, routes2, route, rawSegment, segments, outlet, allowRedirects) {
if (!isImmediateMatch(route, rawSegment, segments, outlet))
return noMatch$1(rawSegment);
if (route.redirectTo === void 0) {
return this.matchSegmentAgainstRoute(injector, rawSegment, route, segments, outlet);
}
if (this.allowRedirects && allowRedirects) {
return this.expandSegmentAgainstRouteUsingRedirect(injector, rawSegment, routes2, route, segments, outlet);
}
return noMatch$1(rawSegment);
}
expandSegmentAgainstRouteUsingRedirect(injector, segmentGroup, routes2, route, segments, outlet) {
const {
matched,
consumedSegments,
positionalParamSegments,
remainingSegments
} = match(segmentGroup, route, segments);
if (!matched)
return noMatch$1(segmentGroup);
if (route.redirectTo.startsWith("/")) {
this.absoluteRedirectCount++;
if (this.absoluteRedirectCount > MAX_ALLOWED_REDIRECTS) {
if (ngDevMode) {
throw new RuntimeError(4016, `Detected possible infinite redirect when redirecting from '${this.urlTree}' to '${route.redirectTo}'.
This is currently a dev mode only error but will become a call stack size exceeded error in production in a future major version.`);
}
this.allowRedirects = false;
}
}
const newTree = this.applyRedirects.applyRedirectCommands(consumedSegments, route.redirectTo, positionalParamSegments);
return this.applyRedirects.lineralizeSegments(route, newTree).pipe(mergeMap((newSegments) => {
return this.processSegment(injector, routes2, segmentGroup, newSegments.concat(remainingSegments), outlet, false);
}));
}
matchSegmentAgainstRoute(injector, rawSegment, route, segments, outlet) {
const matchResult = matchWithChecks(rawSegment, route, segments, injector, this.urlSerializer);
if (route.path === "**") {
rawSegment.children = {};
}
return matchResult.pipe(switchMap((result) => {
if (!result.matched) {
return noMatch$1(rawSegment);
}
injector = route._injector ?? injector;
return this.getChildConfig(injector, route, segments).pipe(switchMap(({
routes: childConfig
}) => {
const childInjector = route._loadedInjector ?? injector;
const {
consumedSegments,
remainingSegments,
parameters
} = result;
const snapshot = new ActivatedRouteSnapshot(consumedSegments, parameters, Object.freeze(__spreadValues({}, this.urlTree.queryParams)), this.urlTree.fragment, getData(route), getOutlet(route), route.component ?? route._loadedComponent ?? null, route, getResolve(route));
const {
segmentGroup,
slicedSegments
} = split(rawSegment, consumedSegments, remainingSegments, childConfig);
if (slicedSegments.length === 0 && segmentGroup.hasChildren()) {
return this.processChildren(childInjector, childConfig, segmentGroup).pipe(map((children) => {
if (children === null) {
return null;
}
return new TreeNode(snapshot, children);
}));
}
if (childConfig.length === 0 && slicedSegments.length === 0) {
return of(new TreeNode(snapshot, []));
}
const matchedOnOutlet = getOutlet(route) === outlet;
return this.processSegment(childInjector, childConfig, segmentGroup, slicedSegments, matchedOnOutlet ? PRIMARY_OUTLET : outlet, true).pipe(map((child) => {
return new TreeNode(snapshot, child instanceof TreeNode ? [child] : []);
}));
}));
}));
}
getChildConfig(injector, route, segments) {
if (route.children) {
return of({
routes: route.children,
injector
});
}
if (route.loadChildren) {
if (route._loadedRoutes !== void 0) {
return of({
routes: route._loadedRoutes,
injector: route._loadedInjector
});
}
return runCanLoadGuards(injector, route, segments, this.urlSerializer).pipe(mergeMap((shouldLoadResult) => {
if (shouldLoadResult) {
return this.configLoader.loadChildren(injector, route).pipe(tap((cfg) => {
route._loadedRoutes = cfg.routes;
route._loadedInjector = cfg.injector;
}));
}
return canLoadFails(route);
}));
}
return of({
routes: [],
injector
});
}
};
function sortActivatedRouteSnapshots(nodes) {
nodes.sort((a, b) => {
if (a.value.outlet === PRIMARY_OUTLET)
return -1;
if (b.value.outlet === PRIMARY_OUTLET)
return 1;
return a.value.outlet.localeCompare(b.value.outlet);
});
}
function hasEmptyPathConfig(node) {
const config2 = node.value.routeConfig;
return config2 && config2.path === "";
}
function mergeEmptyPathMatches(nodes) {
const result = [];
const mergedNodes = /* @__PURE__ */ new Set();
for (const node of nodes) {
if (!hasEmptyPathConfig(node)) {
result.push(node);
continue;
}
const duplicateEmptyPathNode = result.find((resultNode) => node.value.routeConfig === resultNode.value.routeConfig);
if (duplicateEmptyPathNode !== void 0) {
duplicateEmptyPathNode.children.push(...node.children);
mergedNodes.add(duplicateEmptyPathNode);
} else {
result.push(node);
}
}
for (const mergedNode of mergedNodes) {
const mergedChildren = mergeEmptyPathMatches(mergedNode.children);
result.push(new TreeNode(mergedNode.value, mergedChildren));
}
return result.filter((n) => !mergedNodes.has(n));
}
function checkOutletNameUniqueness(nodes) {
const names = {};
nodes.forEach((n) => {
const routeWithSameOutletName = names[n.value.outlet];
if (routeWithSameOutletName) {
const p = routeWithSameOutletName.url.map((s) => s.toString()).join("/");
const c = n.value.url.map((s) => s.toString()).join("/");
throw new RuntimeError(4006, (typeof ngDevMode === "undefined" || ngDevMode) && `Two segments cannot have the same outlet name: '${p}' and '${c}'.`);
}
names[n.value.outlet] = n.value;
});
}
function getData(route) {
return route.data || {};
}
function getResolve(route) {
return route.resolve || {};
}
function recognize(injector, configLoader, rootComponentType, config2, serializer, paramsInheritanceStrategy) {
return mergeMap((t) => recognize$1(injector, configLoader, rootComponentType, config2, t.extractedUrl, serializer, paramsInheritanceStrategy).pipe(map(({
state: targetSnapshot,
tree: urlAfterRedirects
}) => {
return __spreadProps(__spreadValues({}, t), {
targetSnapshot,
urlAfterRedirects
});
})));
}
function resolveData(paramsInheritanceStrategy, injector) {
return mergeMap((t) => {
const {
targetSnapshot,
guards: {
canActivateChecks
}
} = t;
if (!canActivateChecks.length) {
return of(t);
}
const routesWithResolversToRun = new Set(canActivateChecks.map((check) => check.route));
const routesNeedingDataUpdates = /* @__PURE__ */ new Set();
for (const route of routesWithResolversToRun) {
if (routesNeedingDataUpdates.has(route)) {
continue;
}
for (const newRoute of flattenRouteTree(route)) {
routesNeedingDataUpdates.add(newRoute);
}
}
let routesProcessed = 0;
return from(routesNeedingDataUpdates).pipe(concatMap((route) => {
if (routesWithResolversToRun.has(route)) {
return runResolve(route, targetSnapshot, paramsInheritanceStrategy, injector);
} else {
route.data = getInherited(route, route.parent, paramsInheritanceStrategy).resolve;
return of(void 0);
}
}), tap(() => routesProcessed++), takeLast(1), mergeMap((_) => routesProcessed === routesNeedingDataUpdates.size ? of(t) : EMPTY));
});
}
function flattenRouteTree(route) {
const descendants = route.children.map((child) => flattenRouteTree(child)).flat();
return [route, ...descendants];
}
function runResolve(futureARS, futureRSS, paramsInheritanceStrategy, injector) {
const config2 = futureARS.routeConfig;
const resolve = futureARS._resolve;
if (config2?.title !== void 0 && !hasStaticTitle(config2)) {
resolve[RouteTitleKey] = config2.title;
}
return resolveNode(resolve, futureARS, futureRSS, injector).pipe(map((resolvedData) => {
futureARS._resolvedData = resolvedData;
futureARS.data = getInherited(futureARS, futureARS.parent, paramsInheritanceStrategy).resolve;
return null;
}));
}
function resolveNode(resolve, futureARS, futureRSS, injector) {
const keys = getDataKeys(resolve);
if (keys.length === 0) {
return of({});
}
const data2 = {};
return from(keys).pipe(mergeMap((key2) => getResolver(resolve[key2], futureARS, futureRSS, injector).pipe(first(), tap((value2) => {
data2[key2] = value2;
}))), takeLast(1), mapTo(data2), catchError((e) => isEmptyError(e) ? EMPTY : throwError(e)));
}
function getResolver(injectionToken, futureARS, futureRSS, injector) {
const closestInjector = getClosestRouteInjector(futureARS) ?? injector;
const resolver = getTokenOrFunctionIdentity(injectionToken, closestInjector);
const resolverValue = resolver.resolve ? resolver.resolve(futureARS, futureRSS) : runInInjectionContext(closestInjector, () => resolver(futureARS, futureRSS));
return wrapIntoObservable(resolverValue);
}
function switchTap(next) {
return switchMap((v) => {
const nextResult = next(v);
if (nextResult) {
return from(nextResult).pipe(map(() => v));
}
return of(v);
});
}
var _TitleStrategy = class _TitleStrategy {
/**
* @returns The `title` of the deepest primary route.
*/
buildTitle(snapshot) {
let pageTitle;
let route = snapshot.root;
while (route !== void 0) {
pageTitle = this.getResolvedTitleForRoute(route) ?? pageTitle;
route = route.children.find((child) => child.outlet === PRIMARY_OUTLET);
}
return pageTitle;
}
/**
* Given an `ActivatedRouteSnapshot`, returns the final value of the
* `Route.title` property, which can either be a static string or a resolved value.
*/
getResolvedTitleForRoute(snapshot) {
return snapshot.data[RouteTitleKey];
}
};
_TitleStrategy.\u0275fac = function TitleStrategy_Factory(t) {
return new (t || _TitleStrategy)();
};
_TitleStrategy.\u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
token: _TitleStrategy,
factory: () => (() => inject(DefaultTitleStrategy))(),
providedIn: "root"
});
var TitleStrategy = _TitleStrategy;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(TitleStrategy, [{
type: Injectable,
args: [{
providedIn: "root",
useFactory: () => inject(DefaultTitleStrategy)
}]
}], null, null);
})();
var _DefaultTitleStrategy = class _DefaultTitleStrategy extends TitleStrategy {
constructor(title) {
super();
this.title = title;
}
/**
* Sets the title of the browser to the given value.
*
* @param title The `pageTitle` from the deepest primary route.
*/
updateTitle(snapshot) {
const title = this.buildTitle(snapshot);
if (title !== void 0) {
this.title.setTitle(title);
}
}
};
_DefaultTitleStrategy.\u0275fac = function DefaultTitleStrategy_Factory(t) {
return new (t || _DefaultTitleStrategy)(\u0275\u0275inject(Title));
};
_DefaultTitleStrategy.\u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
token: _DefaultTitleStrategy,
factory: _DefaultTitleStrategy.\u0275fac,
providedIn: "root"
});
var DefaultTitleStrategy = _DefaultTitleStrategy;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(DefaultTitleStrategy, [{
type: Injectable,
args: [{
providedIn: "root"
}]
}], () => [{
type: Title
}], null);
})();
var ROUTER_CONFIGURATION = new InjectionToken(typeof ngDevMode === "undefined" || ngDevMode ? "router config" : "", {
providedIn: "root",
factory: () => ({})
});
var ROUTES = new InjectionToken(ngDevMode ? "ROUTES" : "");
var _RouterConfigLoader = class _RouterConfigLoader {
constructor() {
this.componentLoaders = /* @__PURE__ */ new WeakMap();
this.childrenLoaders = /* @__PURE__ */ new WeakMap();
this.compiler = inject(Compiler);
}
loadComponent(route) {
if (this.componentLoaders.get(route)) {
return this.componentLoaders.get(route);
} else if (route._loadedComponent) {
return of(route._loadedComponent);
}
if (this.onLoadStartListener) {
this.onLoadStartListener(route);
}
const loadRunner = wrapIntoObservable(route.loadComponent()).pipe(map(maybeUnwrapDefaultExport), tap((component) => {
if (this.onLoadEndListener) {
this.onLoadEndListener(route);
}
(typeof ngDevMode === "undefined" || ngDevMode) && assertStandalone(route.path ?? "", component);
route._loadedComponent = component;
}), finalize(() => {
this.componentLoaders.delete(route);
}));
const loader = new ConnectableObservable(loadRunner, () => new Subject()).pipe(refCount());
this.componentLoaders.set(route, loader);
return loader;
}
loadChildren(parentInjector, route) {
if (this.childrenLoaders.get(route)) {
return this.childrenLoaders.get(route);
} else if (route._loadedRoutes) {
return of({
routes: route._loadedRoutes,
injector: route._loadedInjector
});
}
if (this.onLoadStartListener) {
this.onLoadStartListener(route);
}
const moduleFactoryOrRoutes$ = loadChildren(route, this.compiler, parentInjector, this.onLoadEndListener);
const loadRunner = moduleFactoryOrRoutes$.pipe(finalize(() => {
this.childrenLoaders.delete(route);
}));
const loader = new ConnectableObservable(loadRunner, () => new Subject()).pipe(refCount());
this.childrenLoaders.set(route, loader);
return loader;
}
};
_RouterConfigLoader.\u0275fac = function RouterConfigLoader_Factory(t) {
return new (t || _RouterConfigLoader)();
};
_RouterConfigLoader.\u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
token: _RouterConfigLoader,
factory: _RouterConfigLoader.\u0275fac,
providedIn: "root"
});
var RouterConfigLoader = _RouterConfigLoader;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(RouterConfigLoader, [{
type: Injectable,
args: [{
providedIn: "root"
}]
}], null, null);
})();
function loadChildren(route, compiler, parentInjector, onLoadEndListener) {
return wrapIntoObservable(route.loadChildren()).pipe(map(maybeUnwrapDefaultExport), mergeMap((t) => {
if (t instanceof NgModuleFactory$1 || Array.isArray(t)) {
return of(t);
} else {
return from(compiler.compileModuleAsync(t));
}
}), map((factoryOrRoutes) => {
if (onLoadEndListener) {
onLoadEndListener(route);
}
let injector;
let rawRoutes;
let requireStandaloneComponents = false;
if (Array.isArray(factoryOrRoutes)) {
rawRoutes = factoryOrRoutes;
requireStandaloneComponents = true;
} else {
injector = factoryOrRoutes.create(parentInjector).injector;
rawRoutes = injector.get(ROUTES, [], {
optional: true,
self: true
}).flat();
}
const routes2 = rawRoutes.map(standardizeConfig);
(typeof ngDevMode === "undefined" || ngDevMode) && validateConfig(routes2, route.path, requireStandaloneComponents);
return {
routes: routes2,
injector
};
}));
}
function isWrappedDefaultExport(value2) {
return value2 && typeof value2 === "object" && "default" in value2;
}
function maybeUnwrapDefaultExport(input2) {
return isWrappedDefaultExport(input2) ? input2["default"] : input2;
}
var _UrlHandlingStrategy = class _UrlHandlingStrategy {
};
_UrlHandlingStrategy.\u0275fac = function UrlHandlingStrategy_Factory(t) {
return new (t || _UrlHandlingStrategy)();
};
_UrlHandlingStrategy.\u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
token: _UrlHandlingStrategy,
factory: () => (() => inject(DefaultUrlHandlingStrategy))(),
providedIn: "root"
});
var UrlHandlingStrategy = _UrlHandlingStrategy;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(UrlHandlingStrategy, [{
type: Injectable,
args: [{
providedIn: "root",
useFactory: () => inject(DefaultUrlHandlingStrategy)
}]
}], null, null);
})();
var _DefaultUrlHandlingStrategy = class _DefaultUrlHandlingStrategy {
shouldProcessUrl(url) {
return true;
}
extract(url) {
return url;
}
merge(newUrlPart, wholeUrl) {
return newUrlPart;
}
};
_DefaultUrlHandlingStrategy.\u0275fac = function DefaultUrlHandlingStrategy_Factory(t) {
return new (t || _DefaultUrlHandlingStrategy)();
};
_DefaultUrlHandlingStrategy.\u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
token: _DefaultUrlHandlingStrategy,
factory: _DefaultUrlHandlingStrategy.\u0275fac,
providedIn: "root"
});
var DefaultUrlHandlingStrategy = _DefaultUrlHandlingStrategy;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(DefaultUrlHandlingStrategy, [{
type: Injectable,
args: [{
providedIn: "root"
}]
}], null, null);
})();
var CREATE_VIEW_TRANSITION = new InjectionToken(ngDevMode ? "view transition helper" : "");
var VIEW_TRANSITION_OPTIONS = new InjectionToken(ngDevMode ? "view transition options" : "");
function createViewTransition(injector, from2, to) {
const transitionOptions = injector.get(VIEW_TRANSITION_OPTIONS);
const document2 = injector.get(DOCUMENT2);
return injector.get(NgZone).runOutsideAngular(() => {
if (!document2.startViewTransition || transitionOptions.skipNextTransition) {
transitionOptions.skipNextTransition = false;
return new Promise((resolve) => setTimeout(resolve));
}
let resolveViewTransitionStarted;
const viewTransitionStarted = new Promise((resolve) => {
resolveViewTransitionStarted = resolve;
});
const transition = document2.startViewTransition(() => {
resolveViewTransitionStarted();
return createRenderPromise(injector);
});
const {
onViewTransitionCreated
} = transitionOptions;
if (onViewTransitionCreated) {
runInInjectionContext(injector, () => onViewTransitionCreated({
transition,
from: from2,
to
}));
}
return viewTransitionStarted;
});
}
function createRenderPromise(injector) {
return new Promise((resolve) => {
afterNextRender(resolve, {
injector
});
});
}
var _NavigationTransitions = class _NavigationTransitions {
get hasRequestedNavigation() {
return this.navigationId !== 0;
}
constructor() {
this.currentNavigation = null;
this.currentTransition = null;
this.lastSuccessfulNavigation = null;
this.events = new Subject();
this.transitionAbortSubject = new Subject();
this.configLoader = inject(RouterConfigLoader);
this.environmentInjector = inject(EnvironmentInjector);
this.urlSerializer = inject(UrlSerializer);
this.rootContexts = inject(ChildrenOutletContexts);
this.location = inject(Location);
this.inputBindingEnabled = inject(INPUT_BINDER, {
optional: true
}) !== null;
this.titleStrategy = inject(TitleStrategy);
this.options = inject(ROUTER_CONFIGURATION, {
optional: true
}) || {};
this.paramsInheritanceStrategy = this.options.paramsInheritanceStrategy || "emptyOnly";
this.urlHandlingStrategy = inject(UrlHandlingStrategy);
this.createViewTransition = inject(CREATE_VIEW_TRANSITION, {
optional: true
});
this.navigationId = 0;
this.afterPreactivation = () => of(void 0);
this.rootComponentType = null;
const onLoadStart = (r) => this.events.next(new RouteConfigLoadStart(r));
const onLoadEnd = (r) => this.events.next(new RouteConfigLoadEnd(r));
this.configLoader.onLoadEndListener = onLoadEnd;
this.configLoader.onLoadStartListener = onLoadStart;
}
complete() {
this.transitions?.complete();
}
handleNavigationRequest(request) {
const id = ++this.navigationId;
this.transitions?.next(__spreadProps(__spreadValues(__spreadValues({}, this.transitions.value), request), {
id
}));
}
setupNavigations(router, initialUrlTree, initialRouterState) {
this.transitions = new BehaviorSubject({
id: 0,
currentUrlTree: initialUrlTree,
currentRawUrl: initialUrlTree,
extractedUrl: this.urlHandlingStrategy.extract(initialUrlTree),
urlAfterRedirects: this.urlHandlingStrategy.extract(initialUrlTree),
rawUrl: initialUrlTree,
extras: {},
resolve: null,
reject: null,
promise: Promise.resolve(true),
source: IMPERATIVE_NAVIGATION,
restoredState: null,
currentSnapshot: initialRouterState.snapshot,
targetSnapshot: null,
currentRouterState: initialRouterState,
targetRouterState: null,
guards: {
canActivateChecks: [],
canDeactivateChecks: []
},
guardsResult: null
});
return this.transitions.pipe(
filter((t) => t.id !== 0),
// Extract URL
map((t) => __spreadProps(__spreadValues({}, t), {
extractedUrl: this.urlHandlingStrategy.extract(t.rawUrl)
})),
// Using switchMap so we cancel executing navigations when a new one comes in
switchMap((overallTransitionState) => {
let completed = false;
let errored = false;
return of(overallTransitionState).pipe(
switchMap((t) => {
if (this.navigationId > overallTransitionState.id) {
const cancellationReason = typeof ngDevMode === "undefined" || ngDevMode ? `Navigation ID ${overallTransitionState.id} is not equal to the current navigation id ${this.navigationId}` : "";
this.cancelNavigationTransition(overallTransitionState, cancellationReason, NavigationCancellationCode.SupersededByNewNavigation);
return EMPTY;
}
this.currentTransition = overallTransitionState;
this.currentNavigation = {
id: t.id,
initialUrl: t.rawUrl,
extractedUrl: t.extractedUrl,
trigger: t.source,
extras: t.extras,
previousNavigation: !this.lastSuccessfulNavigation ? null : __spreadProps(__spreadValues({}, this.lastSuccessfulNavigation), {
previousNavigation: null
})
};
const urlTransition = !router.navigated || this.isUpdatingInternalState() || this.isUpdatedBrowserUrl();
const onSameUrlNavigation = t.extras.onSameUrlNavigation ?? router.onSameUrlNavigation;
if (!urlTransition && onSameUrlNavigation !== "reload") {
const reason = typeof ngDevMode === "undefined" || ngDevMode ? `Navigation to ${t.rawUrl} was ignored because it is the same as the current Router URL.` : "";
this.events.next(new NavigationSkipped(t.id, this.urlSerializer.serialize(t.rawUrl), reason, NavigationSkippedCode.IgnoredSameUrlNavigation));
t.resolve(null);
return EMPTY;
}
if (this.urlHandlingStrategy.shouldProcessUrl(t.rawUrl)) {
return of(t).pipe(
// Fire NavigationStart event
switchMap((t2) => {
const transition = this.transitions?.getValue();
this.events.next(new NavigationStart(t2.id, this.urlSerializer.serialize(t2.extractedUrl), t2.source, t2.restoredState));
if (transition !== this.transitions?.getValue()) {
return EMPTY;
}
return Promise.resolve(t2);
}),
// Recognize
recognize(this.environmentInjector, this.configLoader, this.rootComponentType, router.config, this.urlSerializer, this.paramsInheritanceStrategy),
// Update URL if in `eager` update mode
tap((t2) => {
overallTransitionState.targetSnapshot = t2.targetSnapshot;
overallTransitionState.urlAfterRedirects = t2.urlAfterRedirects;
this.currentNavigation = __spreadProps(__spreadValues({}, this.currentNavigation), {
finalUrl: t2.urlAfterRedirects
});
const routesRecognized = new RoutesRecognized(t2.id, this.urlSerializer.serialize(t2.extractedUrl), this.urlSerializer.serialize(t2.urlAfterRedirects), t2.targetSnapshot);
this.events.next(routesRecognized);
})
);
} else if (urlTransition && this.urlHandlingStrategy.shouldProcessUrl(t.currentRawUrl)) {
const {
id,
extractedUrl,
source,
restoredState,
extras
} = t;
const navStart = new NavigationStart(id, this.urlSerializer.serialize(extractedUrl), source, restoredState);
this.events.next(navStart);
const targetSnapshot = createEmptyState(this.rootComponentType).snapshot;
this.currentTransition = overallTransitionState = __spreadProps(__spreadValues({}, t), {
targetSnapshot,
urlAfterRedirects: extractedUrl,
extras: __spreadProps(__spreadValues({}, extras), {
skipLocationChange: false,
replaceUrl: false
})
});
this.currentNavigation.finalUrl = extractedUrl;
return of(overallTransitionState);
} else {
const reason = typeof ngDevMode === "undefined" || ngDevMode ? `Navigation was ignored because the UrlHandlingStrategy indicated neither the current URL ${t.currentRawUrl} nor target URL ${t.rawUrl} should be processed.` : "";
this.events.next(new NavigationSkipped(t.id, this.urlSerializer.serialize(t.extractedUrl), reason, NavigationSkippedCode.IgnoredByUrlHandlingStrategy));
t.resolve(null);
return EMPTY;
}
}),
// --- GUARDS ---
tap((t) => {
const guardsStart = new GuardsCheckStart(t.id, this.urlSerializer.serialize(t.extractedUrl), this.urlSerializer.serialize(t.urlAfterRedirects), t.targetSnapshot);
this.events.next(guardsStart);
}),
map((t) => {
this.currentTransition = overallTransitionState = __spreadProps(__spreadValues({}, t), {
guards: getAllRouteGuards(t.targetSnapshot, t.currentSnapshot, this.rootContexts)
});
return overallTransitionState;
}),
checkGuards(this.environmentInjector, (evt) => this.events.next(evt)),
tap((t) => {
overallTransitionState.guardsResult = t.guardsResult;
if (isUrlTree(t.guardsResult)) {
throw redirectingNavigationError(this.urlSerializer, t.guardsResult);
}
const guardsEnd = new GuardsCheckEnd(t.id, this.urlSerializer.serialize(t.extractedUrl), this.urlSerializer.serialize(t.urlAfterRedirects), t.targetSnapshot, !!t.guardsResult);
this.events.next(guardsEnd);
}),
filter((t) => {
if (!t.guardsResult) {
this.cancelNavigationTransition(t, "", NavigationCancellationCode.GuardRejected);
return false;
}
return true;
}),
// --- RESOLVE ---
switchTap((t) => {
if (t.guards.canActivateChecks.length) {
return of(t).pipe(tap((t2) => {
const resolveStart = new ResolveStart(t2.id, this.urlSerializer.serialize(t2.extractedUrl), this.urlSerializer.serialize(t2.urlAfterRedirects), t2.targetSnapshot);
this.events.next(resolveStart);
}), switchMap((t2) => {
let dataResolved = false;
return of(t2).pipe(resolveData(this.paramsInheritanceStrategy, this.environmentInjector), tap({
next: () => dataResolved = true,
complete: () => {
if (!dataResolved) {
this.cancelNavigationTransition(t2, typeof ngDevMode === "undefined" || ngDevMode ? `At least one route resolver didn't emit any value.` : "", NavigationCancellationCode.NoDataFromResolver);
}
}
}));
}), tap((t2) => {
const resolveEnd = new ResolveEnd(t2.id, this.urlSerializer.serialize(t2.extractedUrl), this.urlSerializer.serialize(t2.urlAfterRedirects), t2.targetSnapshot);
this.events.next(resolveEnd);
}));
}
return void 0;
}),
// --- LOAD COMPONENTS ---
switchTap((t) => {
const loadComponents = (route) => {
const loaders = [];
if (route.routeConfig?.loadComponent && !route.routeConfig._loadedComponent) {
loaders.push(this.configLoader.loadComponent(route.routeConfig).pipe(tap((loadedComponent) => {
route.component = loadedComponent;
}), map(() => void 0)));
}
for (const child of route.children) {
loaders.push(...loadComponents(child));
}
return loaders;
};
return combineLatest(loadComponents(t.targetSnapshot.root)).pipe(defaultIfEmpty(null), take(1));
}),
switchTap(() => this.afterPreactivation()),
switchMap(() => {
const {
currentSnapshot,
targetSnapshot
} = overallTransitionState;
const viewTransitionStarted = this.createViewTransition?.(this.environmentInjector, currentSnapshot.root, targetSnapshot.root);
return viewTransitionStarted ? from(viewTransitionStarted).pipe(map(() => overallTransitionState)) : of(overallTransitionState);
}),
map((t) => {
const targetRouterState = createRouterState(router.routeReuseStrategy, t.targetSnapshot, t.currentRouterState);
this.currentTransition = overallTransitionState = __spreadProps(__spreadValues({}, t), {
targetRouterState
});
this.currentNavigation.targetRouterState = targetRouterState;
return overallTransitionState;
}),
tap(() => {
this.events.next(new BeforeActivateRoutes());
}),
activateRoutes(this.rootContexts, router.routeReuseStrategy, (evt) => this.events.next(evt), this.inputBindingEnabled),
// Ensure that if some observable used to drive the transition doesn't
// complete, the navigation still finalizes This should never happen, but
// this is done as a safety measure to avoid surfacing this error (#49567).
take(1),
tap({
next: (t) => {
completed = true;
this.lastSuccessfulNavigation = this.currentNavigation;
this.events.next(new NavigationEnd(t.id, this.urlSerializer.serialize(t.extractedUrl), this.urlSerializer.serialize(t.urlAfterRedirects)));
this.titleStrategy?.updateTitle(t.targetRouterState.snapshot);
t.resolve(true);
},
complete: () => {
completed = true;
}
}),
// There used to be a lot more logic happening directly within the
// transition Observable. Some of this logic has been refactored out to
// other places but there may still be errors that happen there. This gives
// us a way to cancel the transition from the outside. This may also be
// required in the future to support something like the abort signal of the
// Navigation API where the navigation gets aborted from outside the
// transition.
takeUntil(this.transitionAbortSubject.pipe(tap((err) => {
throw err;
}))),
finalize(() => {
if (!completed && !errored) {
const cancelationReason = typeof ngDevMode === "undefined" || ngDevMode ? `Navigation ID ${overallTransitionState.id} is not equal to the current navigation id ${this.navigationId}` : "";
this.cancelNavigationTransition(overallTransitionState, cancelationReason, NavigationCancellationCode.SupersededByNewNavigation);
}
if (this.currentTransition?.id === overallTransitionState.id) {
this.currentNavigation = null;
this.currentTransition = null;
}
}),
catchError((e) => {
errored = true;
if (isNavigationCancelingError(e)) {
this.events.next(new NavigationCancel(overallTransitionState.id, this.urlSerializer.serialize(overallTransitionState.extractedUrl), e.message, e.cancellationCode));
if (!isRedirectingNavigationCancelingError(e)) {
overallTransitionState.resolve(false);
} else {
this.events.next(new RedirectRequest(e.url));
}
} else {
this.events.next(new NavigationError(overallTransitionState.id, this.urlSerializer.serialize(overallTransitionState.extractedUrl), e, overallTransitionState.targetSnapshot ?? void 0));
try {
overallTransitionState.resolve(router.errorHandler(e));
} catch (ee) {
if (this.options.resolveNavigationPromiseOnError) {
overallTransitionState.resolve(false);
} else {
overallTransitionState.reject(ee);
}
}
}
return EMPTY;
})
);
})
);
}
cancelNavigationTransition(t, reason, code) {
const navCancel = new NavigationCancel(t.id, this.urlSerializer.serialize(t.extractedUrl), reason, code);
this.events.next(navCancel);
t.resolve(false);
}
/**
* @returns Whether we're navigating to somewhere that is not what the Router is
* currently set to.
*/
isUpdatingInternalState() {
return this.currentTransition?.extractedUrl.toString() !== this.currentTransition?.currentUrlTree.toString();
}
/**
* @returns Whether we're updating the browser URL to something new (navigation is going
* to somewhere not displayed in the URL bar and we will update the URL
* bar if navigation succeeds).
*/
isUpdatedBrowserUrl() {
const extractedBrowserUrl = this.urlHandlingStrategy.extract(this.urlSerializer.parse(this.location.path(true)));
return extractedBrowserUrl.toString() !== this.currentTransition?.extractedUrl.toString() && !this.currentTransition?.extras.skipLocationChange;
}
};
_NavigationTransitions.\u0275fac = function NavigationTransitions_Factory(t) {
return new (t || _NavigationTransitions)();
};
_NavigationTransitions.\u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
token: _NavigationTransitions,
factory: _NavigationTransitions.\u0275fac,
providedIn: "root"
});
var NavigationTransitions = _NavigationTransitions;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(NavigationTransitions, [{
type: Injectable,
args: [{
providedIn: "root"
}]
}], () => [], null);
})();
function isBrowserTriggeredNavigation(source) {
return source !== IMPERATIVE_NAVIGATION;
}
var _RouteReuseStrategy = class _RouteReuseStrategy {
};
_RouteReuseStrategy.\u0275fac = function RouteReuseStrategy_Factory(t) {
return new (t || _RouteReuseStrategy)();
};
_RouteReuseStrategy.\u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
token: _RouteReuseStrategy,
factory: () => (() => inject(DefaultRouteReuseStrategy))(),
providedIn: "root"
});
var RouteReuseStrategy = _RouteReuseStrategy;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(RouteReuseStrategy, [{
type: Injectable,
args: [{
providedIn: "root",
useFactory: () => inject(DefaultRouteReuseStrategy)
}]
}], null, null);
})();
var BaseRouteReuseStrategy = class {
/**
* Whether the given route should detach for later reuse.
* Always returns false for `BaseRouteReuseStrategy`.
* */
shouldDetach(route) {
return false;
}
/**
* A no-op; the route is never stored since this strategy never detaches routes for later re-use.
*/
store(route, detachedTree) {
}
/** Returns `false`, meaning the route (and its subtree) is never reattached */
shouldAttach(route) {
return false;
}
/** Returns `null` because this strategy does not store routes for later re-use. */
retrieve(route) {
return null;
}
/**
* Determines if a route should be reused.
* This strategy returns `true` when the future route config and current route config are
* identical.
*/
shouldReuseRoute(future, curr) {
return future.routeConfig === curr.routeConfig;
}
};
var _DefaultRouteReuseStrategy = class _DefaultRouteReuseStrategy extends BaseRouteReuseStrategy {
};
_DefaultRouteReuseStrategy.\u0275fac = /* @__PURE__ */ (() => {
let \u0275DefaultRouteReuseStrategy_BaseFactory;
return function DefaultRouteReuseStrategy_Factory(t) {
return (\u0275DefaultRouteReuseStrategy_BaseFactory || (\u0275DefaultRouteReuseStrategy_BaseFactory = \u0275\u0275getInheritedFactory(_DefaultRouteReuseStrategy)))(t || _DefaultRouteReuseStrategy);
};
})();
_DefaultRouteReuseStrategy.\u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
token: _DefaultRouteReuseStrategy,
factory: _DefaultRouteReuseStrategy.\u0275fac,
providedIn: "root"
});
var DefaultRouteReuseStrategy = _DefaultRouteReuseStrategy;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(DefaultRouteReuseStrategy, [{
type: Injectable,
args: [{
providedIn: "root"
}]
}], null, null);
})();
var _StateManager = class _StateManager {
};
_StateManager.\u0275fac = function StateManager_Factory(t) {
return new (t || _StateManager)();
};
_StateManager.\u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
token: _StateManager,
factory: () => (() => inject(HistoryStateManager))(),
providedIn: "root"
});
var StateManager = _StateManager;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(StateManager, [{
type: Injectable,
args: [{
providedIn: "root",
useFactory: () => inject(HistoryStateManager)
}]
}], null, null);
})();
var _HistoryStateManager = class _HistoryStateManager extends StateManager {
constructor() {
super(...arguments);
this.location = inject(Location);
this.urlSerializer = inject(UrlSerializer);
this.options = inject(ROUTER_CONFIGURATION, {
optional: true
}) || {};
this.canceledNavigationResolution = this.options.canceledNavigationResolution || "replace";
this.urlHandlingStrategy = inject(UrlHandlingStrategy);
this.urlUpdateStrategy = this.options.urlUpdateStrategy || "deferred";
this.currentUrlTree = new UrlTree();
this.rawUrlTree = this.currentUrlTree;
this.currentPageId = 0;
this.lastSuccessfulId = -1;
this.routerState = createEmptyState(null);
this.stateMemento = this.createStateMemento();
}
getCurrentUrlTree() {
return this.currentUrlTree;
}
getRawUrlTree() {
return this.rawUrlTree;
}
restoredState() {
return this.location.getState();
}
/**
* The ɵrouterPageId of whatever page is currently active in the browser history. This is
* important for computing the target page id for new navigations because we need to ensure each
* page id in the browser history is 1 more than the previous entry.
*/
get browserPageId() {
if (this.canceledNavigationResolution !== "computed") {
return this.currentPageId;
}
return this.restoredState()?.\u0275routerPageId ?? this.currentPageId;
}
getRouterState() {
return this.routerState;
}
createStateMemento() {
return {
rawUrlTree: this.rawUrlTree,
currentUrlTree: this.currentUrlTree,
routerState: this.routerState
};
}
registerNonRouterCurrentEntryChangeListener(listener) {
return this.location.subscribe((event) => {
if (event["type"] === "popstate") {
listener(event["url"], event.state);
}
});
}
handleRouterEvent(e, currentTransition) {
if (e instanceof NavigationStart) {
this.stateMemento = this.createStateMemento();
} else if (e instanceof NavigationSkipped) {
this.rawUrlTree = currentTransition.initialUrl;
} else if (e instanceof RoutesRecognized) {
if (this.urlUpdateStrategy === "eager") {
if (!currentTransition.extras.skipLocationChange) {
const rawUrl = this.urlHandlingStrategy.merge(currentTransition.finalUrl, currentTransition.initialUrl);
this.setBrowserUrl(rawUrl, currentTransition);
}
}
} else if (e instanceof BeforeActivateRoutes) {
this.currentUrlTree = currentTransition.finalUrl;
this.rawUrlTree = this.urlHandlingStrategy.merge(currentTransition.finalUrl, currentTransition.initialUrl);
this.routerState = currentTransition.targetRouterState;
if (this.urlUpdateStrategy === "deferred") {
if (!currentTransition.extras.skipLocationChange) {
this.setBrowserUrl(this.rawUrlTree, currentTransition);
}
}
} else if (e instanceof NavigationCancel && (e.code === NavigationCancellationCode.GuardRejected || e.code === NavigationCancellationCode.NoDataFromResolver)) {
this.restoreHistory(currentTransition);
} else if (e instanceof NavigationError) {
this.restoreHistory(currentTransition, true);
} else if (e instanceof NavigationEnd) {
this.lastSuccessfulId = e.id;
this.currentPageId = this.browserPageId;
}
}
setBrowserUrl(url, transition) {
const path = this.urlSerializer.serialize(url);
if (this.location.isCurrentPathEqualTo(path) || !!transition.extras.replaceUrl) {
const currentBrowserPageId = this.browserPageId;
const state = __spreadValues(__spreadValues({}, transition.extras.state), this.generateNgRouterState(transition.id, currentBrowserPageId));
this.location.replaceState(path, "", state);
} else {
const state = __spreadValues(__spreadValues({}, transition.extras.state), this.generateNgRouterState(transition.id, this.browserPageId + 1));
this.location.go(path, "", state);
}
}
/**
* Performs the necessary rollback action to restore the browser URL to the
* state before the transition.
*/
restoreHistory(navigation, restoringFromCaughtError = false) {
if (this.canceledNavigationResolution === "computed") {
const currentBrowserPageId = this.browserPageId;
const targetPagePosition = this.currentPageId - currentBrowserPageId;
if (targetPagePosition !== 0) {
this.location.historyGo(targetPagePosition);
} else if (this.currentUrlTree === navigation.finalUrl && targetPagePosition === 0) {
this.resetState(navigation);
this.resetUrlToCurrentUrlTree();
} else {
}
} else if (this.canceledNavigationResolution === "replace") {
if (restoringFromCaughtError) {
this.resetState(navigation);
}
this.resetUrlToCurrentUrlTree();
}
}
resetState(navigation) {
this.routerState = this.stateMemento.routerState;
this.currentUrlTree = this.stateMemento.currentUrlTree;
this.rawUrlTree = this.urlHandlingStrategy.merge(this.currentUrlTree, navigation.finalUrl ?? this.rawUrlTree);
}
resetUrlToCurrentUrlTree() {
this.location.replaceState(this.urlSerializer.serialize(this.rawUrlTree), "", this.generateNgRouterState(this.lastSuccessfulId, this.currentPageId));
}
generateNgRouterState(navigationId, routerPageId) {
if (this.canceledNavigationResolution === "computed") {
return {
navigationId,
\u0275routerPageId: routerPageId
};
}
return {
navigationId
};
}
};
_HistoryStateManager.\u0275fac = /* @__PURE__ */ (() => {
let \u0275HistoryStateManager_BaseFactory;
return function HistoryStateManager_Factory(t) {
return (\u0275HistoryStateManager_BaseFactory || (\u0275HistoryStateManager_BaseFactory = \u0275\u0275getInheritedFactory(_HistoryStateManager)))(t || _HistoryStateManager);
};
})();
_HistoryStateManager.\u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
token: _HistoryStateManager,
factory: _HistoryStateManager.\u0275fac,
providedIn: "root"
});
var HistoryStateManager = _HistoryStateManager;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(HistoryStateManager, [{
type: Injectable,
args: [{
providedIn: "root"
}]
}], null, null);
})();
var NavigationResult;
(function(NavigationResult2) {
NavigationResult2[NavigationResult2["COMPLETE"] = 0] = "COMPLETE";
NavigationResult2[NavigationResult2["FAILED"] = 1] = "FAILED";
NavigationResult2[NavigationResult2["REDIRECTING"] = 2] = "REDIRECTING";
})(NavigationResult || (NavigationResult = {}));
function afterNextNavigation(router, action) {
router.events.pipe(filter((e) => e instanceof NavigationEnd || e instanceof NavigationCancel || e instanceof NavigationError || e instanceof NavigationSkipped), map((e) => {
if (e instanceof NavigationEnd || e instanceof NavigationSkipped) {
return NavigationResult.COMPLETE;
}
const redirecting = e instanceof NavigationCancel ? e.code === NavigationCancellationCode.Redirect || e.code === NavigationCancellationCode.SupersededByNewNavigation : false;
return redirecting ? NavigationResult.REDIRECTING : NavigationResult.FAILED;
}), filter((result) => result !== NavigationResult.REDIRECTING), take(1)).subscribe(() => {
action();
});
}
function defaultErrorHandler2(error) {
throw error;
}
var exactMatchOptions = {
paths: "exact",
fragment: "ignored",
matrixParams: "ignored",
queryParams: "exact"
};
var subsetMatchOptions = {
paths: "subset",
fragment: "ignored",
matrixParams: "ignored",
queryParams: "subset"
};
var _Router = class _Router {
get currentUrlTree() {
return this.stateManager.getCurrentUrlTree();
}
get rawUrlTree() {
return this.stateManager.getRawUrlTree();
}
/**
* An event stream for routing events.
*/
get events() {
return this._events;
}
/**
* The current state of routing in this NgModule.
*/
get routerState() {
return this.stateManager.getRouterState();
}
constructor() {
this.disposed = false;
this.isNgZoneEnabled = false;
this.console = inject(Console);
this.stateManager = inject(StateManager);
this.options = inject(ROUTER_CONFIGURATION, {
optional: true
}) || {};
this.pendingTasks = inject(PendingTasks);
this.urlUpdateStrategy = this.options.urlUpdateStrategy || "deferred";
this.navigationTransitions = inject(NavigationTransitions);
this.urlSerializer = inject(UrlSerializer);
this.location = inject(Location);
this.urlHandlingStrategy = inject(UrlHandlingStrategy);
this._events = new Subject();
this.errorHandler = this.options.errorHandler || defaultErrorHandler2;
this.navigated = false;
this.routeReuseStrategy = inject(RouteReuseStrategy);
this.onSameUrlNavigation = this.options.onSameUrlNavigation || "ignore";
this.config = inject(ROUTES, {
optional: true
})?.flat() ?? [];
this.componentInputBindingEnabled = !!inject(INPUT_BINDER, {
optional: true
});
this.eventsSubscription = new Subscription();
this.isNgZoneEnabled = inject(NgZone) instanceof NgZone && NgZone.isInAngularZone();
this.resetConfig(this.config);
this.navigationTransitions.setupNavigations(this, this.currentUrlTree, this.routerState).subscribe({
error: (e) => {
this.console.warn(ngDevMode ? `Unhandled Navigation Error: ${e}` : e);
}
});
this.subscribeToNavigationEvents();
}
subscribeToNavigationEvents() {
const subscription = this.navigationTransitions.events.subscribe((e) => {
try {
const currentTransition = this.navigationTransitions.currentTransition;
const currentNavigation = this.navigationTransitions.currentNavigation;
if (currentTransition !== null && currentNavigation !== null) {
this.stateManager.handleRouterEvent(e, currentNavigation);
if (e instanceof NavigationCancel && e.code !== NavigationCancellationCode.Redirect && e.code !== NavigationCancellationCode.SupersededByNewNavigation) {
this.navigated = true;
} else if (e instanceof NavigationEnd) {
this.navigated = true;
} else if (e instanceof RedirectRequest) {
const mergedTree = this.urlHandlingStrategy.merge(e.url, currentTransition.currentRawUrl);
const extras = {
// Persist transient navigation info from the original navigation request.
info: currentTransition.extras.info,
skipLocationChange: currentTransition.extras.skipLocationChange,
// The URL is already updated at this point if we have 'eager' URL
// updates or if the navigation was triggered by the browser (back
// button, URL bar, etc). We want to replace that item in history
// if the navigation is rejected.
replaceUrl: this.urlUpdateStrategy === "eager" || isBrowserTriggeredNavigation(currentTransition.source)
};
this.scheduleNavigation(mergedTree, IMPERATIVE_NAVIGATION, null, extras, {
resolve: currentTransition.resolve,
reject: currentTransition.reject,
promise: currentTransition.promise
});
}
}
if (isPublicRouterEvent(e)) {
this._events.next(e);
}
} catch (e2) {
this.navigationTransitions.transitionAbortSubject.next(e2);
}
});
this.eventsSubscription.add(subscription);
}
/** @internal */
resetRootComponentType(rootComponentType) {
this.routerState.root.component = rootComponentType;
this.navigationTransitions.rootComponentType = rootComponentType;
}
/**
* Sets up the location change listener and performs the initial navigation.
*/
initialNavigation() {
this.setUpLocationChangeListener();
if (!this.navigationTransitions.hasRequestedNavigation) {
this.navigateToSyncWithBrowser(this.location.path(true), IMPERATIVE_NAVIGATION, this.stateManager.restoredState());
}
}
/**
* Sets up the location change listener. This listener detects navigations triggered from outside
* the Router (the browser back/forward buttons, for example) and schedules a corresponding Router
* navigation so that the correct events, guards, etc. are triggered.
*/
setUpLocationChangeListener() {
this.nonRouterCurrentEntryChangeSubscription ??= this.stateManager.registerNonRouterCurrentEntryChangeListener((url, state) => {
setTimeout(() => {
this.navigateToSyncWithBrowser(url, "popstate", state);
}, 0);
});
}
/**
* Schedules a router navigation to synchronize Router state with the browser state.
*
* This is done as a response to a popstate event and the initial navigation. These
* two scenarios represent times when the browser URL/state has been updated and
* the Router needs to respond to ensure its internal state matches.
*/
navigateToSyncWithBrowser(url, source, state) {
const extras = {
replaceUrl: true
};
const restoredState = state?.navigationId ? state : null;
if (state) {
const stateCopy = __spreadValues({}, state);
delete stateCopy.navigationId;
delete stateCopy.\u0275routerPageId;
if (Object.keys(stateCopy).length !== 0) {
extras.state = stateCopy;
}
}
const urlTree = this.parseUrl(url);
this.scheduleNavigation(urlTree, source, restoredState, extras);
}
/** The current URL. */
get url() {
return this.serializeUrl(this.currentUrlTree);
}
/**
* Returns the current `Navigation` object when the router is navigating,
* and `null` when idle.
*/
getCurrentNavigation() {
return this.navigationTransitions.currentNavigation;
}
/**
* The `Navigation` object of the most recent navigation to succeed and `null` if there
* has not been a successful navigation yet.
*/
get lastSuccessfulNavigation() {
return this.navigationTransitions.lastSuccessfulNavigation;
}
/**
* Resets the route configuration used for navigation and generating links.
*
* @param config The route array for the new configuration.
*
* @usageNotes
*
* ```
* router.resetConfig([
* { path: 'team/:id', component: TeamCmp, children: [
* { path: 'simple', component: SimpleCmp },
* { path: 'user/:name', component: UserCmp }
* ]}
* ]);
* ```
*/
resetConfig(config2) {
(typeof ngDevMode === "undefined" || ngDevMode) && validateConfig(config2);
this.config = config2.map(standardizeConfig);
this.navigated = false;
}
/** @nodoc */
ngOnDestroy() {
this.dispose();
}
/** Disposes of the router. */
dispose() {
this.navigationTransitions.complete();
if (this.nonRouterCurrentEntryChangeSubscription) {
this.nonRouterCurrentEntryChangeSubscription.unsubscribe();
this.nonRouterCurrentEntryChangeSubscription = void 0;
}
this.disposed = true;
this.eventsSubscription.unsubscribe();
}
/**
* Appends URL segments to the current URL tree to create a new URL tree.
*
* @param commands An array of URL fragments with which to construct the new URL tree.
* If the path is static, can be the literal URL string. For a dynamic path, pass an array of path
* segments, followed by the parameters for each segment.
* The fragments are applied to the current URL tree or the one provided in the `relativeTo`
* property of the options object, if supplied.
* @param navigationExtras Options that control the navigation strategy.
* @returns The new URL tree.
*
* @usageNotes
*
* ```
* // create /team/33/user/11
* router.createUrlTree(['/team', 33, 'user', 11]);
*
* // create /team/33;expand=true/user/11
* router.createUrlTree(['/team', 33, {expand: true}, 'user', 11]);
*
* // you can collapse static segments like this (this works only with the first passed-in value):
* router.createUrlTree(['/team/33/user', userId]);
*
* // If the first segment can contain slashes, and you do not want the router to split it,
* // you can do the following:
* router.createUrlTree([{segmentPath: '/one/two'}]);
*
* // create /team/33/(user/11//right:chat)
* router.createUrlTree(['/team', 33, {outlets: {primary: 'user/11', right: 'chat'}}]);
*
* // remove the right secondary node
* router.createUrlTree(['/team', 33, {outlets: {primary: 'user/11', right: null}}]);
*
* // assuming the current url is `/team/33/user/11` and the route points to `user/11`
*
* // navigate to /team/33/user/11/details
* router.createUrlTree(['details'], {relativeTo: route});
*
* // navigate to /team/33/user/22
* router.createUrlTree(['../22'], {relativeTo: route});
*
* // navigate to /team/44/user/22
* router.createUrlTree(['../../team/44/user/22'], {relativeTo: route});
*
* Note that a value of `null` or `undefined` for `relativeTo` indicates that the
* tree should be created relative to the root.
* ```
*/
createUrlTree(commands, navigationExtras = {}) {
const {
relativeTo,
queryParams,
fragment,
queryParamsHandling,
preserveFragment
} = navigationExtras;
const f = preserveFragment ? this.currentUrlTree.fragment : fragment;
let q = null;
switch (queryParamsHandling) {
case "merge":
q = __spreadValues(__spreadValues({}, this.currentUrlTree.queryParams), queryParams);
break;
case "preserve":
q = this.currentUrlTree.queryParams;
break;
default:
q = queryParams || null;
}
if (q !== null) {
q = this.removeEmptyProps(q);
}
let relativeToUrlSegmentGroup;
try {
const relativeToSnapshot = relativeTo ? relativeTo.snapshot : this.routerState.snapshot.root;
relativeToUrlSegmentGroup = createSegmentGroupFromRoute(relativeToSnapshot);
} catch (e) {
if (typeof commands[0] !== "string" || !commands[0].startsWith("/")) {
commands = [];
}
relativeToUrlSegmentGroup = this.currentUrlTree.root;
}
return createUrlTreeFromSegmentGroup(relativeToUrlSegmentGroup, commands, q, f ?? null);
}
/**
* Navigates to a view using an absolute route path.
*
* @param url An absolute path for a defined route. The function does not apply any delta to the
* current URL.
* @param extras An object containing properties that modify the navigation strategy.
*
* @returns A Promise that resolves to 'true' when navigation succeeds,
* to 'false' when navigation fails, or is rejected on error.
*
* @usageNotes
*
* The following calls request navigation to an absolute path.
*
* ```
* router.navigateByUrl("/team/33/user/11");
*
* // Navigate without updating the URL
* router.navigateByUrl("/team/33/user/11", { skipLocationChange: true });
* ```
*
* @see [Routing and Navigation guide](guide/router)
*
*/
navigateByUrl(url, extras = {
skipLocationChange: false
}) {
if (typeof ngDevMode === "undefined" || ngDevMode) {
if (this.isNgZoneEnabled && !NgZone.isInAngularZone()) {
this.console.warn(`Navigation triggered outside Angular zone, did you forget to call 'ngZone.run()'?`);
}
}
const urlTree = isUrlTree(url) ? url : this.parseUrl(url);
const mergedTree = this.urlHandlingStrategy.merge(urlTree, this.rawUrlTree);
return this.scheduleNavigation(mergedTree, IMPERATIVE_NAVIGATION, null, extras);
}
/**
* Navigate based on the provided array of commands and a starting point.
* If no starting route is provided, the navigation is absolute.
*
* @param commands An array of URL fragments with which to construct the target URL.
* If the path is static, can be the literal URL string. For a dynamic path, pass an array of path
* segments, followed by the parameters for each segment.
* The fragments are applied to the current URL or the one provided in the `relativeTo` property
* of the options object, if supplied.
* @param extras An options object that determines how the URL should be constructed or
* interpreted.
*
* @returns A Promise that resolves to `true` when navigation succeeds, or `false` when navigation
* fails. The Promise is rejected when an error occurs if `resolveNavigationPromiseOnError` is
* not `true`.
*
* @usageNotes
*
* The following calls request navigation to a dynamic route path relative to the current URL.
*
* ```
* router.navigate(['team', 33, 'user', 11], {relativeTo: route});
*
* // Navigate without updating the URL, overriding the default behavior
* router.navigate(['team', 33, 'user', 11], {relativeTo: route, skipLocationChange: true});
* ```
*
* @see [Routing and Navigation guide](guide/router)
*
*/
navigate(commands, extras = {
skipLocationChange: false
}) {
validateCommands(commands);
return this.navigateByUrl(this.createUrlTree(commands, extras), extras);
}
/** Serializes a `UrlTree` into a string */
serializeUrl(url) {
return this.urlSerializer.serialize(url);
}
/** Parses a string into a `UrlTree` */
parseUrl(url) {
try {
return this.urlSerializer.parse(url);
} catch {
return this.urlSerializer.parse("/");
}
}
isActive(url, matchOptions) {
let options;
if (matchOptions === true) {
options = __spreadValues({}, exactMatchOptions);
} else if (matchOptions === false) {
options = __spreadValues({}, subsetMatchOptions);
} else {
options = matchOptions;
}
if (isUrlTree(url)) {
return containsTree(this.currentUrlTree, url, options);
}
const urlTree = this.parseUrl(url);
return containsTree(this.currentUrlTree, urlTree, options);
}
removeEmptyProps(params) {
return Object.entries(params).reduce((result, [key2, value2]) => {
if (value2 !== null && value2 !== void 0) {
result[key2] = value2;
}
return result;
}, {});
}
scheduleNavigation(rawUrl, source, restoredState, extras, priorPromise) {
if (this.disposed) {
return Promise.resolve(false);
}
let resolve;
let reject;
let promise;
if (priorPromise) {
resolve = priorPromise.resolve;
reject = priorPromise.reject;
promise = priorPromise.promise;
} else {
promise = new Promise((res, rej) => {
resolve = res;
reject = rej;
});
}
const taskId = this.pendingTasks.add();
afterNextNavigation(this, () => {
queueMicrotask(() => this.pendingTasks.remove(taskId));
});
this.navigationTransitions.handleNavigationRequest({
source,
restoredState,
currentUrlTree: this.currentUrlTree,
currentRawUrl: this.currentUrlTree,
rawUrl,
extras,
resolve,
reject,
promise,
currentSnapshot: this.routerState.snapshot,
currentRouterState: this.routerState
});
return promise.catch((e) => {
return Promise.reject(e);
});
}
};
_Router.\u0275fac = function Router_Factory(t) {
return new (t || _Router)();
};
_Router.\u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
token: _Router,
factory: _Router.\u0275fac,
providedIn: "root"
});
var Router = _Router;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(Router, [{
type: Injectable,
args: [{
providedIn: "root"
}]
}], () => [], null);
})();
function validateCommands(commands) {
for (let i = 0; i < commands.length; i++) {
const cmd = commands[i];
if (cmd == null) {
throw new RuntimeError(4008, (typeof ngDevMode === "undefined" || ngDevMode) && `The requested path contains ${cmd} segment at index ${i}`);
}
}
}
function isPublicRouterEvent(e) {
return !(e instanceof BeforeActivateRoutes) && !(e instanceof RedirectRequest);
}
var _RouterLink = class _RouterLink {
constructor(router, route, tabIndexAttribute, renderer2, el, locationStrategy) {
this.router = router;
this.route = route;
this.tabIndexAttribute = tabIndexAttribute;
this.renderer = renderer2;
this.el = el;
this.locationStrategy = locationStrategy;
this.href = null;
this.commands = null;
this.onChanges = new Subject();
this.preserveFragment = false;
this.skipLocationChange = false;
this.replaceUrl = false;
const tagName = el.nativeElement.tagName?.toLowerCase();
this.isAnchorElement = tagName === "a" || tagName === "area";
if (this.isAnchorElement) {
this.subscription = router.events.subscribe((s) => {
if (s instanceof NavigationEnd) {
this.updateHref();
}
});
} else {
this.setTabIndexIfNotOnNativeEl("0");
}
}
/**
* Modifies the tab index if there was not a tabindex attribute on the element during
* instantiation.
*/
setTabIndexIfNotOnNativeEl(newTabIndex) {
if (this.tabIndexAttribute != null || this.isAnchorElement) {
return;
}
this.applyAttributeValue("tabindex", newTabIndex);
}
/** @nodoc */
ngOnChanges(changes) {
if (this.isAnchorElement) {
this.updateHref();
}
this.onChanges.next(this);
}
/**
* Commands to pass to {@link Router#createUrlTree}.
* - **array**: commands to pass to {@link Router#createUrlTree}.
* - **string**: shorthand for array of commands with just the string, i.e. `['/route']`
* - **null|undefined**: effectively disables the `routerLink`
* @see {@link Router#createUrlTree}
*/
set routerLink(commands) {
if (commands != null) {
this.commands = Array.isArray(commands) ? commands : [commands];
this.setTabIndexIfNotOnNativeEl("0");
} else {
this.commands = null;
this.setTabIndexIfNotOnNativeEl(null);
}
}
/** @nodoc */
onClick(button, ctrlKey, shiftKey, altKey, metaKey) {
const urlTree = this.urlTree;
if (urlTree === null) {
return true;
}
if (this.isAnchorElement) {
if (button !== 0 || ctrlKey || shiftKey || altKey || metaKey) {
return true;
}
if (typeof this.target === "string" && this.target != "_self") {
return true;
}
}
const extras = {
skipLocationChange: this.skipLocationChange,
replaceUrl: this.replaceUrl,
state: this.state,
info: this.info
};
this.router.navigateByUrl(urlTree, extras);
return !this.isAnchorElement;
}
/** @nodoc */
ngOnDestroy() {
this.subscription?.unsubscribe();
}
updateHref() {
const urlTree = this.urlTree;
this.href = urlTree !== null && this.locationStrategy ? this.locationStrategy?.prepareExternalUrl(this.router.serializeUrl(urlTree)) : null;
const sanitizedValue = this.href === null ? null : (
// This class represents a directive that can be added to both `<a>` elements,
// as well as other elements. As a result, we can't define security context at
// compile time. So the security context is deferred to runtime.
// The `ɵɵsanitizeUrlOrResourceUrl` selects the necessary sanitizer function
// based on the tag and property names. The logic mimics the one from
// `packages/compiler/src/schema/dom_security_schema.ts`, which is used at compile time.
//
// Note: we should investigate whether we can switch to using `@HostBinding('attr.href')`
// instead of applying a value via a renderer, after a final merge of the
// `RouterLinkWithHref` directive.
\u0275\u0275sanitizeUrlOrResourceUrl(this.href, this.el.nativeElement.tagName.toLowerCase(), "href")
);
this.applyAttributeValue("href", sanitizedValue);
}
applyAttributeValue(attrName, attrValue) {
const renderer2 = this.renderer;
const nativeElement = this.el.nativeElement;
if (attrValue !== null) {
renderer2.setAttribute(nativeElement, attrName, attrValue);
} else {
renderer2.removeAttribute(nativeElement, attrName);
}
}
get urlTree() {
if (this.commands === null) {
return null;
}
return this.router.createUrlTree(this.commands, {
// If the `relativeTo` input is not defined, we want to use `this.route` by default.
// Otherwise, we should use the value provided by the user in the input.
relativeTo: this.relativeTo !== void 0 ? this.relativeTo : this.route,
queryParams: this.queryParams,
fragment: this.fragment,
queryParamsHandling: this.queryParamsHandling,
preserveFragment: this.preserveFragment
});
}
};
_RouterLink.\u0275fac = function RouterLink_Factory(t) {
return new (t || _RouterLink)(\u0275\u0275directiveInject(Router), \u0275\u0275directiveInject(ActivatedRoute), \u0275\u0275injectAttribute("tabindex"), \u0275\u0275directiveInject(Renderer2), \u0275\u0275directiveInject(ElementRef), \u0275\u0275directiveInject(LocationStrategy));
};
_RouterLink.\u0275dir = /* @__PURE__ */ \u0275\u0275defineDirective({
type: _RouterLink,
selectors: [["", "routerLink", ""]],
hostVars: 1,
hostBindings: function RouterLink_HostBindings(rf, ctx) {
if (rf & 1) {
\u0275\u0275listener("click", function RouterLink_click_HostBindingHandler($event) {
return ctx.onClick($event.button, $event.ctrlKey, $event.shiftKey, $event.altKey, $event.metaKey);
});
}
if (rf & 2) {
\u0275\u0275attribute("target", ctx.target);
}
},
inputs: {
target: "target",
queryParams: "queryParams",
fragment: "fragment",
queryParamsHandling: "queryParamsHandling",
state: "state",
info: "info",
relativeTo: "relativeTo",
preserveFragment: [InputFlags.HasDecoratorInputTransform, "preserveFragment", "preserveFragment", booleanAttribute],
skipLocationChange: [InputFlags.HasDecoratorInputTransform, "skipLocationChange", "skipLocationChange", booleanAttribute],
replaceUrl: [InputFlags.HasDecoratorInputTransform, "replaceUrl", "replaceUrl", booleanAttribute],
routerLink: "routerLink"
},
standalone: true,
features: [\u0275\u0275InputTransformsFeature, \u0275\u0275NgOnChangesFeature]
});
var RouterLink = _RouterLink;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(RouterLink, [{
type: Directive,
args: [{
selector: "[routerLink]",
standalone: true
}]
}], () => [{
type: Router
}, {
type: ActivatedRoute
}, {
type: void 0,
decorators: [{
type: Attribute,
args: ["tabindex"]
}]
}, {
type: Renderer2
}, {
type: ElementRef
}, {
type: LocationStrategy
}], {
target: [{
type: HostBinding,
args: ["attr.target"]
}, {
type: Input
}],
queryParams: [{
type: Input
}],
fragment: [{
type: Input
}],
queryParamsHandling: [{
type: Input
}],
state: [{
type: Input
}],
info: [{
type: Input
}],
relativeTo: [{
type: Input
}],
preserveFragment: [{
type: Input,
args: [{
transform: booleanAttribute
}]
}],
skipLocationChange: [{
type: Input,
args: [{
transform: booleanAttribute
}]
}],
replaceUrl: [{
type: Input,
args: [{
transform: booleanAttribute
}]
}],
routerLink: [{
type: Input
}],
onClick: [{
type: HostListener,
args: ["click", ["$event.button", "$event.ctrlKey", "$event.shiftKey", "$event.altKey", "$event.metaKey"]]
}]
});
})();
var _RouterLinkActive = class _RouterLinkActive {
get isActive() {
return this._isActive;
}
constructor(router, element, renderer2, cdr, link) {
this.router = router;
this.element = element;
this.renderer = renderer2;
this.cdr = cdr;
this.link = link;
this.classes = [];
this._isActive = false;
this.routerLinkActiveOptions = {
exact: false
};
this.isActiveChange = new EventEmitter();
this.routerEventsSubscription = router.events.subscribe((s) => {
if (s instanceof NavigationEnd) {
this.update();
}
});
}
/** @nodoc */
ngAfterContentInit() {
of(this.links.changes, of(null)).pipe(mergeAll()).subscribe((_) => {
this.update();
this.subscribeToEachLinkOnChanges();
});
}
subscribeToEachLinkOnChanges() {
this.linkInputChangesSubscription?.unsubscribe();
const allLinkChanges = [...this.links.toArray(), this.link].filter((link) => !!link).map((link) => link.onChanges);
this.linkInputChangesSubscription = from(allLinkChanges).pipe(mergeAll()).subscribe((link) => {
if (this._isActive !== this.isLinkActive(this.router)(link)) {
this.update();
}
});
}
set routerLinkActive(data2) {
const classes = Array.isArray(data2) ? data2 : data2.split(" ");
this.classes = classes.filter((c) => !!c);
}
/** @nodoc */
ngOnChanges(changes) {
this.update();
}
/** @nodoc */
ngOnDestroy() {
this.routerEventsSubscription.unsubscribe();
this.linkInputChangesSubscription?.unsubscribe();
}
update() {
if (!this.links || !this.router.navigated)
return;
queueMicrotask(() => {
const hasActiveLinks = this.hasActiveLinks();
this.classes.forEach((c) => {
if (hasActiveLinks) {
this.renderer.addClass(this.element.nativeElement, c);
} else {
this.renderer.removeClass(this.element.nativeElement, c);
}
});
if (hasActiveLinks && this.ariaCurrentWhenActive !== void 0) {
this.renderer.setAttribute(this.element.nativeElement, "aria-current", this.ariaCurrentWhenActive.toString());
} else {
this.renderer.removeAttribute(this.element.nativeElement, "aria-current");
}
if (this._isActive !== hasActiveLinks) {
this._isActive = hasActiveLinks;
this.cdr.markForCheck();
this.isActiveChange.emit(hasActiveLinks);
}
});
}
isLinkActive(router) {
const options = isActiveMatchOptions(this.routerLinkActiveOptions) ? this.routerLinkActiveOptions : (
// While the types should disallow `undefined` here, it's possible without strict inputs
this.routerLinkActiveOptions.exact || false
);
return (link) => {
const urlTree = link.urlTree;
return urlTree ? router.isActive(urlTree, options) : false;
};
}
hasActiveLinks() {
const isActiveCheckFn = this.isLinkActive(this.router);
return this.link && isActiveCheckFn(this.link) || this.links.some(isActiveCheckFn);
}
};
_RouterLinkActive.\u0275fac = function RouterLinkActive_Factory(t) {
return new (t || _RouterLinkActive)(\u0275\u0275directiveInject(Router), \u0275\u0275directiveInject(ElementRef), \u0275\u0275directiveInject(Renderer2), \u0275\u0275directiveInject(ChangeDetectorRef), \u0275\u0275directiveInject(RouterLink, 8));
};
_RouterLinkActive.\u0275dir = /* @__PURE__ */ \u0275\u0275defineDirective({
type: _RouterLinkActive,
selectors: [["", "routerLinkActive", ""]],
contentQueries: function RouterLinkActive_ContentQueries(rf, ctx, dirIndex) {
if (rf & 1) {
\u0275\u0275contentQuery(dirIndex, RouterLink, 5);
}
if (rf & 2) {
let _t;
\u0275\u0275queryRefresh(_t = \u0275\u0275loadQuery()) && (ctx.links = _t);
}
},
inputs: {
routerLinkActiveOptions: "routerLinkActiveOptions",
ariaCurrentWhenActive: "ariaCurrentWhenActive",
routerLinkActive: "routerLinkActive"
},
outputs: {
isActiveChange: "isActiveChange"
},
exportAs: ["routerLinkActive"],
standalone: true,
features: [\u0275\u0275NgOnChangesFeature]
});
var RouterLinkActive = _RouterLinkActive;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(RouterLinkActive, [{
type: Directive,
args: [{
selector: "[routerLinkActive]",
exportAs: "routerLinkActive",
standalone: true
}]
}], () => [{
type: Router
}, {
type: ElementRef
}, {
type: Renderer2
}, {
type: ChangeDetectorRef
}, {
type: RouterLink,
decorators: [{
type: Optional
}]
}], {
links: [{
type: ContentChildren,
args: [RouterLink, {
descendants: true
}]
}],
routerLinkActiveOptions: [{
type: Input
}],
ariaCurrentWhenActive: [{
type: Input
}],
isActiveChange: [{
type: Output
}],
routerLinkActive: [{
type: Input
}]
});
})();
function isActiveMatchOptions(options) {
return !!options.paths;
}
var PreloadingStrategy = class {
};
var _PreloadAllModules = class _PreloadAllModules {
preload(route, fn) {
return fn().pipe(catchError(() => of(null)));
}
};
_PreloadAllModules.\u0275fac = function PreloadAllModules_Factory(t) {
return new (t || _PreloadAllModules)();
};
_PreloadAllModules.\u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
token: _PreloadAllModules,
factory: _PreloadAllModules.\u0275fac,
providedIn: "root"
});
var PreloadAllModules = _PreloadAllModules;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(PreloadAllModules, [{
type: Injectable,
args: [{
providedIn: "root"
}]
}], null, null);
})();
var _NoPreloading = class _NoPreloading {
preload(route, fn) {
return of(null);
}
};
_NoPreloading.\u0275fac = function NoPreloading_Factory(t) {
return new (t || _NoPreloading)();
};
_NoPreloading.\u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
token: _NoPreloading,
factory: _NoPreloading.\u0275fac,
providedIn: "root"
});
var NoPreloading = _NoPreloading;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(NoPreloading, [{
type: Injectable,
args: [{
providedIn: "root"
}]
}], null, null);
})();
var _RouterPreloader = class _RouterPreloader {
constructor(router, compiler, injector, preloadingStrategy, loader) {
this.router = router;
this.injector = injector;
this.preloadingStrategy = preloadingStrategy;
this.loader = loader;
}
setUpPreloading() {
this.subscription = this.router.events.pipe(filter((e) => e instanceof NavigationEnd), concatMap(() => this.preload())).subscribe(() => {
});
}
preload() {
return this.processRoutes(this.injector, this.router.config);
}
/** @nodoc */
ngOnDestroy() {
if (this.subscription) {
this.subscription.unsubscribe();
}
}
processRoutes(injector, routes2) {
const res = [];
for (const route of routes2) {
if (route.providers && !route._injector) {
route._injector = createEnvironmentInjector(route.providers, injector, `Route: ${route.path}`);
}
const injectorForCurrentRoute = route._injector ?? injector;
const injectorForChildren = route._loadedInjector ?? injectorForCurrentRoute;
if (route.loadChildren && !route._loadedRoutes && route.canLoad === void 0 || route.loadComponent && !route._loadedComponent) {
res.push(this.preloadConfig(injectorForCurrentRoute, route));
}
if (route.children || route._loadedRoutes) {
res.push(this.processRoutes(injectorForChildren, route.children ?? route._loadedRoutes));
}
}
return from(res).pipe(mergeAll());
}
preloadConfig(injector, route) {
return this.preloadingStrategy.preload(route, () => {
let loadedChildren$;
if (route.loadChildren && route.canLoad === void 0) {
loadedChildren$ = this.loader.loadChildren(injector, route);
} else {
loadedChildren$ = of(null);
}
const recursiveLoadChildren$ = loadedChildren$.pipe(mergeMap((config2) => {
if (config2 === null) {
return of(void 0);
}
route._loadedRoutes = config2.routes;
route._loadedInjector = config2.injector;
return this.processRoutes(config2.injector ?? injector, config2.routes);
}));
if (route.loadComponent && !route._loadedComponent) {
const loadComponent$ = this.loader.loadComponent(route);
return from([recursiveLoadChildren$, loadComponent$]).pipe(mergeAll());
} else {
return recursiveLoadChildren$;
}
});
}
};
_RouterPreloader.\u0275fac = function RouterPreloader_Factory(t) {
return new (t || _RouterPreloader)(\u0275\u0275inject(Router), \u0275\u0275inject(Compiler), \u0275\u0275inject(EnvironmentInjector), \u0275\u0275inject(PreloadingStrategy), \u0275\u0275inject(RouterConfigLoader));
};
_RouterPreloader.\u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
token: _RouterPreloader,
factory: _RouterPreloader.\u0275fac,
providedIn: "root"
});
var RouterPreloader = _RouterPreloader;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(RouterPreloader, [{
type: Injectable,
args: [{
providedIn: "root"
}]
}], () => [{
type: Router
}, {
type: Compiler
}, {
type: EnvironmentInjector
}, {
type: PreloadingStrategy
}, {
type: RouterConfigLoader
}], null);
})();
var ROUTER_SCROLLER = new InjectionToken("");
var _RouterScroller = class _RouterScroller {
/** @nodoc */
constructor(urlSerializer, transitions, viewportScroller, zone, options = {}) {
this.urlSerializer = urlSerializer;
this.transitions = transitions;
this.viewportScroller = viewportScroller;
this.zone = zone;
this.options = options;
this.lastId = 0;
this.lastSource = "imperative";
this.restoredId = 0;
this.store = {};
this.environmentInjector = inject(EnvironmentInjector);
options.scrollPositionRestoration ||= "disabled";
options.anchorScrolling ||= "disabled";
}
init() {
if (this.options.scrollPositionRestoration !== "disabled") {
this.viewportScroller.setHistoryScrollRestoration("manual");
}
this.routerEventsSubscription = this.createScrollEvents();
this.scrollEventsSubscription = this.consumeScrollEvents();
}
createScrollEvents() {
return this.transitions.events.subscribe((e) => {
if (e instanceof NavigationStart) {
this.store[this.lastId] = this.viewportScroller.getScrollPosition();
this.lastSource = e.navigationTrigger;
this.restoredId = e.restoredState ? e.restoredState.navigationId : 0;
} else if (e instanceof NavigationEnd) {
this.lastId = e.id;
this.scheduleScrollEvent(e, this.urlSerializer.parse(e.urlAfterRedirects).fragment);
} else if (e instanceof NavigationSkipped && e.code === NavigationSkippedCode.IgnoredSameUrlNavigation) {
this.lastSource = void 0;
this.restoredId = 0;
this.scheduleScrollEvent(e, this.urlSerializer.parse(e.url).fragment);
}
});
}
consumeScrollEvents() {
return this.transitions.events.subscribe((e) => {
if (!(e instanceof Scroll))
return;
if (e.position) {
if (this.options.scrollPositionRestoration === "top") {
this.viewportScroller.scrollToPosition([0, 0]);
} else if (this.options.scrollPositionRestoration === "enabled") {
this.viewportScroller.scrollToPosition(e.position);
}
} else {
if (e.anchor && this.options.anchorScrolling === "enabled") {
this.viewportScroller.scrollToAnchor(e.anchor);
} else if (this.options.scrollPositionRestoration !== "disabled") {
this.viewportScroller.scrollToPosition([0, 0]);
}
}
});
}
scheduleScrollEvent(routerEvent, anchor) {
this.zone.runOutsideAngular(() => __async(this, null, function* () {
yield new Promise((resolve) => {
setTimeout(() => {
resolve();
});
afterNextRender(() => {
resolve();
}, {
injector: this.environmentInjector
});
});
this.zone.run(() => {
this.transitions.events.next(new Scroll(routerEvent, this.lastSource === "popstate" ? this.store[this.restoredId] : null, anchor));
});
}));
}
/** @nodoc */
ngOnDestroy() {
this.routerEventsSubscription?.unsubscribe();
this.scrollEventsSubscription?.unsubscribe();
}
};
_RouterScroller.\u0275fac = function RouterScroller_Factory(t) {
\u0275\u0275invalidFactory();
};
_RouterScroller.\u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
token: _RouterScroller,
factory: _RouterScroller.\u0275fac
});
var RouterScroller = _RouterScroller;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(RouterScroller, [{
type: Injectable
}], () => [{
type: UrlSerializer
}, {
type: NavigationTransitions
}, {
type: ViewportScroller
}, {
type: NgZone
}, {
type: void 0
}], null);
})();
function provideRouter(routes2, ...features) {
return makeEnvironmentProviders([{
provide: ROUTES,
multi: true,
useValue: routes2
}, typeof ngDevMode === "undefined" || ngDevMode ? {
provide: ROUTER_IS_PROVIDED,
useValue: true
} : [], {
provide: ActivatedRoute,
useFactory: rootRoute,
deps: [Router]
}, {
provide: APP_BOOTSTRAP_LISTENER,
multi: true,
useFactory: getBootstrapListener
}, features.map((feature) => feature.\u0275providers)]);
}
function rootRoute(router) {
return router.routerState.root;
}
function routerFeature(kind, providers) {
return {
\u0275kind: kind,
\u0275providers: providers
};
}
var ROUTER_IS_PROVIDED = new InjectionToken("", {
providedIn: "root",
factory: () => false
});
function getBootstrapListener() {
const injector = inject(Injector);
return (bootstrappedComponentRef) => {
const ref = injector.get(ApplicationRef);
if (bootstrappedComponentRef !== ref.components[0]) {
return;
}
const router = injector.get(Router);
const bootstrapDone = injector.get(BOOTSTRAP_DONE);
if (injector.get(INITIAL_NAVIGATION) === 1) {
router.initialNavigation();
}
injector.get(ROUTER_PRELOADER, null, InjectFlags.Optional)?.setUpPreloading();
injector.get(ROUTER_SCROLLER, null, InjectFlags.Optional)?.init();
router.resetRootComponentType(ref.componentTypes[0]);
if (!bootstrapDone.closed) {
bootstrapDone.next();
bootstrapDone.complete();
bootstrapDone.unsubscribe();
}
};
}
var BOOTSTRAP_DONE = new InjectionToken(typeof ngDevMode === "undefined" || ngDevMode ? "bootstrap done indicator" : "", {
factory: () => {
return new Subject();
}
});
var INITIAL_NAVIGATION = new InjectionToken(typeof ngDevMode === "undefined" || ngDevMode ? "initial navigation" : "", {
providedIn: "root",
factory: () => 1
/* InitialNavigation.EnabledNonBlocking */
});
function withEnabledBlockingInitialNavigation() {
const providers = [{
provide: INITIAL_NAVIGATION,
useValue: 0
/* InitialNavigation.EnabledBlocking */
}, {
provide: APP_INITIALIZER,
multi: true,
deps: [Injector],
useFactory: (injector) => {
const locationInitialized = injector.get(LOCATION_INITIALIZED, Promise.resolve());
return () => {
return locationInitialized.then(() => {
return new Promise((resolve) => {
const router = injector.get(Router);
const bootstrapDone = injector.get(BOOTSTRAP_DONE);
afterNextNavigation(router, () => {
resolve(true);
});
injector.get(NavigationTransitions).afterPreactivation = () => {
resolve(true);
return bootstrapDone.closed ? of(void 0) : bootstrapDone;
};
router.initialNavigation();
});
});
};
}
}];
return routerFeature(2, providers);
}
function withDisabledInitialNavigation() {
const providers = [{
provide: APP_INITIALIZER,
multi: true,
useFactory: () => {
const router = inject(Router);
return () => {
router.setUpLocationChangeListener();
};
}
}, {
provide: INITIAL_NAVIGATION,
useValue: 2
/* InitialNavigation.Disabled */
}];
return routerFeature(3, providers);
}
function withDebugTracing() {
let providers = [];
if (typeof ngDevMode === "undefined" || ngDevMode) {
providers = [{
provide: ENVIRONMENT_INITIALIZER,
multi: true,
useFactory: () => {
const router = inject(Router);
return () => router.events.subscribe((e) => {
console.group?.(`Router Event: ${e.constructor.name}`);
console.log(stringifyEvent(e));
console.log(e);
console.groupEnd?.();
});
}
}];
} else {
providers = [];
}
return routerFeature(1, providers);
}
var ROUTER_PRELOADER = new InjectionToken(typeof ngDevMode === "undefined" || ngDevMode ? "router preloader" : "");
function withPreloading(preloadingStrategy) {
const providers = [{
provide: ROUTER_PRELOADER,
useExisting: RouterPreloader
}, {
provide: PreloadingStrategy,
useExisting: preloadingStrategy
}];
return routerFeature(0, providers);
}
function withComponentInputBinding() {
const providers = [RoutedComponentInputBinder, {
provide: INPUT_BINDER,
useExisting: RoutedComponentInputBinder
}];
return routerFeature(8, providers);
}
function withViewTransitions(options) {
const providers = [{
provide: CREATE_VIEW_TRANSITION,
useValue: createViewTransition
}, {
provide: VIEW_TRANSITION_OPTIONS,
useValue: __spreadValues({
skipNextTransition: !!options?.skipInitialTransition
}, options)
}];
return routerFeature(9, providers);
}
var ROUTER_DIRECTIVES = [RouterOutlet, RouterLink, RouterLinkActive, \u0275EmptyOutletComponent];
var ROUTER_FORROOT_GUARD = new InjectionToken(typeof ngDevMode === "undefined" || ngDevMode ? "router duplicate forRoot guard" : "ROUTER_FORROOT_GUARD");
var ROUTER_PROVIDERS = [
Location,
{
provide: UrlSerializer,
useClass: DefaultUrlSerializer
},
Router,
ChildrenOutletContexts,
{
provide: ActivatedRoute,
useFactory: rootRoute,
deps: [Router]
},
RouterConfigLoader,
// Only used to warn when `provideRoutes` is used without `RouterModule` or `provideRouter`. Can
// be removed when `provideRoutes` is removed.
typeof ngDevMode === "undefined" || ngDevMode ? {
provide: ROUTER_IS_PROVIDED,
useValue: true
} : []
];
var _RouterModule = class _RouterModule {
constructor(guard) {
}
/**
* Creates and configures a module with all the router providers and directives.
* Optionally sets up an application listener to perform an initial navigation.
*
* When registering the NgModule at the root, import as follows:
*
* ```
* @NgModule({
* imports: [RouterModule.forRoot(ROUTES)]
* })
* class MyNgModule {}
* ```
*
* @param routes An array of `Route` objects that define the navigation paths for the application.
* @param config An `ExtraOptions` configuration object that controls how navigation is performed.
* @return The new `NgModule`.
*
*/
static forRoot(routes2, config2) {
return {
ngModule: _RouterModule,
providers: [ROUTER_PROVIDERS, typeof ngDevMode === "undefined" || ngDevMode ? config2?.enableTracing ? withDebugTracing().\u0275providers : [] : [], {
provide: ROUTES,
multi: true,
useValue: routes2
}, {
provide: ROUTER_FORROOT_GUARD,
useFactory: provideForRootGuard,
deps: [[Router, new Optional(), new SkipSelf()]]
}, {
provide: ROUTER_CONFIGURATION,
useValue: config2 ? config2 : {}
}, config2?.useHash ? provideHashLocationStrategy() : providePathLocationStrategy(), provideRouterScroller(), config2?.preloadingStrategy ? withPreloading(config2.preloadingStrategy).\u0275providers : [], config2?.initialNavigation ? provideInitialNavigation(config2) : [], config2?.bindToComponentInputs ? withComponentInputBinding().\u0275providers : [], config2?.enableViewTransitions ? withViewTransitions().\u0275providers : [], provideRouterInitializer()]
};
}
/**
* Creates a module with all the router directives and a provider registering routes,
* without creating a new Router service.
* When registering for submodules and lazy-loaded submodules, create the NgModule as follows:
*
* ```
* @NgModule({
* imports: [RouterModule.forChild(ROUTES)]
* })
* class MyNgModule {}
* ```
*
* @param routes An array of `Route` objects that define the navigation paths for the submodule.
* @return The new NgModule.
*
*/
static forChild(routes2) {
return {
ngModule: _RouterModule,
providers: [{
provide: ROUTES,
multi: true,
useValue: routes2
}]
};
}
};
_RouterModule.\u0275fac = function RouterModule_Factory(t) {
return new (t || _RouterModule)(\u0275\u0275inject(ROUTER_FORROOT_GUARD, 8));
};
_RouterModule.\u0275mod = /* @__PURE__ */ \u0275\u0275defineNgModule({
type: _RouterModule
});
_RouterModule.\u0275inj = /* @__PURE__ */ \u0275\u0275defineInjector({});
var RouterModule = _RouterModule;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(RouterModule, [{
type: NgModule,
args: [{
imports: ROUTER_DIRECTIVES,
exports: ROUTER_DIRECTIVES
}]
}], () => [{
type: void 0,
decorators: [{
type: Optional
}, {
type: Inject,
args: [ROUTER_FORROOT_GUARD]
}]
}], null);
})();
function provideRouterScroller() {
return {
provide: ROUTER_SCROLLER,
useFactory: () => {
const viewportScroller = inject(ViewportScroller);
const zone = inject(NgZone);
const config2 = inject(ROUTER_CONFIGURATION);
const transitions = inject(NavigationTransitions);
const urlSerializer = inject(UrlSerializer);
if (config2.scrollOffset) {
viewportScroller.setOffset(config2.scrollOffset);
}
return new RouterScroller(urlSerializer, transitions, viewportScroller, zone, config2);
}
};
}
function provideHashLocationStrategy() {
return {
provide: LocationStrategy,
useClass: HashLocationStrategy
};
}
function providePathLocationStrategy() {
return {
provide: LocationStrategy,
useClass: PathLocationStrategy
};
}
function provideForRootGuard(router) {
if ((typeof ngDevMode === "undefined" || ngDevMode) && router) {
throw new RuntimeError(4007, `The Router was provided more than once. This can happen if 'forRoot' is used outside of the root injector. Lazy loaded modules should use RouterModule.forChild() instead.`);
}
return "guarded";
}
function provideInitialNavigation(config2) {
return [config2.initialNavigation === "disabled" ? withDisabledInitialNavigation().\u0275providers : [], config2.initialNavigation === "enabledBlocking" ? withEnabledBlockingInitialNavigation().\u0275providers : []];
}
var ROUTER_INITIALIZER = new InjectionToken(typeof ngDevMode === "undefined" || ngDevMode ? "Router Initializer" : "");
function provideRouterInitializer() {
return [
// ROUTER_INITIALIZER token should be removed. It's public API but shouldn't be. We can just
// have `getBootstrapListener` directly attached to APP_BOOTSTRAP_LISTENER.
{
provide: ROUTER_INITIALIZER,
useFactory: getBootstrapListener
},
{
provide: APP_BOOTSTRAP_LISTENER,
multi: true,
useExisting: ROUTER_INITIALIZER
}
];
}
var VERSION4 = new Version("17.3.12");
// node_modules/angularx-qrcode/fesm2022/angularx-qrcode.mjs
var import_qrcode = __toESM(require_browser(), 1);
var _c0 = ["qrcElement"];
var _QRCodeComponent = class _QRCodeComponent {
constructor(renderer2, sanitizer) {
this.renderer = renderer2;
this.sanitizer = sanitizer;
this.allowEmptyString = false;
this.colorDark = "#000000ff";
this.colorLight = "#ffffffff";
this.cssClass = "qrcode";
this.elementType = "canvas";
this.errorCorrectionLevel = "M";
this.margin = 4;
this.qrdata = "";
this.scale = 4;
this.width = 10;
this.qrCodeURL = new EventEmitter();
this.context = null;
}
ngOnChanges() {
return __async(this, null, function* () {
yield this.createQRCode();
});
}
isValidQrCodeText(data2) {
if (this.allowEmptyString === false) {
return !(typeof data2 === "undefined" || data2 === "" || data2 === "null" || data2 === null);
}
return !(typeof data2 === "undefined");
}
toDataURL(qrCodeConfig) {
return new Promise((resolve, reject) => {
(0, import_qrcode.toDataURL)(this.qrdata, qrCodeConfig, (err, url) => {
if (err) {
reject(err);
} else {
resolve(url);
}
});
});
}
toCanvas(canvas, qrCodeConfig) {
return new Promise((resolve, reject) => {
(0, import_qrcode.toCanvas)(canvas, this.qrdata, qrCodeConfig, (error) => {
if (error) {
reject(error);
} else {
resolve("success");
}
});
});
}
toSVG(qrCodeConfig) {
return new Promise((resolve, reject) => {
(0, import_qrcode.toString)(this.qrdata, qrCodeConfig, (err, url) => {
if (err) {
reject(err);
} else {
resolve(url);
}
});
});
}
renderElement(element) {
for (const node of this.qrcElement.nativeElement.childNodes) {
this.renderer.removeChild(this.qrcElement.nativeElement, node);
}
this.renderer.appendChild(this.qrcElement.nativeElement, element);
}
createQRCode() {
return __async(this, null, function* () {
if (this.version && this.version > 40) {
console.warn("[angularx-qrcode] max value for `version` is 40");
this.version = 40;
} else if (this.version && this.version < 1) {
console.warn("[angularx-qrcode]`min value for `version` is 1");
this.version = 1;
} else if (this.version !== void 0 && isNaN(this.version)) {
console.warn("[angularx-qrcode] version should be a number, defaulting to auto.");
this.version = void 0;
}
try {
if (!this.isValidQrCodeText(this.qrdata)) {
throw new Error("[angularx-qrcode] Field `qrdata` is empty, set 'allowEmptyString=\"true\"' to overwrite this behaviour.");
}
if (this.isValidQrCodeText(this.qrdata) && this.qrdata === "") {
this.qrdata = " ";
}
const config2 = {
color: {
dark: this.colorDark,
light: this.colorLight
},
errorCorrectionLevel: this.errorCorrectionLevel,
margin: this.margin,
scale: this.scale,
version: this.version,
width: this.width
};
const centerImageSrc = this.imageSrc;
const centerImageHeight = this.imageHeight || 40;
const centerImageWidth = this.imageWidth || 40;
switch (this.elementType) {
case "canvas": {
const canvasElement = this.renderer.createElement("canvas");
this.context = canvasElement.getContext("2d");
this.toCanvas(canvasElement, config2).then(() => {
if (this.ariaLabel) {
this.renderer.setAttribute(canvasElement, "aria-label", `${this.ariaLabel}`);
}
if (this.title) {
this.renderer.setAttribute(canvasElement, "title", `${this.title}`);
}
if (centerImageSrc && this.context) {
this.centerImage = new Image(centerImageWidth, centerImageHeight);
if (centerImageSrc !== this.centerImage.src) {
this.centerImage.src = centerImageSrc;
}
if (centerImageHeight !== this.centerImage.height) {
this.centerImage.height = centerImageHeight;
}
if (centerImageWidth !== this.centerImage.width) {
this.centerImage.width = centerImageWidth;
}
const centerImage = this.centerImage;
if (centerImage) {
centerImage.onload = () => {
this.context?.drawImage(centerImage, canvasElement.width / 2 - centerImageWidth / 2, canvasElement.height / 2 - centerImageHeight / 2, centerImageWidth, centerImageHeight);
};
}
}
this.renderElement(canvasElement);
this.emitQRCodeURL(canvasElement);
}).catch((e) => {
console.error("[angularx-qrcode] canvas error:", e);
});
break;
}
case "svg": {
const svgParentElement = this.renderer.createElement("div");
this.toSVG(config2).then((svgString) => {
this.renderer.setProperty(svgParentElement, "innerHTML", svgString);
const svgElement = svgParentElement.firstChild;
this.renderer.setAttribute(svgElement, "height", `${this.width}`);
this.renderer.setAttribute(svgElement, "width", `${this.width}`);
this.renderElement(svgElement);
this.emitQRCodeURL(svgElement);
}).catch((e) => {
console.error("[angularx-qrcode] svg error:", e);
});
break;
}
case "url":
case "img":
default: {
const imgElement = this.renderer.createElement("img");
this.toDataURL(config2).then((dataUrl) => {
if (this.alt) {
imgElement.setAttribute("alt", this.alt);
}
if (this.ariaLabel) {
imgElement.setAttribute("aria-label", this.ariaLabel);
}
imgElement.setAttribute("src", dataUrl);
if (this.title) {
imgElement.setAttribute("title", this.title);
}
this.renderElement(imgElement);
this.emitQRCodeURL(imgElement);
}).catch((e) => {
console.error("[angularx-qrcode] img/url error:", e);
});
}
}
} catch (e) {
console.error("[angularx-qrcode] Error generating QR Code:", e.message);
}
});
}
emitQRCodeURL(element) {
const className = element.constructor.name;
if (className === SVGSVGElement.name) {
const svgHTML = element.outerHTML;
const blob = new Blob([svgHTML], {
type: "image/svg+xml"
});
const urlSvg = URL.createObjectURL(blob);
const urlSanitized = this.sanitizer.bypassSecurityTrustUrl(urlSvg);
this.qrCodeURL.emit(urlSanitized);
return;
}
let urlImage = "";
if (className === HTMLCanvasElement.name) {
urlImage = element.toDataURL("image/png");
}
if (className === HTMLImageElement.name) {
urlImage = element.src;
}
fetch(urlImage).then((urlResponse) => urlResponse.blob()).then((blob) => URL.createObjectURL(blob)).then((url) => this.sanitizer.bypassSecurityTrustUrl(url)).then((urlSanitized) => {
this.qrCodeURL.emit(urlSanitized);
}).catch((error) => {
console.error("[angularx-qrcode] Error when fetching image/png URL: " + error);
});
}
};
_QRCodeComponent.\u0275fac = function QRCodeComponent_Factory(t) {
return new (t || _QRCodeComponent)(\u0275\u0275directiveInject(Renderer2), \u0275\u0275directiveInject(DomSanitizer));
};
_QRCodeComponent.\u0275cmp = /* @__PURE__ */ \u0275\u0275defineComponent({
type: _QRCodeComponent,
selectors: [["qrcode"]],
viewQuery: function QRCodeComponent_Query(rf, ctx) {
if (rf & 1) {
\u0275\u0275viewQuery(_c0, 7);
}
if (rf & 2) {
let _t;
\u0275\u0275queryRefresh(_t = \u0275\u0275loadQuery()) && (ctx.qrcElement = _t.first);
}
},
inputs: {
allowEmptyString: "allowEmptyString",
colorDark: "colorDark",
colorLight: "colorLight",
cssClass: "cssClass",
elementType: "elementType",
errorCorrectionLevel: "errorCorrectionLevel",
imageSrc: "imageSrc",
imageHeight: "imageHeight",
imageWidth: "imageWidth",
margin: "margin",
qrdata: "qrdata",
scale: "scale",
version: "version",
width: "width",
alt: "alt",
ariaLabel: "ariaLabel",
title: "title"
},
outputs: {
qrCodeURL: "qrCodeURL"
},
features: [\u0275\u0275NgOnChangesFeature],
decls: 2,
vars: 2,
consts: [["qrcElement", ""]],
template: function QRCodeComponent_Template(rf, ctx) {
if (rf & 1) {
\u0275\u0275element(0, "div", null, 0);
}
if (rf & 2) {
\u0275\u0275classMap(ctx.cssClass);
}
},
encapsulation: 2,
changeDetection: 0
});
var QRCodeComponent = _QRCodeComponent;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(QRCodeComponent, [{
type: Component,
args: [{
selector: "qrcode",
changeDetection: ChangeDetectionStrategy.OnPush,
template: `<div #qrcElement [class]="cssClass"></div>`
}]
}], () => [{
type: Renderer2
}, {
type: DomSanitizer
}], {
allowEmptyString: [{
type: Input
}],
colorDark: [{
type: Input
}],
colorLight: [{
type: Input
}],
cssClass: [{
type: Input
}],
elementType: [{
type: Input
}],
errorCorrectionLevel: [{
type: Input
}],
imageSrc: [{
type: Input
}],
imageHeight: [{
type: Input
}],
imageWidth: [{
type: Input
}],
margin: [{
type: Input
}],
qrdata: [{
type: Input
}],
scale: [{
type: Input
}],
version: [{
type: Input
}],
width: [{
type: Input
}],
alt: [{
type: Input
}],
ariaLabel: [{
type: Input
}],
title: [{
type: Input
}],
qrCodeURL: [{
type: Output
}],
qrcElement: [{
type: ViewChild,
args: ["qrcElement", {
static: true
}]
}]
});
})();
var _QRCodeModule = class _QRCodeModule {
};
_QRCodeModule.\u0275fac = function QRCodeModule_Factory(t) {
return new (t || _QRCodeModule)();
};
_QRCodeModule.\u0275mod = /* @__PURE__ */ \u0275\u0275defineNgModule({
type: _QRCodeModule
});
_QRCodeModule.\u0275inj = /* @__PURE__ */ \u0275\u0275defineInjector({});
var QRCodeModule = _QRCodeModule;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(QRCodeModule, [{
type: NgModule,
args: [{
providers: [],
declarations: [QRCodeComponent],
exports: [QRCodeComponent]
}]
}], null, null);
})();
// src/app/shared/enums/link-status.ts
var LinkStatus;
(function(LinkStatus2) {
LinkStatus2["PENDING"] = "PENDING";
LinkStatus2["USED"] = "USED";
LinkStatus2["EXPIRED"] = "EXPIRED";
LinkStatus2["ACTIVE"] = "ACTIVE";
LinkStatus2["INACTIVE"] = "INACTIVE";
})(LinkStatus || (LinkStatus = {}));
// src/environments/environment.ts
var environment = {
production: false,
apiUrl: "https://paytek-africa.net:11901/api/apps",
apiKey: "31|YEwf8ocRy4zyiFGdPKJTXxkkRfKRXbrcjnyfe8Q1",
appId: "3576128409",
apiPublicKey: `-----BEGIN PUBLIC KEY-----
MIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEA0tnN71ibgTryKECTMvt7
M+eqaJwib5ln/Xpk0FA6arbeXlFA2Qr+Wnxf1u5bFABRFZCr4y7df/Bq4tLgY81U
UgjKN9M6Ygi5wnNUqzly+DDz6avidkm8OErhVGl1ir+nVgy4Ivx09u9um+nf/ua1
kZ8KJM2u57nKsCdXhilPoif18X6s+jo33L66aVuAczo+785scOhYvcYWPtH0815a
z6MnbBqBlZ0CGlA4YudiRa3Hm+gYROk/UU7Ol0kWh0hLFwht9LHsDIMI6N3rdCRs
T8rNz3NOdZ5RoXUx8uGwBwH2DHx1IV0AhMGVUjJNCzdYF9MhzCm45FLcSh+VSZ0i
ZoHQIvabkZI77qhe7FfVPqKl9JUt60t0VngCzgx/ql3hg3stNWhQcP/pFeZA7nig
oILojBw1Jr0DlrPmQJ1ff/GlwfbJgY16rlhqdtwPzboRfrDk3QNANygOq8rlTdfy
ku1Y7Xwrk4XOo9ybEjh4HLSuWdd8LdEaOTgn8nInwz2X2dBRlFWmNZ9vyqx26KQC
8akW7O/1M1iocDKAzmphAFQqYoDkUj3GmcoZObBrg4h8KsWjcJjez8I1jw1znppc
IxhAgP/ncQcgZm3QMWPJS2YQEPOqmSEAfx2JyyUT3CSzZP03p1jxV2vNqo0PLGy5
6c/RwJbODviY6LabqtFCBB8CAwEAAQ==
-----END PUBLIC KEY-----`,
pusherKey: "ad52cb097fca7bdd5e08",
pusherCluster: "ap2",
pusherChannel: "payments"
};
// src/app/services/pusher.service.ts
var import_pusher_js = __toESM(require_pusher());
var _PusherService = class _PusherService {
constructor() {
this.pusher = new import_pusher_js.default(environment.pusherKey, {
cluster: environment.pusherCluster
});
}
listen(channelName, eventName, callback) {
let channel = this.pusher.subscribe(channelName);
channel.bind(eventName, callback);
}
unsubscribe(eventName) {
this.channel.unbind(eventName);
}
disconnect() {
this.pusher.disconnect();
}
};
_PusherService.\u0275fac = function PusherService_Factory(t) {
return new (t || _PusherService)();
};
_PusherService.\u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({ token: _PusherService, factory: _PusherService.\u0275fac, providedIn: "root" });
var PusherService = _PusherService;
// src/app/shared/enums/payment-status.ts
var PaymentStatus;
(function(PaymentStatus2) {
PaymentStatus2["PENDING"] = "PENDING";
PaymentStatus2["SUCCESS"] = "SUCCESS";
PaymentStatus2["FAILED"] = "FAILED";
PaymentStatus2["REJECTED"] = "REJECTED";
PaymentStatus2["EXPIRED"] = "EXPIRED";
})(PaymentStatus || (PaymentStatus = {}));
// node_modules/uuid/dist/esm-browser/stringify.js
var byteToHex = [];
for (let i = 0; i < 256; ++i) {
byteToHex.push((i + 256).toString(16).slice(1));
}
function unsafeStringify(arr, offset = 0) {
return (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();
}
// node_modules/uuid/dist/esm-browser/rng.js
var getRandomValues;
var rnds8 = new Uint8Array(16);
function rng() {
if (!getRandomValues) {
if (typeof crypto === "undefined" || !crypto.getRandomValues) {
throw new Error("crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported");
}
getRandomValues = crypto.getRandomValues.bind(crypto);
}
return getRandomValues(rnds8);
}
// node_modules/uuid/dist/esm-browser/native.js
var randomUUID = typeof crypto !== "undefined" && crypto.randomUUID && crypto.randomUUID.bind(crypto);
var native_default = { randomUUID };
// node_modules/uuid/dist/esm-browser/v4.js
function v4(options, buf, offset) {
if (native_default.randomUUID && !buf && !options) {
return native_default.randomUUID();
}
options = options || {};
const rnds = options.random ?? options.rng?.() ?? rng();
if (rnds.length < 16) {
throw new Error("Random bytes length must be >= 16");
}
rnds[6] = rnds[6] & 15 | 64;
rnds[8] = rnds[8] & 63 | 128;
if (buf) {
offset = offset || 0;
if (offset < 0 || offset + 16 > buf.length) {
throw new RangeError(`UUID byte range ${offset}:${offset + 15} is out of buffer bounds`);
}
for (let i = 0; i < 16; ++i) {
buf[offset + i] = rnds[i];
}
return buf;
}
return unsafeStringify(rnds);
}
var v4_default = v4;
// src/app/shared/utils/utils.ts
function generateUuid() {
return v4_default().replace(/-/g, "").substring(0, 12);
}
function closeWindow() {
window.close();
}
// src/app/services/cache.service.ts
var _CacheService = class _CacheService {
constructor() {
this.cacheKey = "httpCache";
}
put(url, response) {
const cache = this.getCache();
cache[url] = response;
sessionStorage.setItem(this.cacheKey, JSON.stringify(cache));
}
get(url) {
const cache = this.getCache();
return cache[url] || null;
}
clear() {
sessionStorage.removeItem(this.cacheKey);
}
getCache() {
const cache = sessionStorage.getItem(this.cacheKey);
return cache ? JSON.parse(cache) : {};
}
};
_CacheService.\u0275fac = function CacheService_Factory(t) {
return new (t || _CacheService)();
};
_CacheService.\u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({ token: _CacheService, factory: _CacheService.\u0275fac, providedIn: "root" });
var CacheService = _CacheService;
// src/app/services/payment.service.ts
var _PaymentService = class _PaymentService {
constructor() {
this.http = inject(HttpClient);
this.cache = inject(CacheService);
this.pusherServ = inject(PusherService);
}
getLinkInformation(linkId) {
const url = `https://imali.co.mz:11901/api/get-store-link/${linkId}`;
const linkCache = this.cache.get(url);
if (linkCache) {
return of(linkCache);
}
return this.http.get(url).pipe(map((data2) => {
console.log(data2);
const rawData = data2.data[0];
const response = __spreadProps(__spreadValues({}, rawData), {
status: rawData.status
});
this.cache.put(url, response);
return response;
}));
}
getAvailablePaymentServices() {
const url = `${environment.apiUrl}/get-payment-services`;
const avaliablePaymentServicesCache = this.cache.get(url);
if (avaliablePaymentServicesCache) {
return of(avaliablePaymentServicesCache);
}
return this.http.get(url).pipe(map((data2) => {
const response = data2.data ?? [];
console.log(response);
this.cache.put(url, response);
return response;
}));
}
makePayment() {
}
/**
*
* @param paymentNumber
* @param amount
* @param store_number
* @param paymentMethod
* @param paymentType
* @returns
*
* @deprecated
*/
createPayment(paymentNumber, amount, store_number, paymentMethod, paymentType) {
const partner_transaction_id = generateUuid();
return this.http.post(`https://imali.co.mz:11901/api/imaliway/v2/payments`, {
"client_account_number": paymentNumber,
"amount": amount,
"store_account_number": store_number,
"partner_transaction_id": partner_transaction_id,
"payment_method": paymentMethod.toLowerCase(),
"payment_type": paymentType
}).pipe(switchMap(({ data: initialPayment }) => {
return interval(1e4).pipe(startWith(0), switchMap(() => this.http.get(`https://imali.co.mz:11901/api/imaliway/v2/payments/status`, {
params: {
"partner_transaction_id": partner_transaction_id,
"payment_type": paymentType
}
}).pipe(map(({ data: payment }) => payment), catchError((err) => {
console.error("Error fetching payment:", err);
return of(initialPayment);
}))), takeWhile((payment) => payment.status === PaymentStatus.PENDING, true));
}));
}
};
_PaymentService.\u0275fac = function PaymentService_Factory(t) {
return new (t || _PaymentService)();
};
_PaymentService.\u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({ token: _PaymentService, factory: _PaymentService.\u0275fac, providedIn: "root" });
var PaymentService = _PaymentService;
// src/app/shared/services/link.service.ts
var _LinkService = class _LinkService {
setLinkInformation(linkInfo) {
this.linkInformation.set(linkInfo);
}
setPaymentInput(paymentMethod, paymentNumber) {
this.paymentMethod = paymentMethod;
this.paymentNumber = paymentNumber;
}
// setPaymentResult(payment: Payment){
// this.payment.set(payment)
// }
getLinkInformation() {
return this.linkInformation();
}
getPaymentMethod() {
return this.paymentMethod;
}
getPaymentNumber() {
return this.paymentNumber;
}
getPayment() {
return this.payment();
}
clear() {
this.payment.set({});
this.paymentNumber = "";
this.paymentMethod = "";
this.linkInformation.set({});
}
constructor() {
this.linkInformation = signal({});
this.paymentMethod = "";
this.paymentNumber = "";
this.payment = signal({});
}
};
_LinkService.\u0275fac = function LinkService_Factory(t) {
return new (t || _LinkService)();
};
_LinkService.\u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({ token: _LinkService, factory: _LinkService.\u0275fac, providedIn: "root" });
var LinkService = _LinkService;
// src/app/home/home.component.ts
var _c02 = (a0) => ({ "color": a0 });
var _c1 = (a0) => ({ "background-color": a0 });
var _c2 = (a0) => ["/payment", a0];
function HomeComponent_div_22_Template(rf, ctx) {
if (rf & 1) {
\u0275\u0275elementStart(0, "div", 9)(1, "label", 10);
\u0275\u0275text(2, "Nota");
\u0275\u0275elementEnd();
\u0275\u0275elementStart(3, "p", 11);
\u0275\u0275text(4);
\u0275\u0275elementEnd()();
}
if (rf & 2) {
const ctx_r0 = \u0275\u0275nextContext();
\u0275\u0275advance(4);
\u0275\u0275textInterpolate(ctx_r0.info == null ? null : ctx_r0.info.short_description);
}
}
function HomeComponent_button_24_Template(rf, ctx) {
if (rf & 1) {
\u0275\u0275elementStart(0, "button", 26);
\u0275\u0275element(1, "img", 27);
\u0275\u0275elementEnd();
}
if (rf & 2) {
const pservic_r2 = ctx.$implicit;
\u0275\u0275property("routerLink", \u0275\u0275pureFunction1(4, _c2, pservic_r2.name));
\u0275\u0275advance();
\u0275\u0275property("src", pservic_r2.logo, \u0275\u0275sanitizeUrl)("alt", pservic_r2.name)("ngStyle", \u0275\u0275pureFunction1(6, _c1, pservic_r2.color));
}
}
var _HomeComponent = class _HomeComponent {
constructor(router, route, paymentServ, linkServ) {
this.router = router;
this.route = route;
this.paymentServ = paymentServ;
this.linkServ = linkServ;
this.customPurple = "#6D50E3";
this.linkId = "";
this.paymentServs = [];
this.info = null;
this.pusherServ = inject(PusherService);
}
ngOnInit() {
this.pusherServ.listen("paymentss", "payment-push", (data2) => {
console.log(`Push: ${data2}`);
});
this.pusherServ.listen("paymments", "payment-qrcode", (data2) => {
console.log(`QrCode: ${data2}`);
});
this.paymentServ.makePayment();
this.linkServ.clear();
this.linkId = this.route.snapshot.paramMap.get("linkId");
this.paymentServ.getLinkInformation(this.linkId).subscribe({
next: (data2) => {
if (data2.status !== LinkStatus.PENDING && data2.status !== LinkStatus.ACTIVE) {
this.router.navigate([data2.status?.toLowerCase()]);
}
this.info = data2;
this.linkServ.setLinkInformation(data2);
},
error: (error) => {
this.router.navigate(["not-found"]);
}
});
this.paymentServ.getAvailablePaymentServices().subscribe({
next: (data2) => {
this.paymentServs = data2;
this.paymentServs.forEach((paymentSer) => {
switch (paymentSer.name) {
case "iMali":
paymentSer.color = "#FFFFFF";
break;
case "eMola":
paymentSer.color = "#F37227";
break;
case "mKesh":
paymentSer.color = "#FFD200";
break;
case "MPesa":
paymentSer.color = "#E70101";
break;
}
});
}
});
}
};
_HomeComponent.\u0275fac = function HomeComponent_Factory(t) {
return new (t || _HomeComponent)(\u0275\u0275directiveInject(Router), \u0275\u0275directiveInject(ActivatedRoute), \u0275\u0275directiveInject(PaymentService), \u0275\u0275directiveInject(LinkService));
};
_HomeComponent.\u0275cmp = /* @__PURE__ */ \u0275\u0275defineComponent({ type: _HomeComponent, selectors: [["app-home"]], standalone: true, features: [\u0275\u0275StandaloneFeature], decls: 41, vars: 17, consts: [[1, "flex"], [1, "h-screen", "flex-[7]", "flex", "flex-col", "justify-center", "items-center", "bg-slate-200"], [1, "w-full", "flex", "px-8", "items-center", "sm:justify-center", "md:space-x-16", "pb-4", "pt-24"], [1, "flex", "flex-col", "space-y-2", "ml-2"], [1, "text-sm", "md:text-base", "truncate", "w-56", "sm:w-64", "md:w-72", "lg:w-96"], [1, "font-bold"], [1, "text-sm", "lg:text-3xl"], ["colorLight", "#E2E8F0", 3, "qrdata"], [1, "space-y-5"], [1, "w-screen", "max-w-[21rem]", "md:max-w-xl", "px-4", "py-3", "rounded-lg", "shadow-sm", "bg-white"], [1, "block", "text-sm", "text-gray-400"], [1, "mt-1", "text-base", "text-black", "font-semibold"], ["class", "w-screen max-w-[21rem] md:max-w-xl px-4 py-3 rounded-lg shadow-sm bg-white", 4, "ngIf"], [1, "grid", "grid-cols-2", "gap-6", "py-20"], ["class", "flex justify-center items-center", 3, "routerLink", 4, "ngFor", "ngForOf"], [1, "text-center", "pb-20"], [1, "text-gray-400"], ["href", "https://imali.co.mz/politicas-de-privacidade/", "target", "_blank", 1, "no-underline", 3, "ngStyle"], [1, "flex-[3]", "bg-slate-200", "hidden", "lg:block"], [1, "flex", "flex-col", "justify-evenly", "items-center", "h-screen", "rounded-s-[2rem]", 3, "ngStyle"], ["src", "assets/images/imali_logo_white.png", "alt", "imali_logo", 1, "w-20"], [1, "text-white", "py-10"], ["href", "https://imali.co.mz/", "target", "_blank", 1, "text-white", "underline"], [1, "relative"], ["src", "assets/images/tv.png", "alt", "tv", 1, "h-44"], ["src", "assets/images/lightbulb.png", "alt", "lightbulb", 1, "h-52", "absolute", "bottom-0", "left-0", "translate-x-[-44%]", "translate-y-[30%]"], [1, "flex", "justify-center", "items-center", 3, "routerLink"], [1, "w-44", "h-16", "object-contain", "rounded-full", 3, "src", "alt", "ngStyle"]], template: function HomeComponent_Template(rf, ctx) {
if (rf & 1) {
\u0275\u0275elementStart(0, "div", 0)(1, "div", 1)(2, "div", 2)(3, "div", 3)(4, "p", 4);
\u0275\u0275text(5, " Comerciante: ");
\u0275\u0275elementStart(6, "span", 5);
\u0275\u0275text(7);
\u0275\u0275elementEnd()();
\u0275\u0275elementStart(8, "p", 6)(9, "span", 5);
\u0275\u0275text(10);
\u0275\u0275pipe(11, "currency");
\u0275\u0275elementEnd();
\u0275\u0275elementStart(12, "span");
\u0275\u0275text(13, " MZN ");
\u0275\u0275elementEnd()()();
\u0275\u0275elementStart(14, "div");
\u0275\u0275element(15, "qrcode", 7);
\u0275\u0275elementEnd()();
\u0275\u0275elementStart(16, "div", 8)(17, "div", 9)(18, "label", 10);
\u0275\u0275text(19, "Nome do produto");
\u0275\u0275elementEnd();
\u0275\u0275elementStart(20, "p", 11);
\u0275\u0275text(21);
\u0275\u0275elementEnd()();
\u0275\u0275template(22, HomeComponent_div_22_Template, 5, 1, "div", 12);
\u0275\u0275elementEnd();
\u0275\u0275elementStart(23, "div", 13);
\u0275\u0275template(24, HomeComponent_button_24_Template, 2, 8, "button", 14);
\u0275\u0275elementEnd();
\u0275\u0275elementStart(25, "div", 15)(26, "p", 16);
\u0275\u0275text(27, "Ao realizar um pagamento, concorda com os nossos");
\u0275\u0275elementEnd();
\u0275\u0275elementStart(28, "a", 17);
\u0275\u0275text(29, "Termos de Servi\xE7o Gerais");
\u0275\u0275elementEnd()()();
\u0275\u0275elementStart(30, "div", 18)(31, "div", 19)(32, "div");
\u0275\u0275element(33, "img", 20);
\u0275\u0275elementStart(34, "p", 21);
\u0275\u0275text(35, "Aproveita o teu dinheiro da melhor forma.");
\u0275\u0275elementEnd();
\u0275\u0275elementStart(36, "a", 22);
\u0275\u0275text(37, "Saber Mais");
\u0275\u0275elementEnd()();
\u0275\u0275elementStart(38, "div", 23);
\u0275\u0275element(39, "img", 24)(40, "img", 25);
\u0275\u0275elementEnd()()()();
}
if (rf & 2) {
\u0275\u0275advance(7);
\u0275\u0275textInterpolate(ctx.info == null ? null : ctx.info.store_name);
\u0275\u0275advance(3);
\u0275\u0275textInterpolate(\u0275\u0275pipeBind4(11, 8, ctx.info == null ? null : ctx.info.amount, "", "", "1.2-2"));
\u0275\u0275advance(5);
\u0275\u0275property("qrdata", "Your data string");
\u0275\u0275advance(6);
\u0275\u0275textInterpolate(ctx.info == null ? null : ctx.info.title);
\u0275\u0275advance();
\u0275\u0275property("ngIf", (ctx.info == null ? null : ctx.info.short_description) != void 0);
\u0275\u0275advance(2);
\u0275\u0275property("ngForOf", ctx.paymentServs);
\u0275\u0275advance(4);
\u0275\u0275property("ngStyle", \u0275\u0275pureFunction1(13, _c02, ctx.customPurple));
\u0275\u0275advance(3);
\u0275\u0275property("ngStyle", \u0275\u0275pureFunction1(15, _c1, ctx.customPurple));
}
}, dependencies: [NgForOf, NgIf, QRCodeModule, QRCodeComponent, CurrencyPipe, NgStyle, RouterLink], styles: ["\n\n/*# sourceMappingURL=home.component.css.map */"] });
var HomeComponent = _HomeComponent;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && \u0275setClassDebugInfo(HomeComponent, { className: "HomeComponent", filePath: "src/app/home/home.component.ts", lineNumber: 20 });
})();
// node_modules/@angular/forms/fesm2022/forms.mjs
var _BaseControlValueAccessor = class _BaseControlValueAccessor {
constructor(_renderer, _elementRef) {
this._renderer = _renderer;
this._elementRef = _elementRef;
this.onChange = (_) => {
};
this.onTouched = () => {
};
}
/**
* Helper method that sets a property on a target element using the current Renderer
* implementation.
* @nodoc
*/
setProperty(key2, value2) {
this._renderer.setProperty(this._elementRef.nativeElement, key2, value2);
}
/**
* Registers a function called when the control is touched.
* @nodoc
*/
registerOnTouched(fn) {
this.onTouched = fn;
}
/**
* Registers a function called when the control value changes.
* @nodoc
*/
registerOnChange(fn) {
this.onChange = fn;
}
/**
* Sets the "disabled" property on the range input element.
* @nodoc
*/
setDisabledState(isDisabled) {
this.setProperty("disabled", isDisabled);
}
};
_BaseControlValueAccessor.\u0275fac = function BaseControlValueAccessor_Factory(t) {
return new (t || _BaseControlValueAccessor)(\u0275\u0275directiveInject(Renderer2), \u0275\u0275directiveInject(ElementRef));
};
_BaseControlValueAccessor.\u0275dir = /* @__PURE__ */ \u0275\u0275defineDirective({
type: _BaseControlValueAccessor
});
var BaseControlValueAccessor = _BaseControlValueAccessor;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(BaseControlValueAccessor, [{
type: Directive
}], () => [{
type: Renderer2
}, {
type: ElementRef
}], null);
})();
var _BuiltInControlValueAccessor = class _BuiltInControlValueAccessor extends BaseControlValueAccessor {
};
_BuiltInControlValueAccessor.\u0275fac = /* @__PURE__ */ (() => {
let \u0275BuiltInControlValueAccessor_BaseFactory;
return function BuiltInControlValueAccessor_Factory(t) {
return (\u0275BuiltInControlValueAccessor_BaseFactory || (\u0275BuiltInControlValueAccessor_BaseFactory = \u0275\u0275getInheritedFactory(_BuiltInControlValueAccessor)))(t || _BuiltInControlValueAccessor);
};
})();
_BuiltInControlValueAccessor.\u0275dir = /* @__PURE__ */ \u0275\u0275defineDirective({
type: _BuiltInControlValueAccessor,
features: [\u0275\u0275InheritDefinitionFeature]
});
var BuiltInControlValueAccessor = _BuiltInControlValueAccessor;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(BuiltInControlValueAccessor, [{
type: Directive
}], null, null);
})();
var NG_VALUE_ACCESSOR = new InjectionToken(ngDevMode ? "NgValueAccessor" : "");
var CHECKBOX_VALUE_ACCESSOR = {
provide: NG_VALUE_ACCESSOR,
useExisting: forwardRef(() => CheckboxControlValueAccessor),
multi: true
};
var _CheckboxControlValueAccessor = class _CheckboxControlValueAccessor extends BuiltInControlValueAccessor {
/**
* Sets the "checked" property on the input element.
* @nodoc
*/
writeValue(value2) {
this.setProperty("checked", value2);
}
};
_CheckboxControlValueAccessor.\u0275fac = /* @__PURE__ */ (() => {
let \u0275CheckboxControlValueAccessor_BaseFactory;
return function CheckboxControlValueAccessor_Factory(t) {
return (\u0275CheckboxControlValueAccessor_BaseFactory || (\u0275CheckboxControlValueAccessor_BaseFactory = \u0275\u0275getInheritedFactory(_CheckboxControlValueAccessor)))(t || _CheckboxControlValueAccessor);
};
})();
_CheckboxControlValueAccessor.\u0275dir = /* @__PURE__ */ \u0275\u0275defineDirective({
type: _CheckboxControlValueAccessor,
selectors: [["input", "type", "checkbox", "formControlName", ""], ["input", "type", "checkbox", "formControl", ""], ["input", "type", "checkbox", "ngModel", ""]],
hostBindings: function CheckboxControlValueAccessor_HostBindings(rf, ctx) {
if (rf & 1) {
\u0275\u0275listener("change", function CheckboxControlValueAccessor_change_HostBindingHandler($event) {
return ctx.onChange($event.target.checked);
})("blur", function CheckboxControlValueAccessor_blur_HostBindingHandler() {
return ctx.onTouched();
});
}
},
features: [\u0275\u0275ProvidersFeature([CHECKBOX_VALUE_ACCESSOR]), \u0275\u0275InheritDefinitionFeature]
});
var CheckboxControlValueAccessor = _CheckboxControlValueAccessor;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(CheckboxControlValueAccessor, [{
type: Directive,
args: [{
selector: "input[type=checkbox][formControlName],input[type=checkbox][formControl],input[type=checkbox][ngModel]",
host: {
"(change)": "onChange($event.target.checked)",
"(blur)": "onTouched()"
},
providers: [CHECKBOX_VALUE_ACCESSOR]
}]
}], null, null);
})();
var DEFAULT_VALUE_ACCESSOR = {
provide: NG_VALUE_ACCESSOR,
useExisting: forwardRef(() => DefaultValueAccessor),
multi: true
};
function _isAndroid() {
const userAgent = getDOM() ? getDOM().getUserAgent() : "";
return /android (\d+)/.test(userAgent.toLowerCase());
}
var COMPOSITION_BUFFER_MODE = new InjectionToken(ngDevMode ? "CompositionEventMode" : "");
var _DefaultValueAccessor = class _DefaultValueAccessor extends BaseControlValueAccessor {
constructor(renderer2, elementRef, _compositionMode) {
super(renderer2, elementRef);
this._compositionMode = _compositionMode;
this._composing = false;
if (this._compositionMode == null) {
this._compositionMode = !_isAndroid();
}
}
/**
* Sets the "value" property on the input element.
* @nodoc
*/
writeValue(value2) {
const normalizedValue = value2 == null ? "" : value2;
this.setProperty("value", normalizedValue);
}
/** @internal */
_handleInput(value2) {
if (!this._compositionMode || this._compositionMode && !this._composing) {
this.onChange(value2);
}
}
/** @internal */
_compositionStart() {
this._composing = true;
}
/** @internal */
_compositionEnd(value2) {
this._composing = false;
this._compositionMode && this.onChange(value2);
}
};
_DefaultValueAccessor.\u0275fac = function DefaultValueAccessor_Factory(t) {
return new (t || _DefaultValueAccessor)(\u0275\u0275directiveInject(Renderer2), \u0275\u0275directiveInject(ElementRef), \u0275\u0275directiveInject(COMPOSITION_BUFFER_MODE, 8));
};
_DefaultValueAccessor.\u0275dir = /* @__PURE__ */ \u0275\u0275defineDirective({
type: _DefaultValueAccessor,
selectors: [["input", "formControlName", "", 3, "type", "checkbox"], ["textarea", "formControlName", ""], ["input", "formControl", "", 3, "type", "checkbox"], ["textarea", "formControl", ""], ["input", "ngModel", "", 3, "type", "checkbox"], ["textarea", "ngModel", ""], ["", "ngDefaultControl", ""]],
hostBindings: function DefaultValueAccessor_HostBindings(rf, ctx) {
if (rf & 1) {
\u0275\u0275listener("input", function DefaultValueAccessor_input_HostBindingHandler($event) {
return ctx._handleInput($event.target.value);
})("blur", function DefaultValueAccessor_blur_HostBindingHandler() {
return ctx.onTouched();
})("compositionstart", function DefaultValueAccessor_compositionstart_HostBindingHandler() {
return ctx._compositionStart();
})("compositionend", function DefaultValueAccessor_compositionend_HostBindingHandler($event) {
return ctx._compositionEnd($event.target.value);
});
}
},
features: [\u0275\u0275ProvidersFeature([DEFAULT_VALUE_ACCESSOR]), \u0275\u0275InheritDefinitionFeature]
});
var DefaultValueAccessor = _DefaultValueAccessor;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(DefaultValueAccessor, [{
type: Directive,
args: [{
selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]",
// TODO: vsavkin replace the above selector with the one below it once
// https://github.com/angular/angular/issues/3011 is implemented
// selector: '[ngModel],[formControl],[formControlName]',
host: {
"(input)": "$any(this)._handleInput($event.target.value)",
"(blur)": "onTouched()",
"(compositionstart)": "$any(this)._compositionStart()",
"(compositionend)": "$any(this)._compositionEnd($event.target.value)"
},
providers: [DEFAULT_VALUE_ACCESSOR]
}]
}], () => [{
type: Renderer2
}, {
type: ElementRef
}, {
type: void 0,
decorators: [{
type: Optional
}, {
type: Inject,
args: [COMPOSITION_BUFFER_MODE]
}]
}], null);
})();
function isEmptyInputValue(value2) {
return value2 == null || (typeof value2 === "string" || Array.isArray(value2)) && value2.length === 0;
}
function hasValidLength(value2) {
return value2 != null && typeof value2.length === "number";
}
var NG_VALIDATORS = new InjectionToken(ngDevMode ? "NgValidators" : "");
var NG_ASYNC_VALIDATORS = new InjectionToken(ngDevMode ? "NgAsyncValidators" : "");
var EMAIL_REGEXP = /^(?=.{1,254}$)(?=.{1,64}@)[a-zA-Z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-zA-Z0-9!#$%&'*+/=?^_`{|}~-]+)*@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/;
function minValidator(min) {
return (control) => {
if (isEmptyInputValue(control.value) || isEmptyInputValue(min)) {
return null;
}
const value2 = parseFloat(control.value);
return !isNaN(value2) && value2 < min ? {
"min": {
"min": min,
"actual": control.value
}
} : null;
};
}
function maxValidator(max) {
return (control) => {
if (isEmptyInputValue(control.value) || isEmptyInputValue(max)) {
return null;
}
const value2 = parseFloat(control.value);
return !isNaN(value2) && value2 > max ? {
"max": {
"max": max,
"actual": control.value
}
} : null;
};
}
function requiredValidator(control) {
return isEmptyInputValue(control.value) ? {
"required": true
} : null;
}
function requiredTrueValidator(control) {
return control.value === true ? null : {
"required": true
};
}
function emailValidator(control) {
if (isEmptyInputValue(control.value)) {
return null;
}
return EMAIL_REGEXP.test(control.value) ? null : {
"email": true
};
}
function minLengthValidator(minLength) {
return (control) => {
if (isEmptyInputValue(control.value) || !hasValidLength(control.value)) {
return null;
}
return control.value.length < minLength ? {
"minlength": {
"requiredLength": minLength,
"actualLength": control.value.length
}
} : null;
};
}
function maxLengthValidator(maxLength) {
return (control) => {
return hasValidLength(control.value) && control.value.length > maxLength ? {
"maxlength": {
"requiredLength": maxLength,
"actualLength": control.value.length
}
} : null;
};
}
function patternValidator(pattern) {
if (!pattern)
return nullValidator;
let regex;
let regexStr;
if (typeof pattern === "string") {
regexStr = "";
if (pattern.charAt(0) !== "^")
regexStr += "^";
regexStr += pattern;
if (pattern.charAt(pattern.length - 1) !== "$")
regexStr += "$";
regex = new RegExp(regexStr);
} else {
regexStr = pattern.toString();
regex = pattern;
}
return (control) => {
if (isEmptyInputValue(control.value)) {
return null;
}
const value2 = control.value;
return regex.test(value2) ? null : {
"pattern": {
"requiredPattern": regexStr,
"actualValue": value2
}
};
};
}
function nullValidator(control) {
return null;
}
function isPresent(o) {
return o != null;
}
function toObservable(value2) {
const obs = isPromise2(value2) ? from(value2) : value2;
if ((typeof ngDevMode === "undefined" || ngDevMode) && !isSubscribable(obs)) {
let errorMessage = `Expected async validator to return Promise or Observable.`;
if (typeof value2 === "object") {
errorMessage += " Are you using a synchronous validator where an async validator is expected?";
}
throw new RuntimeError(-1101, errorMessage);
}
return obs;
}
function mergeErrors(arrayOfErrors) {
let res = {};
arrayOfErrors.forEach((errors) => {
res = errors != null ? __spreadValues(__spreadValues({}, res), errors) : res;
});
return Object.keys(res).length === 0 ? null : res;
}
function executeValidators(control, validators) {
return validators.map((validator) => validator(control));
}
function isValidatorFn(validator) {
return !validator.validate;
}
function normalizeValidators(validators) {
return validators.map((validator) => {
return isValidatorFn(validator) ? validator : (c) => validator.validate(c);
});
}
function compose(validators) {
if (!validators)
return null;
const presentValidators = validators.filter(isPresent);
if (presentValidators.length == 0)
return null;
return function(control) {
return mergeErrors(executeValidators(control, presentValidators));
};
}
function composeValidators(validators) {
return validators != null ? compose(normalizeValidators(validators)) : null;
}
function composeAsync(validators) {
if (!validators)
return null;
const presentValidators = validators.filter(isPresent);
if (presentValidators.length == 0)
return null;
return function(control) {
const observables = executeValidators(control, presentValidators).map(toObservable);
return forkJoin(observables).pipe(map(mergeErrors));
};
}
function composeAsyncValidators(validators) {
return validators != null ? composeAsync(normalizeValidators(validators)) : null;
}
function mergeValidators(controlValidators, dirValidator) {
if (controlValidators === null)
return [dirValidator];
return Array.isArray(controlValidators) ? [...controlValidators, dirValidator] : [controlValidators, dirValidator];
}
function getControlValidators(control) {
return control._rawValidators;
}
function getControlAsyncValidators(control) {
return control._rawAsyncValidators;
}
function makeValidatorsArray(validators) {
if (!validators)
return [];
return Array.isArray(validators) ? validators : [validators];
}
function hasValidator(validators, validator) {
return Array.isArray(validators) ? validators.includes(validator) : validators === validator;
}
function addValidators(validators, currentValidators) {
const current = makeValidatorsArray(currentValidators);
const validatorsToAdd = makeValidatorsArray(validators);
validatorsToAdd.forEach((v) => {
if (!hasValidator(current, v)) {
current.push(v);
}
});
return current;
}
function removeValidators(validators, currentValidators) {
return makeValidatorsArray(currentValidators).filter((v) => !hasValidator(validators, v));
}
var AbstractControlDirective = class {
constructor() {
this._rawValidators = [];
this._rawAsyncValidators = [];
this._onDestroyCallbacks = [];
}
/**
* @description
* Reports the value of the control if it is present, otherwise null.
*/
get value() {
return this.control ? this.control.value : null;
}
/**
* @description
* Reports whether the control is valid. A control is considered valid if no
* validation errors exist with the current value.
* If the control is not present, null is returned.
*/
get valid() {
return this.control ? this.control.valid : null;
}
/**
* @description
* Reports whether the control is invalid, meaning that an error exists in the input value.
* If the control is not present, null is returned.
*/
get invalid() {
return this.control ? this.control.invalid : null;
}
/**
* @description
* Reports whether a control is pending, meaning that async validation is occurring and
* errors are not yet available for the input value. If the control is not present, null is
* returned.
*/
get pending() {
return this.control ? this.control.pending : null;
}
/**
* @description
* Reports whether the control is disabled, meaning that the control is disabled
* in the UI and is exempt from validation checks and excluded from aggregate
* values of ancestor controls. If the control is not present, null is returned.
*/
get disabled() {
return this.control ? this.control.disabled : null;
}
/**
* @description
* Reports whether the control is enabled, meaning that the control is included in ancestor
* calculations of validity or value. If the control is not present, null is returned.
*/
get enabled() {
return this.control ? this.control.enabled : null;
}
/**
* @description
* Reports the control's validation errors. If the control is not present, null is returned.
*/
get errors() {
return this.control ? this.control.errors : null;
}
/**
* @description
* Reports whether the control is pristine, meaning that the user has not yet changed
* the value in the UI. If the control is not present, null is returned.
*/
get pristine() {
return this.control ? this.control.pristine : null;
}
/**
* @description
* Reports whether the control is dirty, meaning that the user has changed
* the value in the UI. If the control is not present, null is returned.
*/
get dirty() {
return this.control ? this.control.dirty : null;
}
/**
* @description
* Reports whether the control is touched, meaning that the user has triggered
* a `blur` event on it. If the control is not present, null is returned.
*/
get touched() {
return this.control ? this.control.touched : null;
}
/**
* @description
* Reports the validation status of the control. Possible values include:
* 'VALID', 'INVALID', 'DISABLED', and 'PENDING'.
* If the control is not present, null is returned.
*/
get status() {
return this.control ? this.control.status : null;
}
/**
* @description
* Reports whether the control is untouched, meaning that the user has not yet triggered
* a `blur` event on it. If the control is not present, null is returned.
*/
get untouched() {
return this.control ? this.control.untouched : null;
}
/**
* @description
* Returns a multicasting observable that emits a validation status whenever it is
* calculated for the control. If the control is not present, null is returned.
*/
get statusChanges() {
return this.control ? this.control.statusChanges : null;
}
/**
* @description
* Returns a multicasting observable of value changes for the control that emits every time the
* value of the control changes in the UI or programmatically.
* If the control is not present, null is returned.
*/
get valueChanges() {
return this.control ? this.control.valueChanges : null;
}
/**
* @description
* Returns an array that represents the path from the top-level form to this control.
* Each index is the string name of the control on that level.
*/
get path() {
return null;
}
/**
* Sets synchronous validators for this directive.
* @internal
*/
_setValidators(validators) {
this._rawValidators = validators || [];
this._composedValidatorFn = composeValidators(this._rawValidators);
}
/**
* Sets asynchronous validators for this directive.
* @internal
*/
_setAsyncValidators(validators) {
this._rawAsyncValidators = validators || [];
this._composedAsyncValidatorFn = composeAsyncValidators(this._rawAsyncValidators);
}
/**
* @description
* Synchronous validator function composed of all the synchronous validators registered with this
* directive.
*/
get validator() {
return this._composedValidatorFn || null;
}
/**
* @description
* Asynchronous validator function composed of all the asynchronous validators registered with
* this directive.
*/
get asyncValidator() {
return this._composedAsyncValidatorFn || null;
}
/**
* Internal function to register callbacks that should be invoked
* when directive instance is being destroyed.
* @internal
*/
_registerOnDestroy(fn) {
this._onDestroyCallbacks.push(fn);
}
/**
* Internal function to invoke all registered "on destroy" callbacks.
* Note: calling this function also clears the list of callbacks.
* @internal
*/
_invokeOnDestroyCallbacks() {
this._onDestroyCallbacks.forEach((fn) => fn());
this._onDestroyCallbacks = [];
}
/**
* @description
* Resets the control with the provided value if the control is present.
*/
reset(value2 = void 0) {
if (this.control)
this.control.reset(value2);
}
/**
* @description
* Reports whether the control with the given path has the error specified.
*
* @param errorCode The code of the error to check
* @param path A list of control names that designates how to move from the current control
* to the control that should be queried for errors.
*
* @usageNotes
* For example, for the following `FormGroup`:
*
* ```
* form = new FormGroup({
* address: new FormGroup({ street: new FormControl() })
* });
* ```
*
* The path to the 'street' control from the root form would be 'address' -> 'street'.
*
* It can be provided to this method in one of two formats:
*
* 1. An array of string control names, e.g. `['address', 'street']`
* 1. A period-delimited list of control names in one string, e.g. `'address.street'`
*
* If no path is given, this method checks for the error on the current control.
*
* @returns whether the given error is present in the control at the given path.
*
* If the control is not present, false is returned.
*/
hasError(errorCode, path) {
return this.control ? this.control.hasError(errorCode, path) : false;
}
/**
* @description
* Reports error data for the control with the given path.
*
* @param errorCode The code of the error to check
* @param path A list of control names that designates how to move from the current control
* to the control that should be queried for errors.
*
* @usageNotes
* For example, for the following `FormGroup`:
*
* ```
* form = new FormGroup({
* address: new FormGroup({ street: new FormControl() })
* });
* ```
*
* The path to the 'street' control from the root form would be 'address' -> 'street'.
*
* It can be provided to this method in one of two formats:
*
* 1. An array of string control names, e.g. `['address', 'street']`
* 1. A period-delimited list of control names in one string, e.g. `'address.street'`
*
* @returns error data for that particular error. If the control or error is not present,
* null is returned.
*/
getError(errorCode, path) {
return this.control ? this.control.getError(errorCode, path) : null;
}
};
var ControlContainer = class extends AbstractControlDirective {
/**
* @description
* The top-level form directive for the control.
*/
get formDirective() {
return null;
}
/**
* @description
* The path to this group.
*/
get path() {
return null;
}
};
var NgControl = class extends AbstractControlDirective {
constructor() {
super(...arguments);
this._parent = null;
this.name = null;
this.valueAccessor = null;
}
};
var AbstractControlStatus = class {
constructor(cd) {
this._cd = cd;
}
get isTouched() {
return !!this._cd?.control?.touched;
}
get isUntouched() {
return !!this._cd?.control?.untouched;
}
get isPristine() {
return !!this._cd?.control?.pristine;
}
get isDirty() {
return !!this._cd?.control?.dirty;
}
get isValid() {
return !!this._cd?.control?.valid;
}
get isInvalid() {
return !!this._cd?.control?.invalid;
}
get isPending() {
return !!this._cd?.control?.pending;
}
get isSubmitted() {
return !!this._cd?.submitted;
}
};
var ngControlStatusHost = {
"[class.ng-untouched]": "isUntouched",
"[class.ng-touched]": "isTouched",
"[class.ng-pristine]": "isPristine",
"[class.ng-dirty]": "isDirty",
"[class.ng-valid]": "isValid",
"[class.ng-invalid]": "isInvalid",
"[class.ng-pending]": "isPending"
};
var ngGroupStatusHost = __spreadProps(__spreadValues({}, ngControlStatusHost), {
"[class.ng-submitted]": "isSubmitted"
});
var _NgControlStatus = class _NgControlStatus extends AbstractControlStatus {
constructor(cd) {
super(cd);
}
};
_NgControlStatus.\u0275fac = function NgControlStatus_Factory(t) {
return new (t || _NgControlStatus)(\u0275\u0275directiveInject(NgControl, 2));
};
_NgControlStatus.\u0275dir = /* @__PURE__ */ \u0275\u0275defineDirective({
type: _NgControlStatus,
selectors: [["", "formControlName", ""], ["", "ngModel", ""], ["", "formControl", ""]],
hostVars: 14,
hostBindings: function NgControlStatus_HostBindings(rf, ctx) {
if (rf & 2) {
\u0275\u0275classProp("ng-untouched", ctx.isUntouched)("ng-touched", ctx.isTouched)("ng-pristine", ctx.isPristine)("ng-dirty", ctx.isDirty)("ng-valid", ctx.isValid)("ng-invalid", ctx.isInvalid)("ng-pending", ctx.isPending);
}
},
features: [\u0275\u0275InheritDefinitionFeature]
});
var NgControlStatus = _NgControlStatus;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(NgControlStatus, [{
type: Directive,
args: [{
selector: "[formControlName],[ngModel],[formControl]",
host: ngControlStatusHost
}]
}], () => [{
type: NgControl,
decorators: [{
type: Self
}]
}], null);
})();
var _NgControlStatusGroup = class _NgControlStatusGroup extends AbstractControlStatus {
constructor(cd) {
super(cd);
}
};
_NgControlStatusGroup.\u0275fac = function NgControlStatusGroup_Factory(t) {
return new (t || _NgControlStatusGroup)(\u0275\u0275directiveInject(ControlContainer, 10));
};
_NgControlStatusGroup.\u0275dir = /* @__PURE__ */ \u0275\u0275defineDirective({
type: _NgControlStatusGroup,
selectors: [["", "formGroupName", ""], ["", "formArrayName", ""], ["", "ngModelGroup", ""], ["", "formGroup", ""], ["form", 3, "ngNoForm", ""], ["", "ngForm", ""]],
hostVars: 16,
hostBindings: function NgControlStatusGroup_HostBindings(rf, ctx) {
if (rf & 2) {
\u0275\u0275classProp("ng-untouched", ctx.isUntouched)("ng-touched", ctx.isTouched)("ng-pristine", ctx.isPristine)("ng-dirty", ctx.isDirty)("ng-valid", ctx.isValid)("ng-invalid", ctx.isInvalid)("ng-pending", ctx.isPending)("ng-submitted", ctx.isSubmitted);
}
},
features: [\u0275\u0275InheritDefinitionFeature]
});
var NgControlStatusGroup = _NgControlStatusGroup;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(NgControlStatusGroup, [{
type: Directive,
args: [{
selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]",
host: ngGroupStatusHost
}]
}], () => [{
type: ControlContainer,
decorators: [{
type: Optional
}, {
type: Self
}]
}], null);
})();
var formControlNameExample = `
<div [formGroup]="myGroup">
<input formControlName="firstName">
</div>
In your class:
this.myGroup = new FormGroup({
firstName: new FormControl()
});`;
var formGroupNameExample = `
<div [formGroup]="myGroup">
<div formGroupName="person">
<input formControlName="firstName">
</div>
</div>
In your class:
this.myGroup = new FormGroup({
person: new FormGroup({ firstName: new FormControl() })
});`;
var formArrayNameExample = `
<div [formGroup]="myGroup">
<div formArrayName="cities">
<div *ngFor="let city of cityArray.controls; index as i">
<input [formControlName]="i">
</div>
</div>
</div>
In your class:
this.cityArray = new FormArray([new FormControl('SF')]);
this.myGroup = new FormGroup({
cities: this.cityArray
});`;
var ngModelGroupExample = `
<form>
<div ngModelGroup="person">
<input [(ngModel)]="person.name" name="firstName">
</div>
</form>`;
var ngModelWithFormGroupExample = `
<div [formGroup]="myGroup">
<input formControlName="firstName">
<input [(ngModel)]="showMoreControls" [ngModelOptions]="{standalone: true}">
</div>
`;
function controlParentException() {
return new RuntimeError(1050, `formControlName must be used with a parent formGroup directive. You'll want to add a formGroup
directive and pass it an existing FormGroup instance (you can create one in your class).
Example:
${formControlNameExample}`);
}
function ngModelGroupException() {
return new RuntimeError(1051, `formControlName cannot be used with an ngModelGroup parent. It is only compatible with parents
that also have a "form" prefix: formGroupName, formArrayName, or formGroup.
Option 1: Update the parent to be formGroupName (reactive form strategy)
${formGroupNameExample}
Option 2: Use ngModel instead of formControlName (template-driven strategy)
${ngModelGroupExample}`);
}
function missingFormException() {
return new RuntimeError(1052, `formGroup expects a FormGroup instance. Please pass one in.
Example:
${formControlNameExample}`);
}
function groupParentException() {
return new RuntimeError(1053, `formGroupName must be used with a parent formGroup directive. You'll want to add a formGroup
directive and pass it an existing FormGroup instance (you can create one in your class).
Example:
${formGroupNameExample}`);
}
function arrayParentException() {
return new RuntimeError(1054, `formArrayName must be used with a parent formGroup directive. You'll want to add a formGroup
directive and pass it an existing FormGroup instance (you can create one in your class).
Example:
${formArrayNameExample}`);
}
var disabledAttrWarning = `
It looks like you're using the disabled attribute with a reactive form directive. If you set disabled to true
when you set up this control in your component class, the disabled attribute will actually be set in the DOM for
you. We recommend using this approach to avoid 'changed after checked' errors.
Example:
// Specify the \`disabled\` property at control creation time:
form = new FormGroup({
first: new FormControl({value: 'Nancy', disabled: true}, Validators.required),
last: new FormControl('Drew', Validators.required)
});
// Controls can also be enabled/disabled after creation:
form.get('first')?.enable();
form.get('last')?.disable();
`;
var asyncValidatorsDroppedWithOptsWarning = `
It looks like you're constructing using a FormControl with both an options argument and an
async validators argument. Mixing these arguments will cause your async validators to be dropped.
You should either put all your validators in the options object, or in separate validators
arguments. For example:
// Using validators arguments
fc = new FormControl(42, Validators.required, myAsyncValidator);
// Using AbstractControlOptions
fc = new FormControl(42, {validators: Validators.required, asyncValidators: myAV});
// Do NOT mix them: async validators will be dropped!
fc = new FormControl(42, {validators: Validators.required}, /* Oops! */ myAsyncValidator);
`;
function ngModelWarning(directiveName) {
return `
It looks like you're using ngModel on the same form field as ${directiveName}.
Support for using the ngModel input property and ngModelChange event with
reactive form directives has been deprecated in Angular v6 and will be removed
in a future version of Angular.
For more information on this, see our API docs here:
https://angular.io/api/forms/${directiveName === "formControl" ? "FormControlDirective" : "FormControlName"}#use-with-ngmodel
`;
}
function describeKey(isFormGroup, key2) {
return isFormGroup ? `with name: '${key2}'` : `at index: ${key2}`;
}
function noControlsError(isFormGroup) {
return `
There are no form controls registered with this ${isFormGroup ? "group" : "array"} yet. If you're using ngModel,
you may want to check next tick (e.g. use setTimeout).
`;
}
function missingControlError(isFormGroup, key2) {
return `Cannot find form control ${describeKey(isFormGroup, key2)}`;
}
function missingControlValueError(isFormGroup, key2) {
return `Must supply a value for form control ${describeKey(isFormGroup, key2)}`;
}
var VALID = "VALID";
var INVALID = "INVALID";
var PENDING = "PENDING";
var DISABLED = "DISABLED";
function pickValidators(validatorOrOpts) {
return (isOptionsObj(validatorOrOpts) ? validatorOrOpts.validators : validatorOrOpts) || null;
}
function coerceToValidator(validator) {
return Array.isArray(validator) ? composeValidators(validator) : validator || null;
}
function pickAsyncValidators(asyncValidator, validatorOrOpts) {
if (typeof ngDevMode === "undefined" || ngDevMode) {
if (isOptionsObj(validatorOrOpts) && asyncValidator) {
console.warn(asyncValidatorsDroppedWithOptsWarning);
}
}
return (isOptionsObj(validatorOrOpts) ? validatorOrOpts.asyncValidators : asyncValidator) || null;
}
function coerceToAsyncValidator(asyncValidator) {
return Array.isArray(asyncValidator) ? composeAsyncValidators(asyncValidator) : asyncValidator || null;
}
function isOptionsObj(validatorOrOpts) {
return validatorOrOpts != null && !Array.isArray(validatorOrOpts) && typeof validatorOrOpts === "object";
}
function assertControlPresent(parent2, isGroup, key2) {
const controls = parent2.controls;
const collection = isGroup ? Object.keys(controls) : controls;
if (!collection.length) {
throw new RuntimeError(1e3, typeof ngDevMode === "undefined" || ngDevMode ? noControlsError(isGroup) : "");
}
if (!controls[key2]) {
throw new RuntimeError(1001, typeof ngDevMode === "undefined" || ngDevMode ? missingControlError(isGroup, key2) : "");
}
}
function assertAllValuesPresent(control, isGroup, value2) {
control._forEachChild((_, key2) => {
if (value2[key2] === void 0) {
throw new RuntimeError(1002, typeof ngDevMode === "undefined" || ngDevMode ? missingControlValueError(isGroup, key2) : "");
}
});
}
var AbstractControl = class {
/**
* Initialize the AbstractControl instance.
*
* @param validators The function or array of functions that is used to determine the validity of
* this control synchronously.
* @param asyncValidators The function or array of functions that is used to determine validity of
* this control asynchronously.
*/
constructor(validators, asyncValidators) {
this._pendingDirty = false;
this._hasOwnPendingAsyncValidator = false;
this._pendingTouched = false;
this._onCollectionChange = () => {
};
this._parent = null;
this.pristine = true;
this.touched = false;
this._onDisabledChange = [];
this._assignValidators(validators);
this._assignAsyncValidators(asyncValidators);
}
/**
* Returns the function that is used to determine the validity of this control synchronously.
* If multiple validators have been added, this will be a single composed function.
* See `Validators.compose()` for additional information.
*/
get validator() {
return this._composedValidatorFn;
}
set validator(validatorFn) {
this._rawValidators = this._composedValidatorFn = validatorFn;
}
/**
* Returns the function that is used to determine the validity of this control asynchronously.
* If multiple validators have been added, this will be a single composed function.
* See `Validators.compose()` for additional information.
*/
get asyncValidator() {
return this._composedAsyncValidatorFn;
}
set asyncValidator(asyncValidatorFn) {
this._rawAsyncValidators = this._composedAsyncValidatorFn = asyncValidatorFn;
}
/**
* The parent control.
*/
get parent() {
return this._parent;
}
/**
* A control is `valid` when its `status` is `VALID`.
*
* @see {@link AbstractControl.status}
*
* @returns True if the control has passed all of its validation tests,
* false otherwise.
*/
get valid() {
return this.status === VALID;
}
/**
* A control is `invalid` when its `status` is `INVALID`.
*
* @see {@link AbstractControl.status}
*
* @returns True if this control has failed one or more of its validation checks,
* false otherwise.
*/
get invalid() {
return this.status === INVALID;
}
/**
* A control is `pending` when its `status` is `PENDING`.
*
* @see {@link AbstractControl.status}
*
* @returns True if this control is in the process of conducting a validation check,
* false otherwise.
*/
get pending() {
return this.status == PENDING;
}
/**
* A control is `disabled` when its `status` is `DISABLED`.
*
* Disabled controls are exempt from validation checks and
* are not included in the aggregate value of their ancestor
* controls.
*
* @see {@link AbstractControl.status}
*
* @returns True if the control is disabled, false otherwise.
*/
get disabled() {
return this.status === DISABLED;
}
/**
* A control is `enabled` as long as its `status` is not `DISABLED`.
*
* @returns True if the control has any status other than 'DISABLED',
* false if the status is 'DISABLED'.
*
* @see {@link AbstractControl.status}
*
*/
get enabled() {
return this.status !== DISABLED;
}
/**
* A control is `dirty` if the user has changed the value
* in the UI.
*
* @returns True if the user has changed the value of this control in the UI; compare `pristine`.
* Programmatic changes to a control's value do not mark it dirty.
*/
get dirty() {
return !this.pristine;
}
/**
* True if the control has not been marked as touched
*
* A control is `untouched` if the user has not yet triggered
* a `blur` event on it.
*/
get untouched() {
return !this.touched;
}
/**
* Reports the update strategy of the `AbstractControl` (meaning
* the event on which the control updates itself).
* Possible values: `'change'` | `'blur'` | `'submit'`
* Default value: `'change'`
*/
get updateOn() {
return this._updateOn ? this._updateOn : this.parent ? this.parent.updateOn : "change";
}
/**
* Sets the synchronous validators that are active on this control. Calling
* this overwrites any existing synchronous validators.
*
* When you add or remove a validator at run time, you must call
* `updateValueAndValidity()` for the new validation to take effect.
*
* If you want to add a new validator without affecting existing ones, consider
* using `addValidators()` method instead.
*/
setValidators(validators) {
this._assignValidators(validators);
}
/**
* Sets the asynchronous validators that are active on this control. Calling this
* overwrites any existing asynchronous validators.
*
* When you add or remove a validator at run time, you must call
* `updateValueAndValidity()` for the new validation to take effect.
*
* If you want to add a new validator without affecting existing ones, consider
* using `addAsyncValidators()` method instead.
*/
setAsyncValidators(validators) {
this._assignAsyncValidators(validators);
}
/**
* Add a synchronous validator or validators to this control, without affecting other validators.
*
* When you add or remove a validator at run time, you must call
* `updateValueAndValidity()` for the new validation to take effect.
*
* Adding a validator that already exists will have no effect. If duplicate validator functions
* are present in the `validators` array, only the first instance would be added to a form
* control.
*
* @param validators The new validator function or functions to add to this control.
*/
addValidators(validators) {
this.setValidators(addValidators(validators, this._rawValidators));
}
/**
* Add an asynchronous validator or validators to this control, without affecting other
* validators.
*
* When you add or remove a validator at run time, you must call
* `updateValueAndValidity()` for the new validation to take effect.
*
* Adding a validator that already exists will have no effect.
*
* @param validators The new asynchronous validator function or functions to add to this control.
*/
addAsyncValidators(validators) {
this.setAsyncValidators(addValidators(validators, this._rawAsyncValidators));
}
/**
* Remove a synchronous validator from this control, without affecting other validators.
* Validators are compared by function reference; you must pass a reference to the exact same
* validator function as the one that was originally set. If a provided validator is not found,
* it is ignored.
*
* @usageNotes
*
* ### Reference to a ValidatorFn
*
* ```
* // Reference to the RequiredValidator
* const ctrl = new FormControl<string | null>('', Validators.required);
* ctrl.removeValidators(Validators.required);
*
* // Reference to anonymous function inside MinValidator
* const minValidator = Validators.min(3);
* const ctrl = new FormControl<string | null>('', minValidator);
* expect(ctrl.hasValidator(minValidator)).toEqual(true)
* expect(ctrl.hasValidator(Validators.min(3))).toEqual(false)
*
* ctrl.removeValidators(minValidator);
* ```
*
* When you add or remove a validator at run time, you must call
* `updateValueAndValidity()` for the new validation to take effect.
*
* @param validators The validator or validators to remove.
*/
removeValidators(validators) {
this.setValidators(removeValidators(validators, this._rawValidators));
}
/**
* Remove an asynchronous validator from this control, without affecting other validators.
* Validators are compared by function reference; you must pass a reference to the exact same
* validator function as the one that was originally set. If a provided validator is not found, it
* is ignored.
*
* When you add or remove a validator at run time, you must call
* `updateValueAndValidity()` for the new validation to take effect.
*
* @param validators The asynchronous validator or validators to remove.
*/
removeAsyncValidators(validators) {
this.setAsyncValidators(removeValidators(validators, this._rawAsyncValidators));
}
/**
* Check whether a synchronous validator function is present on this control. The provided
* validator must be a reference to the exact same function that was provided.
*
* @usageNotes
*
* ### Reference to a ValidatorFn
*
* ```
* // Reference to the RequiredValidator
* const ctrl = new FormControl<number | null>(0, Validators.required);
* expect(ctrl.hasValidator(Validators.required)).toEqual(true)
*
* // Reference to anonymous function inside MinValidator
* const minValidator = Validators.min(3);
* const ctrl = new FormControl<number | null>(0, minValidator);
* expect(ctrl.hasValidator(minValidator)).toEqual(true)
* expect(ctrl.hasValidator(Validators.min(3))).toEqual(false)
* ```
*
* @param validator The validator to check for presence. Compared by function reference.
* @returns Whether the provided validator was found on this control.
*/
hasValidator(validator) {
return hasValidator(this._rawValidators, validator);
}
/**
* Check whether an asynchronous validator function is present on this control. The provided
* validator must be a reference to the exact same function that was provided.
*
* @param validator The asynchronous validator to check for presence. Compared by function
* reference.
* @returns Whether the provided asynchronous validator was found on this control.
*/
hasAsyncValidator(validator) {
return hasValidator(this._rawAsyncValidators, validator);
}
/**
* Empties out the synchronous validator list.
*
* When you add or remove a validator at run time, you must call
* `updateValueAndValidity()` for the new validation to take effect.
*
*/
clearValidators() {
this.validator = null;
}
/**
* Empties out the async validator list.
*
* When you add or remove a validator at run time, you must call
* `updateValueAndValidity()` for the new validation to take effect.
*
*/
clearAsyncValidators() {
this.asyncValidator = null;
}
/**
* Marks the control as `touched`. A control is touched by focus and
* blur events that do not change the value.
*
* @see {@link markAsUntouched()}
* @see {@link markAsDirty()}
* @see {@link markAsPristine()}
*
* @param opts Configuration options that determine how the control propagates changes
* and emits events after marking is applied.
* * `onlySelf`: When true, mark only this control. When false or not supplied,
* marks all direct ancestors. Default is false.
*/
markAsTouched(opts = {}) {
this.touched = true;
if (this._parent && !opts.onlySelf) {
this._parent.markAsTouched(opts);
}
}
/**
* Marks the control and all its descendant controls as `touched`.
* @see {@link markAsTouched()}
*/
markAllAsTouched() {
this.markAsTouched({
onlySelf: true
});
this._forEachChild((control) => control.markAllAsTouched());
}
/**
* Marks the control as `untouched`.
*
* If the control has any children, also marks all children as `untouched`
* and recalculates the `touched` status of all parent controls.
*
* @see {@link markAsTouched()}
* @see {@link markAsDirty()}
* @see {@link markAsPristine()}
*
* @param opts Configuration options that determine how the control propagates changes
* and emits events after the marking is applied.
* * `onlySelf`: When true, mark only this control. When false or not supplied,
* marks all direct ancestors. Default is false.
*/
markAsUntouched(opts = {}) {
this.touched = false;
this._pendingTouched = false;
this._forEachChild((control) => {
control.markAsUntouched({
onlySelf: true
});
});
if (this._parent && !opts.onlySelf) {
this._parent._updateTouched(opts);
}
}
/**
* Marks the control as `dirty`. A control becomes dirty when
* the control's value is changed through the UI; compare `markAsTouched`.
*
* @see {@link markAsTouched()}
* @see {@link markAsUntouched()}
* @see {@link markAsPristine()}
*
* @param opts Configuration options that determine how the control propagates changes
* and emits events after marking is applied.
* * `onlySelf`: When true, mark only this control. When false or not supplied,
* marks all direct ancestors. Default is false.
*/
markAsDirty(opts = {}) {
this.pristine = false;
if (this._parent && !opts.onlySelf) {
this._parent.markAsDirty(opts);
}
}
/**
* Marks the control as `pristine`.
*
* If the control has any children, marks all children as `pristine`,
* and recalculates the `pristine` status of all parent
* controls.
*
* @see {@link markAsTouched()}
* @see {@link markAsUntouched()}
* @see {@link markAsDirty()}
*
* @param opts Configuration options that determine how the control emits events after
* marking is applied.
* * `onlySelf`: When true, mark only this control. When false or not supplied,
* marks all direct ancestors. Default is false.
*/
markAsPristine(opts = {}) {
this.pristine = true;
this._pendingDirty = false;
this._forEachChild((control) => {
control.markAsPristine({
onlySelf: true
});
});
if (this._parent && !opts.onlySelf) {
this._parent._updatePristine(opts);
}
}
/**
* Marks the control as `pending`.
*
* A control is pending while the control performs async validation.
*
* @see {@link AbstractControl.status}
*
* @param opts Configuration options that determine how the control propagates changes and
* emits events after marking is applied.
* * `onlySelf`: When true, mark only this control. When false or not supplied,
* marks all direct ancestors. Default is false.
* * `emitEvent`: When true or not supplied (the default), the `statusChanges`
* observable emits an event with the latest status the control is marked pending.
* When false, no events are emitted.
*
*/
markAsPending(opts = {}) {
this.status = PENDING;
if (opts.emitEvent !== false) {
this.statusChanges.emit(this.status);
}
if (this._parent && !opts.onlySelf) {
this._parent.markAsPending(opts);
}
}
/**
* Disables the control. This means the control is exempt from validation checks and
* excluded from the aggregate value of any parent. Its status is `DISABLED`.
*
* If the control has children, all children are also disabled.
*
* @see {@link AbstractControl.status}
*
* @param opts Configuration options that determine how the control propagates
* changes and emits events after the control is disabled.
* * `onlySelf`: When true, mark only this control. When false or not supplied,
* marks all direct ancestors. Default is false.
* * `emitEvent`: When true or not supplied (the default), both the `statusChanges` and
* `valueChanges`
* observables emit events with the latest status and value when the control is disabled.
* When false, no events are emitted.
*/
disable(opts = {}) {
const skipPristineCheck = this._parentMarkedDirty(opts.onlySelf);
this.status = DISABLED;
this.errors = null;
this._forEachChild((control) => {
control.disable(__spreadProps(__spreadValues({}, opts), {
onlySelf: true
}));
});
this._updateValue();
if (opts.emitEvent !== false) {
this.valueChanges.emit(this.value);
this.statusChanges.emit(this.status);
}
this._updateAncestors(__spreadProps(__spreadValues({}, opts), {
skipPristineCheck
}));
this._onDisabledChange.forEach((changeFn) => changeFn(true));
}
/**
* Enables the control. This means the control is included in validation checks and
* the aggregate value of its parent. Its status recalculates based on its value and
* its validators.
*
* By default, if the control has children, all children are enabled.
*
* @see {@link AbstractControl.status}
*
* @param opts Configure options that control how the control propagates changes and
* emits events when marked as untouched
* * `onlySelf`: When true, mark only this control. When false or not supplied,
* marks all direct ancestors. Default is false.
* * `emitEvent`: When true or not supplied (the default), both the `statusChanges` and
* `valueChanges`
* observables emit events with the latest status and value when the control is enabled.
* When false, no events are emitted.
*/
enable(opts = {}) {
const skipPristineCheck = this._parentMarkedDirty(opts.onlySelf);
this.status = VALID;
this._forEachChild((control) => {
control.enable(__spreadProps(__spreadValues({}, opts), {
onlySelf: true
}));
});
this.updateValueAndValidity({
onlySelf: true,
emitEvent: opts.emitEvent
});
this._updateAncestors(__spreadProps(__spreadValues({}, opts), {
skipPristineCheck
}));
this._onDisabledChange.forEach((changeFn) => changeFn(false));
}
_updateAncestors(opts) {
if (this._parent && !opts.onlySelf) {
this._parent.updateValueAndValidity(opts);
if (!opts.skipPristineCheck) {
this._parent._updatePristine();
}
this._parent._updateTouched();
}
}
/**
* Sets the parent of the control
*
* @param parent The new parent.
*/
setParent(parent2) {
this._parent = parent2;
}
/**
* The raw value of this control. For most control implementations, the raw value will include
* disabled children.
*/
getRawValue() {
return this.value;
}
/**
* Recalculates the value and validation status of the control.
*
* By default, it also updates the value and validity of its ancestors.
*
* @param opts Configuration options determine how the control propagates changes and emits events
* after updates and validity checks are applied.
* * `onlySelf`: When true, only update this control. When false or not supplied,
* update all direct ancestors. Default is false.
* * `emitEvent`: When true or not supplied (the default), both the `statusChanges` and
* `valueChanges`
* observables emit events with the latest status and value when the control is updated.
* When false, no events are emitted.
*/
updateValueAndValidity(opts = {}) {
this._setInitialStatus();
this._updateValue();
if (this.enabled) {
this._cancelExistingSubscription();
this.errors = this._runValidator();
this.status = this._calculateStatus();
if (this.status === VALID || this.status === PENDING) {
this._runAsyncValidator(opts.emitEvent);
}
}
if (opts.emitEvent !== false) {
this.valueChanges.emit(this.value);
this.statusChanges.emit(this.status);
}
if (this._parent && !opts.onlySelf) {
this._parent.updateValueAndValidity(opts);
}
}
/** @internal */
_updateTreeValidity(opts = {
emitEvent: true
}) {
this._forEachChild((ctrl) => ctrl._updateTreeValidity(opts));
this.updateValueAndValidity({
onlySelf: true,
emitEvent: opts.emitEvent
});
}
_setInitialStatus() {
this.status = this._allControlsDisabled() ? DISABLED : VALID;
}
_runValidator() {
return this.validator ? this.validator(this) : null;
}
_runAsyncValidator(emitEvent) {
if (this.asyncValidator) {
this.status = PENDING;
this._hasOwnPendingAsyncValidator = true;
const obs = toObservable(this.asyncValidator(this));
this._asyncValidationSubscription = obs.subscribe((errors) => {
this._hasOwnPendingAsyncValidator = false;
this.setErrors(errors, {
emitEvent
});
});
}
}
_cancelExistingSubscription() {
if (this._asyncValidationSubscription) {
this._asyncValidationSubscription.unsubscribe();
this._hasOwnPendingAsyncValidator = false;
}
}
/**
* Sets errors on a form control when running validations manually, rather than automatically.
*
* Calling `setErrors` also updates the validity of the parent control.
*
* @param opts Configuration options that determine how the control propagates
* changes and emits events after the control errors are set.
* * `emitEvent`: When true or not supplied (the default), the `statusChanges`
* observable emits an event after the errors are set.
*
* @usageNotes
*
* ### Manually set the errors for a control
*
* ```
* const login = new FormControl('someLogin');
* login.setErrors({
* notUnique: true
* });
*
* expect(login.valid).toEqual(false);
* expect(login.errors).toEqual({ notUnique: true });
*
* login.setValue('someOtherLogin');
*
* expect(login.valid).toEqual(true);
* ```
*/
setErrors(errors, opts = {}) {
this.errors = errors;
this._updateControlsErrors(opts.emitEvent !== false);
}
/**
* Retrieves a child control given the control's name or path.
*
* @param path A dot-delimited string or array of string/number values that define the path to the
* control. If a string is provided, passing it as a string literal will result in improved type
* information. Likewise, if an array is provided, passing it `as const` will cause improved type
* information to be available.
*
* @usageNotes
* ### Retrieve a nested control
*
* For example, to get a `name` control nested within a `person` sub-group:
*
* * `this.form.get('person.name');`
*
* -OR-
*
* * `this.form.get(['person', 'name'] as const);` // `as const` gives improved typings
*
* ### Retrieve a control in a FormArray
*
* When accessing an element inside a FormArray, you can use an element index.
* For example, to get a `price` control from the first element in an `items` array you can use:
*
* * `this.form.get('items.0.price');`
*
* -OR-
*
* * `this.form.get(['items', 0, 'price']);`
*/
get(path) {
let currPath = path;
if (currPath == null)
return null;
if (!Array.isArray(currPath))
currPath = currPath.split(".");
if (currPath.length === 0)
return null;
return currPath.reduce((control, name2) => control && control._find(name2), this);
}
/**
* @description
* Reports error data for the control with the given path.
*
* @param errorCode The code of the error to check
* @param path A list of control names that designates how to move from the current control
* to the control that should be queried for errors.
*
* @usageNotes
* For example, for the following `FormGroup`:
*
* ```
* form = new FormGroup({
* address: new FormGroup({ street: new FormControl() })
* });
* ```
*
* The path to the 'street' control from the root form would be 'address' -> 'street'.
*
* It can be provided to this method in one of two formats:
*
* 1. An array of string control names, e.g. `['address', 'street']`
* 1. A period-delimited list of control names in one string, e.g. `'address.street'`
*
* @returns error data for that particular error. If the control or error is not present,
* null is returned.
*/
getError(errorCode, path) {
const control = path ? this.get(path) : this;
return control && control.errors ? control.errors[errorCode] : null;
}
/**
* @description
* Reports whether the control with the given path has the error specified.
*
* @param errorCode The code of the error to check
* @param path A list of control names that designates how to move from the current control
* to the control that should be queried for errors.
*
* @usageNotes
* For example, for the following `FormGroup`:
*
* ```
* form = new FormGroup({
* address: new FormGroup({ street: new FormControl() })
* });
* ```
*
* The path to the 'street' control from the root form would be 'address' -> 'street'.
*
* It can be provided to this method in one of two formats:
*
* 1. An array of string control names, e.g. `['address', 'street']`
* 1. A period-delimited list of control names in one string, e.g. `'address.street'`
*
* If no path is given, this method checks for the error on the current control.
*
* @returns whether the given error is present in the control at the given path.
*
* If the control is not present, false is returned.
*/
hasError(errorCode, path) {
return !!this.getError(errorCode, path);
}
/**
* Retrieves the top-level ancestor of this control.
*/
get root() {
let x = this;
while (x._parent) {
x = x._parent;
}
return x;
}
/** @internal */
_updateControlsErrors(emitEvent) {
this.status = this._calculateStatus();
if (emitEvent) {
this.statusChanges.emit(this.status);
}
if (this._parent) {
this._parent._updateControlsErrors(emitEvent);
}
}
/** @internal */
_initObservables() {
this.valueChanges = new EventEmitter();
this.statusChanges = new EventEmitter();
}
_calculateStatus() {
if (this._allControlsDisabled())
return DISABLED;
if (this.errors)
return INVALID;
if (this._hasOwnPendingAsyncValidator || this._anyControlsHaveStatus(PENDING))
return PENDING;
if (this._anyControlsHaveStatus(INVALID))
return INVALID;
return VALID;
}
/** @internal */
_anyControlsHaveStatus(status) {
return this._anyControls((control) => control.status === status);
}
/** @internal */
_anyControlsDirty() {
return this._anyControls((control) => control.dirty);
}
/** @internal */
_anyControlsTouched() {
return this._anyControls((control) => control.touched);
}
/** @internal */
_updatePristine(opts = {}) {
this.pristine = !this._anyControlsDirty();
if (this._parent && !opts.onlySelf) {
this._parent._updatePristine(opts);
}
}
/** @internal */
_updateTouched(opts = {}) {
this.touched = this._anyControlsTouched();
if (this._parent && !opts.onlySelf) {
this._parent._updateTouched(opts);
}
}
/** @internal */
_registerOnCollectionChange(fn) {
this._onCollectionChange = fn;
}
/** @internal */
_setUpdateStrategy(opts) {
if (isOptionsObj(opts) && opts.updateOn != null) {
this._updateOn = opts.updateOn;
}
}
/**
* Check to see if parent has been marked artificially dirty.
*
* @internal
*/
_parentMarkedDirty(onlySelf) {
const parentDirty = this._parent && this._parent.dirty;
return !onlySelf && !!parentDirty && !this._parent._anyControlsDirty();
}
/** @internal */
_find(name2) {
return null;
}
/**
* Internal implementation of the `setValidators` method. Needs to be separated out into a
* different method, because it is called in the constructor and it can break cases where
* a control is extended.
*/
_assignValidators(validators) {
this._rawValidators = Array.isArray(validators) ? validators.slice() : validators;
this._composedValidatorFn = coerceToValidator(this._rawValidators);
}
/**
* Internal implementation of the `setAsyncValidators` method. Needs to be separated out into a
* different method, because it is called in the constructor and it can break cases where
* a control is extended.
*/
_assignAsyncValidators(validators) {
this._rawAsyncValidators = Array.isArray(validators) ? validators.slice() : validators;
this._composedAsyncValidatorFn = coerceToAsyncValidator(this._rawAsyncValidators);
}
};
var FormGroup = class extends AbstractControl {
/**
* Creates a new `FormGroup` instance.
*
* @param controls A collection of child controls. The key for each child is the name
* under which it is registered.
*
* @param validatorOrOpts A synchronous validator function, or an array of
* such functions, or an `AbstractControlOptions` object that contains validation functions
* and a validation trigger.
*
* @param asyncValidator A single async validator or array of async validator functions
*
*/
constructor(controls, validatorOrOpts, asyncValidator) {
super(pickValidators(validatorOrOpts), pickAsyncValidators(asyncValidator, validatorOrOpts));
(typeof ngDevMode === "undefined" || ngDevMode) && validateFormGroupControls(controls);
this.controls = controls;
this._initObservables();
this._setUpdateStrategy(validatorOrOpts);
this._setUpControls();
this.updateValueAndValidity({
onlySelf: true,
// If `asyncValidator` is present, it will trigger control status change from `PENDING` to
// `VALID` or `INVALID`. The status should be broadcasted via the `statusChanges` observable,
// so we set `emitEvent` to `true` to allow that during the control creation process.
emitEvent: !!this.asyncValidator
});
}
registerControl(name2, control) {
if (this.controls[name2])
return this.controls[name2];
this.controls[name2] = control;
control.setParent(this);
control._registerOnCollectionChange(this._onCollectionChange);
return control;
}
addControl(name2, control, options = {}) {
this.registerControl(name2, control);
this.updateValueAndValidity({
emitEvent: options.emitEvent
});
this._onCollectionChange();
}
/**
* Remove a control from this group. In a strongly-typed group, required controls cannot be
* removed.
*
* This method also updates the value and validity of the control.
*
* @param name The control name to remove from the collection
* @param options Specifies whether this FormGroup instance should emit events after a
* control is removed.
* * `emitEvent`: When true or not supplied (the default), both the `statusChanges` and
* `valueChanges` observables emit events with the latest status and value when the control is
* removed. When false, no events are emitted.
*/
removeControl(name2, options = {}) {
if (this.controls[name2])
this.controls[name2]._registerOnCollectionChange(() => {
});
delete this.controls[name2];
this.updateValueAndValidity({
emitEvent: options.emitEvent
});
this._onCollectionChange();
}
setControl(name2, control, options = {}) {
if (this.controls[name2])
this.controls[name2]._registerOnCollectionChange(() => {
});
delete this.controls[name2];
if (control)
this.registerControl(name2, control);
this.updateValueAndValidity({
emitEvent: options.emitEvent
});
this._onCollectionChange();
}
contains(controlName) {
return this.controls.hasOwnProperty(controlName) && this.controls[controlName].enabled;
}
/**
* Sets the value of the `FormGroup`. It accepts an object that matches
* the structure of the group, with control names as keys.
*
* @usageNotes
* ### Set the complete value for the form group
*
* ```
* const form = new FormGroup({
* first: new FormControl(),
* last: new FormControl()
* });
*
* console.log(form.value); // {first: null, last: null}
*
* form.setValue({first: 'Nancy', last: 'Drew'});
* console.log(form.value); // {first: 'Nancy', last: 'Drew'}
* ```
*
* @throws When strict checks fail, such as setting the value of a control
* that doesn't exist or if you exclude a value of a control that does exist.
*
* @param value The new value for the control that matches the structure of the group.
* @param options Configuration options that determine how the control propagates changes
* and emits events after the value changes.
* The configuration options are passed to the {@link AbstractControl#updateValueAndValidity
* updateValueAndValidity} method.
*
* * `onlySelf`: When true, each change only affects this control, and not its parent. Default is
* false.
* * `emitEvent`: When true or not supplied (the default), both the `statusChanges` and
* `valueChanges`
* observables emit events with the latest status and value when the control value is updated.
* When false, no events are emitted.
*/
setValue(value2, options = {}) {
assertAllValuesPresent(this, true, value2);
Object.keys(value2).forEach((name2) => {
assertControlPresent(this, true, name2);
this.controls[name2].setValue(value2[name2], {
onlySelf: true,
emitEvent: options.emitEvent
});
});
this.updateValueAndValidity(options);
}
/**
* Patches the value of the `FormGroup`. It accepts an object with control
* names as keys, and does its best to match the values to the correct controls
* in the group.
*
* It accepts both super-sets and sub-sets of the group without throwing an error.
*
* @usageNotes
* ### Patch the value for a form group
*
* ```
* const form = new FormGroup({
* first: new FormControl(),
* last: new FormControl()
* });
* console.log(form.value); // {first: null, last: null}
*
* form.patchValue({first: 'Nancy'});
* console.log(form.value); // {first: 'Nancy', last: null}
* ```
*
* @param value The object that matches the structure of the group.
* @param options Configuration options that determine how the control propagates changes and
* emits events after the value is patched.
* * `onlySelf`: When true, each change only affects this control and not its parent. Default is
* true.
* * `emitEvent`: When true or not supplied (the default), both the `statusChanges` and
* `valueChanges` observables emit events with the latest status and value when the control value
* is updated. When false, no events are emitted. The configuration options are passed to
* the {@link AbstractControl#updateValueAndValidity updateValueAndValidity} method.
*/
patchValue(value2, options = {}) {
if (value2 == null)
return;
Object.keys(value2).forEach((name2) => {
const control = this.controls[name2];
if (control) {
control.patchValue(
/* Guaranteed to be present, due to the outer forEach. */
value2[name2],
{
onlySelf: true,
emitEvent: options.emitEvent
}
);
}
});
this.updateValueAndValidity(options);
}
/**
* Resets the `FormGroup`, marks all descendants `pristine` and `untouched` and sets
* the value of all descendants to their default values, or null if no defaults were provided.
*
* You reset to a specific form state by passing in a map of states
* that matches the structure of your form, with control names as keys. The state
* is a standalone value or a form state object with both a value and a disabled
* status.
*
* @param value Resets the control with an initial value,
* or an object that defines the initial value and disabled state.
*
* @param options Configuration options that determine how the control propagates changes
* and emits events when the group is reset.
* * `onlySelf`: When true, each change only affects this control, and not its parent. Default is
* false.
* * `emitEvent`: When true or not supplied (the default), both the `statusChanges` and
* `valueChanges`
* observables emit events with the latest status and value when the control is reset.
* When false, no events are emitted.
* The configuration options are passed to the {@link AbstractControl#updateValueAndValidity
* updateValueAndValidity} method.
*
* @usageNotes
*
* ### Reset the form group values
*
* ```ts
* const form = new FormGroup({
* first: new FormControl('first name'),
* last: new FormControl('last name')
* });
*
* console.log(form.value); // {first: 'first name', last: 'last name'}
*
* form.reset({ first: 'name', last: 'last name' });
*
* console.log(form.value); // {first: 'name', last: 'last name'}
* ```
*
* ### Reset the form group values and disabled status
*
* ```
* const form = new FormGroup({
* first: new FormControl('first name'),
* last: new FormControl('last name')
* });
*
* form.reset({
* first: {value: 'name', disabled: true},
* last: 'last'
* });
*
* console.log(form.value); // {last: 'last'}
* console.log(form.get('first').status); // 'DISABLED'
* ```
*/
reset(value2 = {}, options = {}) {
this._forEachChild((control, name2) => {
control.reset(value2 ? value2[name2] : null, {
onlySelf: true,
emitEvent: options.emitEvent
});
});
this._updatePristine(options);
this._updateTouched(options);
this.updateValueAndValidity(options);
}
/**
* The aggregate value of the `FormGroup`, including any disabled controls.
*
* Retrieves all values regardless of disabled status.
*/
getRawValue() {
return this._reduceChildren({}, (acc, control, name2) => {
acc[name2] = control.getRawValue();
return acc;
});
}
/** @internal */
_syncPendingControls() {
let subtreeUpdated = this._reduceChildren(false, (updated, child) => {
return child._syncPendingControls() ? true : updated;
});
if (subtreeUpdated)
this.updateValueAndValidity({
onlySelf: true
});
return subtreeUpdated;
}
/** @internal */
_forEachChild(cb) {
Object.keys(this.controls).forEach((key2) => {
const control = this.controls[key2];
control && cb(control, key2);
});
}
/** @internal */
_setUpControls() {
this._forEachChild((control) => {
control.setParent(this);
control._registerOnCollectionChange(this._onCollectionChange);
});
}
/** @internal */
_updateValue() {
this.value = this._reduceValue();
}
/** @internal */
_anyControls(condition) {
for (const [controlName, control] of Object.entries(this.controls)) {
if (this.contains(controlName) && condition(control)) {
return true;
}
}
return false;
}
/** @internal */
_reduceValue() {
let acc = {};
return this._reduceChildren(acc, (acc2, control, name2) => {
if (control.enabled || this.disabled) {
acc2[name2] = control.value;
}
return acc2;
});
}
/** @internal */
_reduceChildren(initValue, fn) {
let res = initValue;
this._forEachChild((control, name2) => {
res = fn(res, control, name2);
});
return res;
}
/** @internal */
_allControlsDisabled() {
for (const controlName of Object.keys(this.controls)) {
if (this.controls[controlName].enabled) {
return false;
}
}
return Object.keys(this.controls).length > 0 || this.disabled;
}
/** @internal */
_find(name2) {
return this.controls.hasOwnProperty(name2) ? this.controls[name2] : null;
}
};
function validateFormGroupControls(controls) {
const invalidKeys = Object.keys(controls).filter((key2) => key2.includes("."));
if (invalidKeys.length > 0) {
console.warn(`FormGroup keys cannot include \`.\`, please replace the keys for: ${invalidKeys.join(",")}.`);
}
}
var FormRecord = class extends FormGroup {
};
var CALL_SET_DISABLED_STATE = new InjectionToken("CallSetDisabledState", {
providedIn: "root",
factory: () => setDisabledStateDefault
});
var setDisabledStateDefault = "always";
function controlPath(name2, parent2) {
return [...parent2.path, name2];
}
function setUpControl(control, dir, callSetDisabledState = setDisabledStateDefault) {
if (typeof ngDevMode === "undefined" || ngDevMode) {
if (!control)
_throwError(dir, "Cannot find control with");
if (!dir.valueAccessor)
_throwMissingValueAccessorError(dir);
}
setUpValidators(control, dir);
dir.valueAccessor.writeValue(control.value);
if (control.disabled || callSetDisabledState === "always") {
dir.valueAccessor.setDisabledState?.(control.disabled);
}
setUpViewChangePipeline(control, dir);
setUpModelChangePipeline(control, dir);
setUpBlurPipeline(control, dir);
setUpDisabledChangeHandler(control, dir);
}
function cleanUpControl(control, dir, validateControlPresenceOnChange = true) {
const noop4 = () => {
if (validateControlPresenceOnChange && (typeof ngDevMode === "undefined" || ngDevMode)) {
_noControlError(dir);
}
};
if (dir.valueAccessor) {
dir.valueAccessor.registerOnChange(noop4);
dir.valueAccessor.registerOnTouched(noop4);
}
cleanUpValidators(control, dir);
if (control) {
dir._invokeOnDestroyCallbacks();
control._registerOnCollectionChange(() => {
});
}
}
function registerOnValidatorChange(validators, onChange) {
validators.forEach((validator) => {
if (validator.registerOnValidatorChange)
validator.registerOnValidatorChange(onChange);
});
}
function setUpDisabledChangeHandler(control, dir) {
if (dir.valueAccessor.setDisabledState) {
const onDisabledChange = (isDisabled) => {
dir.valueAccessor.setDisabledState(isDisabled);
};
control.registerOnDisabledChange(onDisabledChange);
dir._registerOnDestroy(() => {
control._unregisterOnDisabledChange(onDisabledChange);
});
}
}
function setUpValidators(control, dir) {
const validators = getControlValidators(control);
if (dir.validator !== null) {
control.setValidators(mergeValidators(validators, dir.validator));
} else if (typeof validators === "function") {
control.setValidators([validators]);
}
const asyncValidators = getControlAsyncValidators(control);
if (dir.asyncValidator !== null) {
control.setAsyncValidators(mergeValidators(asyncValidators, dir.asyncValidator));
} else if (typeof asyncValidators === "function") {
control.setAsyncValidators([asyncValidators]);
}
const onValidatorChange = () => control.updateValueAndValidity();
registerOnValidatorChange(dir._rawValidators, onValidatorChange);
registerOnValidatorChange(dir._rawAsyncValidators, onValidatorChange);
}
function cleanUpValidators(control, dir) {
let isControlUpdated = false;
if (control !== null) {
if (dir.validator !== null) {
const validators = getControlValidators(control);
if (Array.isArray(validators) && validators.length > 0) {
const updatedValidators = validators.filter((validator) => validator !== dir.validator);
if (updatedValidators.length !== validators.length) {
isControlUpdated = true;
control.setValidators(updatedValidators);
}
}
}
if (dir.asyncValidator !== null) {
const asyncValidators = getControlAsyncValidators(control);
if (Array.isArray(asyncValidators) && asyncValidators.length > 0) {
const updatedAsyncValidators = asyncValidators.filter((asyncValidator) => asyncValidator !== dir.asyncValidator);
if (updatedAsyncValidators.length !== asyncValidators.length) {
isControlUpdated = true;
control.setAsyncValidators(updatedAsyncValidators);
}
}
}
}
const noop4 = () => {
};
registerOnValidatorChange(dir._rawValidators, noop4);
registerOnValidatorChange(dir._rawAsyncValidators, noop4);
return isControlUpdated;
}
function setUpViewChangePipeline(control, dir) {
dir.valueAccessor.registerOnChange((newValue) => {
control._pendingValue = newValue;
control._pendingChange = true;
control._pendingDirty = true;
if (control.updateOn === "change")
updateControl(control, dir);
});
}
function setUpBlurPipeline(control, dir) {
dir.valueAccessor.registerOnTouched(() => {
control._pendingTouched = true;
if (control.updateOn === "blur" && control._pendingChange)
updateControl(control, dir);
if (control.updateOn !== "submit")
control.markAsTouched();
});
}
function updateControl(control, dir) {
if (control._pendingDirty)
control.markAsDirty();
control.setValue(control._pendingValue, {
emitModelToViewChange: false
});
dir.viewToModelUpdate(control._pendingValue);
control._pendingChange = false;
}
function setUpModelChangePipeline(control, dir) {
const onChange = (newValue, emitModelEvent) => {
dir.valueAccessor.writeValue(newValue);
if (emitModelEvent)
dir.viewToModelUpdate(newValue);
};
control.registerOnChange(onChange);
dir._registerOnDestroy(() => {
control._unregisterOnChange(onChange);
});
}
function setUpFormContainer(control, dir) {
if (control == null && (typeof ngDevMode === "undefined" || ngDevMode))
_throwError(dir, "Cannot find control with");
setUpValidators(control, dir);
}
function cleanUpFormContainer(control, dir) {
return cleanUpValidators(control, dir);
}
function _noControlError(dir) {
return _throwError(dir, "There is no FormControl instance attached to form control element with");
}
function _throwError(dir, message) {
const messageEnd = _describeControlLocation(dir);
throw new Error(`${message} ${messageEnd}`);
}
function _describeControlLocation(dir) {
const path = dir.path;
if (path && path.length > 1)
return `path: '${path.join(" -> ")}'`;
if (path?.[0])
return `name: '${path}'`;
return "unspecified name attribute";
}
function _throwMissingValueAccessorError(dir) {
const loc = _describeControlLocation(dir);
throw new RuntimeError(-1203, `No value accessor for form control ${loc}.`);
}
function _throwInvalidValueAccessorError(dir) {
const loc = _describeControlLocation(dir);
throw new RuntimeError(1200, `Value accessor was not provided as an array for form control with ${loc}. Check that the \`NG_VALUE_ACCESSOR\` token is configured as a \`multi: true\` provider.`);
}
function isPropertyUpdated(changes, viewModel) {
if (!changes.hasOwnProperty("model"))
return false;
const change = changes["model"];
if (change.isFirstChange())
return true;
return !Object.is(viewModel, change.currentValue);
}
function isBuiltInAccessor(valueAccessor) {
return Object.getPrototypeOf(valueAccessor.constructor) === BuiltInControlValueAccessor;
}
function syncPendingControls(form, directives) {
form._syncPendingControls();
directives.forEach((dir) => {
const control = dir.control;
if (control.updateOn === "submit" && control._pendingChange) {
dir.viewToModelUpdate(control._pendingValue);
control._pendingChange = false;
}
});
}
function selectValueAccessor(dir, valueAccessors) {
if (!valueAccessors)
return null;
if (!Array.isArray(valueAccessors) && (typeof ngDevMode === "undefined" || ngDevMode))
_throwInvalidValueAccessorError(dir);
let defaultAccessor = void 0;
let builtinAccessor = void 0;
let customAccessor = void 0;
valueAccessors.forEach((v) => {
if (v.constructor === DefaultValueAccessor) {
defaultAccessor = v;
} else if (isBuiltInAccessor(v)) {
if (builtinAccessor && (typeof ngDevMode === "undefined" || ngDevMode))
_throwError(dir, "More than one built-in value accessor matches form control with");
builtinAccessor = v;
} else {
if (customAccessor && (typeof ngDevMode === "undefined" || ngDevMode))
_throwError(dir, "More than one custom value accessor matches form control with");
customAccessor = v;
}
});
if (customAccessor)
return customAccessor;
if (builtinAccessor)
return builtinAccessor;
if (defaultAccessor)
return defaultAccessor;
if (typeof ngDevMode === "undefined" || ngDevMode) {
_throwError(dir, "No valid value accessor for form control with");
}
return null;
}
function removeListItem$1(list, el) {
const index2 = list.indexOf(el);
if (index2 > -1)
list.splice(index2, 1);
}
function _ngModelWarning(name2, type, instance, warningConfig) {
if (warningConfig === "never")
return;
if ((warningConfig === null || warningConfig === "once") && !type._ngModelWarningSentOnce || warningConfig === "always" && !instance._ngModelWarningSent) {
console.warn(ngModelWarning(name2));
type._ngModelWarningSentOnce = true;
instance._ngModelWarningSent = true;
}
}
var formDirectiveProvider$1 = {
provide: ControlContainer,
useExisting: forwardRef(() => NgForm)
};
var resolvedPromise$1 = (() => Promise.resolve())();
var _NgForm = class _NgForm extends ControlContainer {
constructor(validators, asyncValidators, callSetDisabledState) {
super();
this.callSetDisabledState = callSetDisabledState;
this.submitted = false;
this._directives = /* @__PURE__ */ new Set();
this.ngSubmit = new EventEmitter();
this.form = new FormGroup({}, composeValidators(validators), composeAsyncValidators(asyncValidators));
}
/** @nodoc */
ngAfterViewInit() {
this._setUpdateStrategy();
}
/**
* @description
* The directive instance.
*/
get formDirective() {
return this;
}
/**
* @description
* The internal `FormGroup` instance.
*/
get control() {
return this.form;
}
/**
* @description
* Returns an array representing the path to this group. Because this directive
* always lives at the top level of a form, it is always an empty array.
*/
get path() {
return [];
}
/**
* @description
* Returns a map of the controls in this group.
*/
get controls() {
return this.form.controls;
}
/**
* @description
* Method that sets up the control directive in this group, re-calculates its value
* and validity, and adds the instance to the internal list of directives.
*
* @param dir The `NgModel` directive instance.
*/
addControl(dir) {
resolvedPromise$1.then(() => {
const container = this._findContainer(dir.path);
dir.control = container.registerControl(dir.name, dir.control);
setUpControl(dir.control, dir, this.callSetDisabledState);
dir.control.updateValueAndValidity({
emitEvent: false
});
this._directives.add(dir);
});
}
/**
* @description
* Retrieves the `FormControl` instance from the provided `NgModel` directive.
*
* @param dir The `NgModel` directive instance.
*/
getControl(dir) {
return this.form.get(dir.path);
}
/**
* @description
* Removes the `NgModel` instance from the internal list of directives
*
* @param dir The `NgModel` directive instance.
*/
removeControl(dir) {
resolvedPromise$1.then(() => {
const container = this._findContainer(dir.path);
if (container) {
container.removeControl(dir.name);
}
this._directives.delete(dir);
});
}
/**
* @description
* Adds a new `NgModelGroup` directive instance to the form.
*
* @param dir The `NgModelGroup` directive instance.
*/
addFormGroup(dir) {
resolvedPromise$1.then(() => {
const container = this._findContainer(dir.path);
const group = new FormGroup({});
setUpFormContainer(group, dir);
container.registerControl(dir.name, group);
group.updateValueAndValidity({
emitEvent: false
});
});
}
/**
* @description
* Removes the `NgModelGroup` directive instance from the form.
*
* @param dir The `NgModelGroup` directive instance.
*/
removeFormGroup(dir) {
resolvedPromise$1.then(() => {
const container = this._findContainer(dir.path);
if (container) {
container.removeControl(dir.name);
}
});
}
/**
* @description
* Retrieves the `FormGroup` for a provided `NgModelGroup` directive instance
*
* @param dir The `NgModelGroup` directive instance.
*/
getFormGroup(dir) {
return this.form.get(dir.path);
}
/**
* Sets the new value for the provided `NgControl` directive.
*
* @param dir The `NgControl` directive instance.
* @param value The new value for the directive's control.
*/
updateModel(dir, value2) {
resolvedPromise$1.then(() => {
const ctrl = this.form.get(dir.path);
ctrl.setValue(value2);
});
}
/**
* @description
* Sets the value for this `FormGroup`.
*
* @param value The new value
*/
setValue(value2) {
this.control.setValue(value2);
}
/**
* @description
* Method called when the "submit" event is triggered on the form.
* Triggers the `ngSubmit` emitter to emit the "submit" event as its payload.
*
* @param $event The "submit" event object
*/
onSubmit($event) {
this.submitted = true;
syncPendingControls(this.form, this._directives);
this.ngSubmit.emit($event);
return $event?.target?.method === "dialog";
}
/**
* @description
* Method called when the "reset" event is triggered on the form.
*/
onReset() {
this.resetForm();
}
/**
* @description
* Resets the form to an initial value and resets its submitted status.
*
* @param value The new value for the form.
*/
resetForm(value2 = void 0) {
this.form.reset(value2);
this.submitted = false;
}
_setUpdateStrategy() {
if (this.options && this.options.updateOn != null) {
this.form._updateOn = this.options.updateOn;
}
}
_findContainer(path) {
path.pop();
return path.length ? this.form.get(path) : this.form;
}
};
_NgForm.\u0275fac = function NgForm_Factory(t) {
return new (t || _NgForm)(\u0275\u0275directiveInject(NG_VALIDATORS, 10), \u0275\u0275directiveInject(NG_ASYNC_VALIDATORS, 10), \u0275\u0275directiveInject(CALL_SET_DISABLED_STATE, 8));
};
_NgForm.\u0275dir = /* @__PURE__ */ \u0275\u0275defineDirective({
type: _NgForm,
selectors: [["form", 3, "ngNoForm", "", 3, "formGroup", ""], ["ng-form"], ["", "ngForm", ""]],
hostBindings: function NgForm_HostBindings(rf, ctx) {
if (rf & 1) {
\u0275\u0275listener("submit", function NgForm_submit_HostBindingHandler($event) {
return ctx.onSubmit($event);
})("reset", function NgForm_reset_HostBindingHandler() {
return ctx.onReset();
});
}
},
inputs: {
options: [InputFlags.None, "ngFormOptions", "options"]
},
outputs: {
ngSubmit: "ngSubmit"
},
exportAs: ["ngForm"],
features: [\u0275\u0275ProvidersFeature([formDirectiveProvider$1]), \u0275\u0275InheritDefinitionFeature]
});
var NgForm = _NgForm;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(NgForm, [{
type: Directive,
args: [{
selector: "form:not([ngNoForm]):not([formGroup]),ng-form,[ngForm]",
providers: [formDirectiveProvider$1],
host: {
"(submit)": "onSubmit($event)",
"(reset)": "onReset()"
},
outputs: ["ngSubmit"],
exportAs: "ngForm"
}]
}], () => [{
type: void 0,
decorators: [{
type: Optional
}, {
type: Self
}, {
type: Inject,
args: [NG_VALIDATORS]
}]
}, {
type: void 0,
decorators: [{
type: Optional
}, {
type: Self
}, {
type: Inject,
args: [NG_ASYNC_VALIDATORS]
}]
}, {
type: void 0,
decorators: [{
type: Optional
}, {
type: Inject,
args: [CALL_SET_DISABLED_STATE]
}]
}], {
options: [{
type: Input,
args: ["ngFormOptions"]
}]
});
})();
function removeListItem(list, el) {
const index2 = list.indexOf(el);
if (index2 > -1)
list.splice(index2, 1);
}
function isFormControlState(formState) {
return typeof formState === "object" && formState !== null && Object.keys(formState).length === 2 && "value" in formState && "disabled" in formState;
}
var FormControl = class FormControl2 extends AbstractControl {
constructor(formState = null, validatorOrOpts, asyncValidator) {
super(pickValidators(validatorOrOpts), pickAsyncValidators(asyncValidator, validatorOrOpts));
this.defaultValue = null;
this._onChange = [];
this._pendingChange = false;
this._applyFormState(formState);
this._setUpdateStrategy(validatorOrOpts);
this._initObservables();
this.updateValueAndValidity({
onlySelf: true,
// If `asyncValidator` is present, it will trigger control status change from `PENDING` to
// `VALID` or `INVALID`.
// The status should be broadcasted via the `statusChanges` observable, so we set
// `emitEvent` to `true` to allow that during the control creation process.
emitEvent: !!this.asyncValidator
});
if (isOptionsObj(validatorOrOpts) && (validatorOrOpts.nonNullable || validatorOrOpts.initialValueIsDefault)) {
if (isFormControlState(formState)) {
this.defaultValue = formState.value;
} else {
this.defaultValue = formState;
}
}
}
setValue(value2, options = {}) {
this.value = this._pendingValue = value2;
if (this._onChange.length && options.emitModelToViewChange !== false) {
this._onChange.forEach((changeFn) => changeFn(this.value, options.emitViewToModelChange !== false));
}
this.updateValueAndValidity(options);
}
patchValue(value2, options = {}) {
this.setValue(value2, options);
}
reset(formState = this.defaultValue, options = {}) {
this._applyFormState(formState);
this.markAsPristine(options);
this.markAsUntouched(options);
this.setValue(this.value, options);
this._pendingChange = false;
}
/** @internal */
_updateValue() {
}
/** @internal */
_anyControls(condition) {
return false;
}
/** @internal */
_allControlsDisabled() {
return this.disabled;
}
registerOnChange(fn) {
this._onChange.push(fn);
}
/** @internal */
_unregisterOnChange(fn) {
removeListItem(this._onChange, fn);
}
registerOnDisabledChange(fn) {
this._onDisabledChange.push(fn);
}
/** @internal */
_unregisterOnDisabledChange(fn) {
removeListItem(this._onDisabledChange, fn);
}
/** @internal */
_forEachChild(cb) {
}
/** @internal */
_syncPendingControls() {
if (this.updateOn === "submit") {
if (this._pendingDirty)
this.markAsDirty();
if (this._pendingTouched)
this.markAsTouched();
if (this._pendingChange) {
this.setValue(this._pendingValue, {
onlySelf: true,
emitModelToViewChange: false
});
return true;
}
}
return false;
}
_applyFormState(formState) {
if (isFormControlState(formState)) {
this.value = this._pendingValue = formState.value;
formState.disabled ? this.disable({
onlySelf: true,
emitEvent: false
}) : this.enable({
onlySelf: true,
emitEvent: false
});
} else {
this.value = this._pendingValue = formState;
}
}
};
var isFormControl = (control) => control instanceof FormControl;
var _AbstractFormGroupDirective = class _AbstractFormGroupDirective extends ControlContainer {
/** @nodoc */
ngOnInit() {
this._checkParentType();
this.formDirective.addFormGroup(this);
}
/** @nodoc */
ngOnDestroy() {
if (this.formDirective) {
this.formDirective.removeFormGroup(this);
}
}
/**
* @description
* The `FormGroup` bound to this directive.
*/
get control() {
return this.formDirective.getFormGroup(this);
}
/**
* @description
* The path to this group from the top-level directive.
*/
get path() {
return controlPath(this.name == null ? this.name : this.name.toString(), this._parent);
}
/**
* @description
* The top-level directive for this group if present, otherwise null.
*/
get formDirective() {
return this._parent ? this._parent.formDirective : null;
}
/** @internal */
_checkParentType() {
}
};
_AbstractFormGroupDirective.\u0275fac = /* @__PURE__ */ (() => {
let \u0275AbstractFormGroupDirective_BaseFactory;
return function AbstractFormGroupDirective_Factory(t) {
return (\u0275AbstractFormGroupDirective_BaseFactory || (\u0275AbstractFormGroupDirective_BaseFactory = \u0275\u0275getInheritedFactory(_AbstractFormGroupDirective)))(t || _AbstractFormGroupDirective);
};
})();
_AbstractFormGroupDirective.\u0275dir = /* @__PURE__ */ \u0275\u0275defineDirective({
type: _AbstractFormGroupDirective,
features: [\u0275\u0275InheritDefinitionFeature]
});
var AbstractFormGroupDirective = _AbstractFormGroupDirective;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(AbstractFormGroupDirective, [{
type: Directive
}], null, null);
})();
function modelParentException() {
return new RuntimeError(1350, `
ngModel cannot be used to register form controls with a parent formGroup directive. Try using
formGroup's partner directive "formControlName" instead. Example:
${formControlNameExample}
Or, if you'd like to avoid registering this form control, indicate that it's standalone in ngModelOptions:
Example:
${ngModelWithFormGroupExample}`);
}
function formGroupNameException() {
return new RuntimeError(1351, `
ngModel cannot be used to register form controls with a parent formGroupName or formArrayName directive.
Option 1: Use formControlName instead of ngModel (reactive strategy):
${formGroupNameExample}
Option 2: Update ngModel's parent be ngModelGroup (template-driven strategy):
${ngModelGroupExample}`);
}
function missingNameException() {
return new RuntimeError(1352, `If ngModel is used within a form tag, either the name attribute must be set or the form
control must be defined as 'standalone' in ngModelOptions.
Example 1: <input [(ngModel)]="person.firstName" name="first">
Example 2: <input [(ngModel)]="person.firstName" [ngModelOptions]="{standalone: true}">`);
}
function modelGroupParentException() {
return new RuntimeError(1353, `
ngModelGroup cannot be used with a parent formGroup directive.
Option 1: Use formGroupName instead of ngModelGroup (reactive strategy):
${formGroupNameExample}
Option 2: Use a regular form tag instead of the formGroup directive (template-driven strategy):
${ngModelGroupExample}`);
}
var modelGroupProvider = {
provide: ControlContainer,
useExisting: forwardRef(() => NgModelGroup)
};
var _NgModelGroup = class _NgModelGroup extends AbstractFormGroupDirective {
constructor(parent2, validators, asyncValidators) {
super();
this.name = "";
this._parent = parent2;
this._setValidators(validators);
this._setAsyncValidators(asyncValidators);
}
/** @internal */
_checkParentType() {
if (!(this._parent instanceof _NgModelGroup) && !(this._parent instanceof NgForm) && (typeof ngDevMode === "undefined" || ngDevMode)) {
throw modelGroupParentException();
}
}
};
_NgModelGroup.\u0275fac = function NgModelGroup_Factory(t) {
return new (t || _NgModelGroup)(\u0275\u0275directiveInject(ControlContainer, 5), \u0275\u0275directiveInject(NG_VALIDATORS, 10), \u0275\u0275directiveInject(NG_ASYNC_VALIDATORS, 10));
};
_NgModelGroup.\u0275dir = /* @__PURE__ */ \u0275\u0275defineDirective({
type: _NgModelGroup,
selectors: [["", "ngModelGroup", ""]],
inputs: {
name: [InputFlags.None, "ngModelGroup", "name"]
},
exportAs: ["ngModelGroup"],
features: [\u0275\u0275ProvidersFeature([modelGroupProvider]), \u0275\u0275InheritDefinitionFeature]
});
var NgModelGroup = _NgModelGroup;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(NgModelGroup, [{
type: Directive,
args: [{
selector: "[ngModelGroup]",
providers: [modelGroupProvider],
exportAs: "ngModelGroup"
}]
}], () => [{
type: ControlContainer,
decorators: [{
type: Host
}, {
type: SkipSelf
}]
}, {
type: void 0,
decorators: [{
type: Optional
}, {
type: Self
}, {
type: Inject,
args: [NG_VALIDATORS]
}]
}, {
type: void 0,
decorators: [{
type: Optional
}, {
type: Self
}, {
type: Inject,
args: [NG_ASYNC_VALIDATORS]
}]
}], {
name: [{
type: Input,
args: ["ngModelGroup"]
}]
});
})();
var formControlBinding$1 = {
provide: NgControl,
useExisting: forwardRef(() => NgModel)
};
var resolvedPromise = (() => Promise.resolve())();
var _NgModel = class _NgModel extends NgControl {
constructor(parent2, validators, asyncValidators, valueAccessors, _changeDetectorRef, callSetDisabledState) {
super();
this._changeDetectorRef = _changeDetectorRef;
this.callSetDisabledState = callSetDisabledState;
this.control = new FormControl();
this._registered = false;
this.name = "";
this.update = new EventEmitter();
this._parent = parent2;
this._setValidators(validators);
this._setAsyncValidators(asyncValidators);
this.valueAccessor = selectValueAccessor(this, valueAccessors);
}
/** @nodoc */
ngOnChanges(changes) {
this._checkForErrors();
if (!this._registered || "name" in changes) {
if (this._registered) {
this._checkName();
if (this.formDirective) {
const oldName = changes["name"].previousValue;
this.formDirective.removeControl({
name: oldName,
path: this._getPath(oldName)
});
}
}
this._setUpControl();
}
if ("isDisabled" in changes) {
this._updateDisabled(changes);
}
if (isPropertyUpdated(changes, this.viewModel)) {
this._updateValue(this.model);
this.viewModel = this.model;
}
}
/** @nodoc */
ngOnDestroy() {
this.formDirective && this.formDirective.removeControl(this);
}
/**
* @description
* Returns an array that represents the path from the top-level form to this control.
* Each index is the string name of the control on that level.
*/
get path() {
return this._getPath(this.name);
}
/**
* @description
* The top-level directive for this control if present, otherwise null.
*/
get formDirective() {
return this._parent ? this._parent.formDirective : null;
}
/**
* @description
* Sets the new value for the view model and emits an `ngModelChange` event.
*
* @param newValue The new value emitted by `ngModelChange`.
*/
viewToModelUpdate(newValue) {
this.viewModel = newValue;
this.update.emit(newValue);
}
_setUpControl() {
this._setUpdateStrategy();
this._isStandalone() ? this._setUpStandalone() : this.formDirective.addControl(this);
this._registered = true;
}
_setUpdateStrategy() {
if (this.options && this.options.updateOn != null) {
this.control._updateOn = this.options.updateOn;
}
}
_isStandalone() {
return !this._parent || !!(this.options && this.options.standalone);
}
_setUpStandalone() {
setUpControl(this.control, this, this.callSetDisabledState);
this.control.updateValueAndValidity({
emitEvent: false
});
}
_checkForErrors() {
if (!this._isStandalone()) {
this._checkParentType();
}
this._checkName();
}
_checkParentType() {
if (typeof ngDevMode === "undefined" || ngDevMode) {
if (!(this._parent instanceof NgModelGroup) && this._parent instanceof AbstractFormGroupDirective) {
throw formGroupNameException();
} else if (!(this._parent instanceof NgModelGroup) && !(this._parent instanceof NgForm)) {
throw modelParentException();
}
}
}
_checkName() {
if (this.options && this.options.name)
this.name = this.options.name;
if (!this._isStandalone() && !this.name && (typeof ngDevMode === "undefined" || ngDevMode)) {
throw missingNameException();
}
}
_updateValue(value2) {
resolvedPromise.then(() => {
this.control.setValue(value2, {
emitViewToModelChange: false
});
this._changeDetectorRef?.markForCheck();
});
}
_updateDisabled(changes) {
const disabledValue = changes["isDisabled"].currentValue;
const isDisabled = disabledValue !== 0 && booleanAttribute(disabledValue);
resolvedPromise.then(() => {
if (isDisabled && !this.control.disabled) {
this.control.disable();
} else if (!isDisabled && this.control.disabled) {
this.control.enable();
}
this._changeDetectorRef?.markForCheck();
});
}
_getPath(controlName) {
return this._parent ? controlPath(controlName, this._parent) : [controlName];
}
};
_NgModel.\u0275fac = function NgModel_Factory(t) {
return new (t || _NgModel)(\u0275\u0275directiveInject(ControlContainer, 9), \u0275\u0275directiveInject(NG_VALIDATORS, 10), \u0275\u0275directiveInject(NG_ASYNC_VALIDATORS, 10), \u0275\u0275directiveInject(NG_VALUE_ACCESSOR, 10), \u0275\u0275directiveInject(ChangeDetectorRef, 8), \u0275\u0275directiveInject(CALL_SET_DISABLED_STATE, 8));
};
_NgModel.\u0275dir = /* @__PURE__ */ \u0275\u0275defineDirective({
type: _NgModel,
selectors: [["", "ngModel", "", 3, "formControlName", "", 3, "formControl", ""]],
inputs: {
name: "name",
isDisabled: [InputFlags.None, "disabled", "isDisabled"],
model: [InputFlags.None, "ngModel", "model"],
options: [InputFlags.None, "ngModelOptions", "options"]
},
outputs: {
update: "ngModelChange"
},
exportAs: ["ngModel"],
features: [\u0275\u0275ProvidersFeature([formControlBinding$1]), \u0275\u0275InheritDefinitionFeature, \u0275\u0275NgOnChangesFeature]
});
var NgModel = _NgModel;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(NgModel, [{
type: Directive,
args: [{
selector: "[ngModel]:not([formControlName]):not([formControl])",
providers: [formControlBinding$1],
exportAs: "ngModel"
}]
}], () => [{
type: ControlContainer,
decorators: [{
type: Optional
}, {
type: Host
}]
}, {
type: void 0,
decorators: [{
type: Optional
}, {
type: Self
}, {
type: Inject,
args: [NG_VALIDATORS]
}]
}, {
type: void 0,
decorators: [{
type: Optional
}, {
type: Self
}, {
type: Inject,
args: [NG_ASYNC_VALIDATORS]
}]
}, {
type: void 0,
decorators: [{
type: Optional
}, {
type: Self
}, {
type: Inject,
args: [NG_VALUE_ACCESSOR]
}]
}, {
type: ChangeDetectorRef,
decorators: [{
type: Optional
}, {
type: Inject,
args: [ChangeDetectorRef]
}]
}, {
type: void 0,
decorators: [{
type: Optional
}, {
type: Inject,
args: [CALL_SET_DISABLED_STATE]
}]
}], {
name: [{
type: Input
}],
isDisabled: [{
type: Input,
args: ["disabled"]
}],
model: [{
type: Input,
args: ["ngModel"]
}],
options: [{
type: Input,
args: ["ngModelOptions"]
}],
update: [{
type: Output,
args: ["ngModelChange"]
}]
});
})();
var _\u0275NgNoValidate = class _\u0275NgNoValidate {
};
_\u0275NgNoValidate.\u0275fac = function \u0275NgNoValidate_Factory(t) {
return new (t || _\u0275NgNoValidate)();
};
_\u0275NgNoValidate.\u0275dir = /* @__PURE__ */ \u0275\u0275defineDirective({
type: _\u0275NgNoValidate,
selectors: [["form", 3, "ngNoForm", "", 3, "ngNativeValidate", ""]],
hostAttrs: ["novalidate", ""]
});
var \u0275NgNoValidate = _\u0275NgNoValidate;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(\u0275NgNoValidate, [{
type: Directive,
args: [{
selector: "form:not([ngNoForm]):not([ngNativeValidate])",
host: {
"novalidate": ""
}
}]
}], null, null);
})();
var NUMBER_VALUE_ACCESSOR = {
provide: NG_VALUE_ACCESSOR,
useExisting: forwardRef(() => NumberValueAccessor),
multi: true
};
var _NumberValueAccessor = class _NumberValueAccessor extends BuiltInControlValueAccessor {
/**
* Sets the "value" property on the input element.
* @nodoc
*/
writeValue(value2) {
const normalizedValue = value2 == null ? "" : value2;
this.setProperty("value", normalizedValue);
}
/**
* Registers a function called when the control value changes.
* @nodoc
*/
registerOnChange(fn) {
this.onChange = (value2) => {
fn(value2 == "" ? null : parseFloat(value2));
};
}
};
_NumberValueAccessor.\u0275fac = /* @__PURE__ */ (() => {
let \u0275NumberValueAccessor_BaseFactory;
return function NumberValueAccessor_Factory(t) {
return (\u0275NumberValueAccessor_BaseFactory || (\u0275NumberValueAccessor_BaseFactory = \u0275\u0275getInheritedFactory(_NumberValueAccessor)))(t || _NumberValueAccessor);
};
})();
_NumberValueAccessor.\u0275dir = /* @__PURE__ */ \u0275\u0275defineDirective({
type: _NumberValueAccessor,
selectors: [["input", "type", "number", "formControlName", ""], ["input", "type", "number", "formControl", ""], ["input", "type", "number", "ngModel", ""]],
hostBindings: function NumberValueAccessor_HostBindings(rf, ctx) {
if (rf & 1) {
\u0275\u0275listener("input", function NumberValueAccessor_input_HostBindingHandler($event) {
return ctx.onChange($event.target.value);
})("blur", function NumberValueAccessor_blur_HostBindingHandler() {
return ctx.onTouched();
});
}
},
features: [\u0275\u0275ProvidersFeature([NUMBER_VALUE_ACCESSOR]), \u0275\u0275InheritDefinitionFeature]
});
var NumberValueAccessor = _NumberValueAccessor;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(NumberValueAccessor, [{
type: Directive,
args: [{
selector: "input[type=number][formControlName],input[type=number][formControl],input[type=number][ngModel]",
host: {
"(input)": "onChange($event.target.value)",
"(blur)": "onTouched()"
},
providers: [NUMBER_VALUE_ACCESSOR]
}]
}], null, null);
})();
var RADIO_VALUE_ACCESSOR = {
provide: NG_VALUE_ACCESSOR,
useExisting: forwardRef(() => RadioControlValueAccessor),
multi: true
};
function throwNameError() {
throw new RuntimeError(1202, `
If you define both a name and a formControlName attribute on your radio button, their values
must match. Ex: <input type="radio" formControlName="food" name="food">
`);
}
var _RadioControlRegistry = class _RadioControlRegistry {
constructor() {
this._accessors = [];
}
/**
* @description
* Adds a control to the internal registry. For internal use only.
*/
add(control, accessor) {
this._accessors.push([control, accessor]);
}
/**
* @description
* Removes a control from the internal registry. For internal use only.
*/
remove(accessor) {
for (let i = this._accessors.length - 1; i >= 0; --i) {
if (this._accessors[i][1] === accessor) {
this._accessors.splice(i, 1);
return;
}
}
}
/**
* @description
* Selects a radio button. For internal use only.
*/
select(accessor) {
this._accessors.forEach((c) => {
if (this._isSameGroup(c, accessor) && c[1] !== accessor) {
c[1].fireUncheck(accessor.value);
}
});
}
_isSameGroup(controlPair, accessor) {
if (!controlPair[0].control)
return false;
return controlPair[0]._parent === accessor._control._parent && controlPair[1].name === accessor.name;
}
};
_RadioControlRegistry.\u0275fac = function RadioControlRegistry_Factory(t) {
return new (t || _RadioControlRegistry)();
};
_RadioControlRegistry.\u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
token: _RadioControlRegistry,
factory: _RadioControlRegistry.\u0275fac,
providedIn: "root"
});
var RadioControlRegistry = _RadioControlRegistry;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(RadioControlRegistry, [{
type: Injectable,
args: [{
providedIn: "root"
}]
}], null, null);
})();
var _RadioControlValueAccessor = class _RadioControlValueAccessor extends BuiltInControlValueAccessor {
constructor(renderer2, elementRef, _registry, _injector) {
super(renderer2, elementRef);
this._registry = _registry;
this._injector = _injector;
this.setDisabledStateFired = false;
this.onChange = () => {
};
this.callSetDisabledState = inject(CALL_SET_DISABLED_STATE, {
optional: true
}) ?? setDisabledStateDefault;
}
/** @nodoc */
ngOnInit() {
this._control = this._injector.get(NgControl);
this._checkName();
this._registry.add(this._control, this);
}
/** @nodoc */
ngOnDestroy() {
this._registry.remove(this);
}
/**
* Sets the "checked" property value on the radio input element.
* @nodoc
*/
writeValue(value2) {
this._state = value2 === this.value;
this.setProperty("checked", this._state);
}
/**
* Registers a function called when the control value changes.
* @nodoc
*/
registerOnChange(fn) {
this._fn = fn;
this.onChange = () => {
fn(this.value);
this._registry.select(this);
};
}
/** @nodoc */
setDisabledState(isDisabled) {
if (this.setDisabledStateFired || isDisabled || this.callSetDisabledState === "whenDisabledForLegacyCode") {
this.setProperty("disabled", isDisabled);
}
this.setDisabledStateFired = true;
}
/**
* Sets the "value" on the radio input element and unchecks it.
*
* @param value
*/
fireUncheck(value2) {
this.writeValue(value2);
}
_checkName() {
if (this.name && this.formControlName && this.name !== this.formControlName && (typeof ngDevMode === "undefined" || ngDevMode)) {
throwNameError();
}
if (!this.name && this.formControlName)
this.name = this.formControlName;
}
};
_RadioControlValueAccessor.\u0275fac = function RadioControlValueAccessor_Factory(t) {
return new (t || _RadioControlValueAccessor)(\u0275\u0275directiveInject(Renderer2), \u0275\u0275directiveInject(ElementRef), \u0275\u0275directiveInject(RadioControlRegistry), \u0275\u0275directiveInject(Injector));
};
_RadioControlValueAccessor.\u0275dir = /* @__PURE__ */ \u0275\u0275defineDirective({
type: _RadioControlValueAccessor,
selectors: [["input", "type", "radio", "formControlName", ""], ["input", "type", "radio", "formControl", ""], ["input", "type", "radio", "ngModel", ""]],
hostBindings: function RadioControlValueAccessor_HostBindings(rf, ctx) {
if (rf & 1) {
\u0275\u0275listener("change", function RadioControlValueAccessor_change_HostBindingHandler() {
return ctx.onChange();
})("blur", function RadioControlValueAccessor_blur_HostBindingHandler() {
return ctx.onTouched();
});
}
},
inputs: {
name: "name",
formControlName: "formControlName",
value: "value"
},
features: [\u0275\u0275ProvidersFeature([RADIO_VALUE_ACCESSOR]), \u0275\u0275InheritDefinitionFeature]
});
var RadioControlValueAccessor = _RadioControlValueAccessor;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(RadioControlValueAccessor, [{
type: Directive,
args: [{
selector: "input[type=radio][formControlName],input[type=radio][formControl],input[type=radio][ngModel]",
host: {
"(change)": "onChange()",
"(blur)": "onTouched()"
},
providers: [RADIO_VALUE_ACCESSOR]
}]
}], () => [{
type: Renderer2
}, {
type: ElementRef
}, {
type: RadioControlRegistry
}, {
type: Injector
}], {
name: [{
type: Input
}],
formControlName: [{
type: Input
}],
value: [{
type: Input
}]
});
})();
var RANGE_VALUE_ACCESSOR = {
provide: NG_VALUE_ACCESSOR,
useExisting: forwardRef(() => RangeValueAccessor),
multi: true
};
var _RangeValueAccessor = class _RangeValueAccessor extends BuiltInControlValueAccessor {
/**
* Sets the "value" property on the input element.
* @nodoc
*/
writeValue(value2) {
this.setProperty("value", parseFloat(value2));
}
/**
* Registers a function called when the control value changes.
* @nodoc
*/
registerOnChange(fn) {
this.onChange = (value2) => {
fn(value2 == "" ? null : parseFloat(value2));
};
}
};
_RangeValueAccessor.\u0275fac = /* @__PURE__ */ (() => {
let \u0275RangeValueAccessor_BaseFactory;
return function RangeValueAccessor_Factory(t) {
return (\u0275RangeValueAccessor_BaseFactory || (\u0275RangeValueAccessor_BaseFactory = \u0275\u0275getInheritedFactory(_RangeValueAccessor)))(t || _RangeValueAccessor);
};
})();
_RangeValueAccessor.\u0275dir = /* @__PURE__ */ \u0275\u0275defineDirective({
type: _RangeValueAccessor,
selectors: [["input", "type", "range", "formControlName", ""], ["input", "type", "range", "formControl", ""], ["input", "type", "range", "ngModel", ""]],
hostBindings: function RangeValueAccessor_HostBindings(rf, ctx) {
if (rf & 1) {
\u0275\u0275listener("change", function RangeValueAccessor_change_HostBindingHandler($event) {
return ctx.onChange($event.target.value);
})("input", function RangeValueAccessor_input_HostBindingHandler($event) {
return ctx.onChange($event.target.value);
})("blur", function RangeValueAccessor_blur_HostBindingHandler() {
return ctx.onTouched();
});
}
},
features: [\u0275\u0275ProvidersFeature([RANGE_VALUE_ACCESSOR]), \u0275\u0275InheritDefinitionFeature]
});
var RangeValueAccessor = _RangeValueAccessor;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(RangeValueAccessor, [{
type: Directive,
args: [{
selector: "input[type=range][formControlName],input[type=range][formControl],input[type=range][ngModel]",
host: {
"(change)": "onChange($event.target.value)",
"(input)": "onChange($event.target.value)",
"(blur)": "onTouched()"
},
providers: [RANGE_VALUE_ACCESSOR]
}]
}], null, null);
})();
var NG_MODEL_WITH_FORM_CONTROL_WARNING = new InjectionToken(ngDevMode ? "NgModelWithFormControlWarning" : "");
var formControlBinding = {
provide: NgControl,
useExisting: forwardRef(() => FormControlDirective)
};
var _FormControlDirective = class _FormControlDirective extends NgControl {
/**
* @description
* Triggers a warning in dev mode that this input should not be used with reactive forms.
*/
set isDisabled(isDisabled) {
if (typeof ngDevMode === "undefined" || ngDevMode) {
console.warn(disabledAttrWarning);
}
}
constructor(validators, asyncValidators, valueAccessors, _ngModelWarningConfig, callSetDisabledState) {
super();
this._ngModelWarningConfig = _ngModelWarningConfig;
this.callSetDisabledState = callSetDisabledState;
this.update = new EventEmitter();
this._ngModelWarningSent = false;
this._setValidators(validators);
this._setAsyncValidators(asyncValidators);
this.valueAccessor = selectValueAccessor(this, valueAccessors);
}
/** @nodoc */
ngOnChanges(changes) {
if (this._isControlChanged(changes)) {
const previousForm = changes["form"].previousValue;
if (previousForm) {
cleanUpControl(
previousForm,
this,
/* validateControlPresenceOnChange */
false
);
}
setUpControl(this.form, this, this.callSetDisabledState);
this.form.updateValueAndValidity({
emitEvent: false
});
}
if (isPropertyUpdated(changes, this.viewModel)) {
if (typeof ngDevMode === "undefined" || ngDevMode) {
_ngModelWarning("formControl", _FormControlDirective, this, this._ngModelWarningConfig);
}
this.form.setValue(this.model);
this.viewModel = this.model;
}
}
/** @nodoc */
ngOnDestroy() {
if (this.form) {
cleanUpControl(
this.form,
this,
/* validateControlPresenceOnChange */
false
);
}
}
/**
* @description
* Returns an array that represents the path from the top-level form to this control.
* Each index is the string name of the control on that level.
*/
get path() {
return [];
}
/**
* @description
* The `FormControl` bound to this directive.
*/
get control() {
return this.form;
}
/**
* @description
* Sets the new value for the view model and emits an `ngModelChange` event.
*
* @param newValue The new value for the view model.
*/
viewToModelUpdate(newValue) {
this.viewModel = newValue;
this.update.emit(newValue);
}
_isControlChanged(changes) {
return changes.hasOwnProperty("form");
}
};
_FormControlDirective._ngModelWarningSentOnce = false;
_FormControlDirective.\u0275fac = function FormControlDirective_Factory(t) {
return new (t || _FormControlDirective)(\u0275\u0275directiveInject(NG_VALIDATORS, 10), \u0275\u0275directiveInject(NG_ASYNC_VALIDATORS, 10), \u0275\u0275directiveInject(NG_VALUE_ACCESSOR, 10), \u0275\u0275directiveInject(NG_MODEL_WITH_FORM_CONTROL_WARNING, 8), \u0275\u0275directiveInject(CALL_SET_DISABLED_STATE, 8));
};
_FormControlDirective.\u0275dir = /* @__PURE__ */ \u0275\u0275defineDirective({
type: _FormControlDirective,
selectors: [["", "formControl", ""]],
inputs: {
form: [InputFlags.None, "formControl", "form"],
isDisabled: [InputFlags.None, "disabled", "isDisabled"],
model: [InputFlags.None, "ngModel", "model"]
},
outputs: {
update: "ngModelChange"
},
exportAs: ["ngForm"],
features: [\u0275\u0275ProvidersFeature([formControlBinding]), \u0275\u0275InheritDefinitionFeature, \u0275\u0275NgOnChangesFeature]
});
var FormControlDirective = _FormControlDirective;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(FormControlDirective, [{
type: Directive,
args: [{
selector: "[formControl]",
providers: [formControlBinding],
exportAs: "ngForm"
}]
}], () => [{
type: void 0,
decorators: [{
type: Optional
}, {
type: Self
}, {
type: Inject,
args: [NG_VALIDATORS]
}]
}, {
type: void 0,
decorators: [{
type: Optional
}, {
type: Self
}, {
type: Inject,
args: [NG_ASYNC_VALIDATORS]
}]
}, {
type: void 0,
decorators: [{
type: Optional
}, {
type: Self
}, {
type: Inject,
args: [NG_VALUE_ACCESSOR]
}]
}, {
type: void 0,
decorators: [{
type: Optional
}, {
type: Inject,
args: [NG_MODEL_WITH_FORM_CONTROL_WARNING]
}]
}, {
type: void 0,
decorators: [{
type: Optional
}, {
type: Inject,
args: [CALL_SET_DISABLED_STATE]
}]
}], {
form: [{
type: Input,
args: ["formControl"]
}],
isDisabled: [{
type: Input,
args: ["disabled"]
}],
model: [{
type: Input,
args: ["ngModel"]
}],
update: [{
type: Output,
args: ["ngModelChange"]
}]
});
})();
var formDirectiveProvider = {
provide: ControlContainer,
useExisting: forwardRef(() => FormGroupDirective)
};
var _FormGroupDirective = class _FormGroupDirective extends ControlContainer {
constructor(validators, asyncValidators, callSetDisabledState) {
super();
this.callSetDisabledState = callSetDisabledState;
this.submitted = false;
this._onCollectionChange = () => this._updateDomValue();
this.directives = [];
this.form = null;
this.ngSubmit = new EventEmitter();
this._setValidators(validators);
this._setAsyncValidators(asyncValidators);
}
/** @nodoc */
ngOnChanges(changes) {
this._checkFormPresent();
if (changes.hasOwnProperty("form")) {
this._updateValidators();
this._updateDomValue();
this._updateRegistrations();
this._oldForm = this.form;
}
}
/** @nodoc */
ngOnDestroy() {
if (this.form) {
cleanUpValidators(this.form, this);
if (this.form._onCollectionChange === this._onCollectionChange) {
this.form._registerOnCollectionChange(() => {
});
}
}
}
/**
* @description
* Returns this directive's instance.
*/
get formDirective() {
return this;
}
/**
* @description
* Returns the `FormGroup` bound to this directive.
*/
get control() {
return this.form;
}
/**
* @description
* Returns an array representing the path to this group. Because this directive
* always lives at the top level of a form, it always an empty array.
*/
get path() {
return [];
}
/**
* @description
* Method that sets up the control directive in this group, re-calculates its value
* and validity, and adds the instance to the internal list of directives.
*
* @param dir The `FormControlName` directive instance.
*/
addControl(dir) {
const ctrl = this.form.get(dir.path);
setUpControl(ctrl, dir, this.callSetDisabledState);
ctrl.updateValueAndValidity({
emitEvent: false
});
this.directives.push(dir);
return ctrl;
}
/**
* @description
* Retrieves the `FormControl` instance from the provided `FormControlName` directive
*
* @param dir The `FormControlName` directive instance.
*/
getControl(dir) {
return this.form.get(dir.path);
}
/**
* @description
* Removes the `FormControlName` instance from the internal list of directives
*
* @param dir The `FormControlName` directive instance.
*/
removeControl(dir) {
cleanUpControl(
dir.control || null,
dir,
/* validateControlPresenceOnChange */
false
);
removeListItem$1(this.directives, dir);
}
/**
* Adds a new `FormGroupName` directive instance to the form.
*
* @param dir The `FormGroupName` directive instance.
*/
addFormGroup(dir) {
this._setUpFormContainer(dir);
}
/**
* Performs the necessary cleanup when a `FormGroupName` directive instance is removed from the
* view.
*
* @param dir The `FormGroupName` directive instance.
*/
removeFormGroup(dir) {
this._cleanUpFormContainer(dir);
}
/**
* @description
* Retrieves the `FormGroup` for a provided `FormGroupName` directive instance
*
* @param dir The `FormGroupName` directive instance.
*/
getFormGroup(dir) {
return this.form.get(dir.path);
}
/**
* Performs the necessary setup when a `FormArrayName` directive instance is added to the view.
*
* @param dir The `FormArrayName` directive instance.
*/
addFormArray(dir) {
this._setUpFormContainer(dir);
}
/**
* Performs the necessary cleanup when a `FormArrayName` directive instance is removed from the
* view.
*
* @param dir The `FormArrayName` directive instance.
*/
removeFormArray(dir) {
this._cleanUpFormContainer(dir);
}
/**
* @description
* Retrieves the `FormArray` for a provided `FormArrayName` directive instance.
*
* @param dir The `FormArrayName` directive instance.
*/
getFormArray(dir) {
return this.form.get(dir.path);
}
/**
* Sets the new value for the provided `FormControlName` directive.
*
* @param dir The `FormControlName` directive instance.
* @param value The new value for the directive's control.
*/
updateModel(dir, value2) {
const ctrl = this.form.get(dir.path);
ctrl.setValue(value2);
}
/**
* @description
* Method called with the "submit" event is triggered on the form.
* Triggers the `ngSubmit` emitter to emit the "submit" event as its payload.
*
* @param $event The "submit" event object
*/
onSubmit($event) {
this.submitted = true;
syncPendingControls(this.form, this.directives);
this.ngSubmit.emit($event);
return $event?.target?.method === "dialog";
}
/**
* @description
* Method called when the "reset" event is triggered on the form.
*/
onReset() {
this.resetForm();
}
/**
* @description
* Resets the form to an initial value and resets its submitted status.
*
* @param value The new value for the form.
*/
resetForm(value2 = void 0) {
this.form.reset(value2);
this.submitted = false;
}
/** @internal */
_updateDomValue() {
this.directives.forEach((dir) => {
const oldCtrl = dir.control;
const newCtrl = this.form.get(dir.path);
if (oldCtrl !== newCtrl) {
cleanUpControl(oldCtrl || null, dir);
if (isFormControl(newCtrl)) {
setUpControl(newCtrl, dir, this.callSetDisabledState);
dir.control = newCtrl;
}
}
});
this.form._updateTreeValidity({
emitEvent: false
});
}
_setUpFormContainer(dir) {
const ctrl = this.form.get(dir.path);
setUpFormContainer(ctrl, dir);
ctrl.updateValueAndValidity({
emitEvent: false
});
}
_cleanUpFormContainer(dir) {
if (this.form) {
const ctrl = this.form.get(dir.path);
if (ctrl) {
const isControlUpdated = cleanUpFormContainer(ctrl, dir);
if (isControlUpdated) {
ctrl.updateValueAndValidity({
emitEvent: false
});
}
}
}
}
_updateRegistrations() {
this.form._registerOnCollectionChange(this._onCollectionChange);
if (this._oldForm) {
this._oldForm._registerOnCollectionChange(() => {
});
}
}
_updateValidators() {
setUpValidators(this.form, this);
if (this._oldForm) {
cleanUpValidators(this._oldForm, this);
}
}
_checkFormPresent() {
if (!this.form && (typeof ngDevMode === "undefined" || ngDevMode)) {
throw missingFormException();
}
}
};
_FormGroupDirective.\u0275fac = function FormGroupDirective_Factory(t) {
return new (t || _FormGroupDirective)(\u0275\u0275directiveInject(NG_VALIDATORS, 10), \u0275\u0275directiveInject(NG_ASYNC_VALIDATORS, 10), \u0275\u0275directiveInject(CALL_SET_DISABLED_STATE, 8));
};
_FormGroupDirective.\u0275dir = /* @__PURE__ */ \u0275\u0275defineDirective({
type: _FormGroupDirective,
selectors: [["", "formGroup", ""]],
hostBindings: function FormGroupDirective_HostBindings(rf, ctx) {
if (rf & 1) {
\u0275\u0275listener("submit", function FormGroupDirective_submit_HostBindingHandler($event) {
return ctx.onSubmit($event);
})("reset", function FormGroupDirective_reset_HostBindingHandler() {
return ctx.onReset();
});
}
},
inputs: {
form: [InputFlags.None, "formGroup", "form"]
},
outputs: {
ngSubmit: "ngSubmit"
},
exportAs: ["ngForm"],
features: [\u0275\u0275ProvidersFeature([formDirectiveProvider]), \u0275\u0275InheritDefinitionFeature, \u0275\u0275NgOnChangesFeature]
});
var FormGroupDirective = _FormGroupDirective;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(FormGroupDirective, [{
type: Directive,
args: [{
selector: "[formGroup]",
providers: [formDirectiveProvider],
host: {
"(submit)": "onSubmit($event)",
"(reset)": "onReset()"
},
exportAs: "ngForm"
}]
}], () => [{
type: void 0,
decorators: [{
type: Optional
}, {
type: Self
}, {
type: Inject,
args: [NG_VALIDATORS]
}]
}, {
type: void 0,
decorators: [{
type: Optional
}, {
type: Self
}, {
type: Inject,
args: [NG_ASYNC_VALIDATORS]
}]
}, {
type: void 0,
decorators: [{
type: Optional
}, {
type: Inject,
args: [CALL_SET_DISABLED_STATE]
}]
}], {
form: [{
type: Input,
args: ["formGroup"]
}],
ngSubmit: [{
type: Output
}]
});
})();
var formGroupNameProvider = {
provide: ControlContainer,
useExisting: forwardRef(() => FormGroupName)
};
var _FormGroupName = class _FormGroupName extends AbstractFormGroupDirective {
constructor(parent2, validators, asyncValidators) {
super();
this.name = null;
this._parent = parent2;
this._setValidators(validators);
this._setAsyncValidators(asyncValidators);
}
/** @internal */
_checkParentType() {
if (_hasInvalidParent(this._parent) && (typeof ngDevMode === "undefined" || ngDevMode)) {
throw groupParentException();
}
}
};
_FormGroupName.\u0275fac = function FormGroupName_Factory(t) {
return new (t || _FormGroupName)(\u0275\u0275directiveInject(ControlContainer, 13), \u0275\u0275directiveInject(NG_VALIDATORS, 10), \u0275\u0275directiveInject(NG_ASYNC_VALIDATORS, 10));
};
_FormGroupName.\u0275dir = /* @__PURE__ */ \u0275\u0275defineDirective({
type: _FormGroupName,
selectors: [["", "formGroupName", ""]],
inputs: {
name: [InputFlags.None, "formGroupName", "name"]
},
features: [\u0275\u0275ProvidersFeature([formGroupNameProvider]), \u0275\u0275InheritDefinitionFeature]
});
var FormGroupName = _FormGroupName;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(FormGroupName, [{
type: Directive,
args: [{
selector: "[formGroupName]",
providers: [formGroupNameProvider]
}]
}], () => [{
type: ControlContainer,
decorators: [{
type: Optional
}, {
type: Host
}, {
type: SkipSelf
}]
}, {
type: void 0,
decorators: [{
type: Optional
}, {
type: Self
}, {
type: Inject,
args: [NG_VALIDATORS]
}]
}, {
type: void 0,
decorators: [{
type: Optional
}, {
type: Self
}, {
type: Inject,
args: [NG_ASYNC_VALIDATORS]
}]
}], {
name: [{
type: Input,
args: ["formGroupName"]
}]
});
})();
var formArrayNameProvider = {
provide: ControlContainer,
useExisting: forwardRef(() => FormArrayName)
};
var _FormArrayName = class _FormArrayName extends ControlContainer {
constructor(parent2, validators, asyncValidators) {
super();
this.name = null;
this._parent = parent2;
this._setValidators(validators);
this._setAsyncValidators(asyncValidators);
}
/**
* A lifecycle method called when the directive's inputs are initialized. For internal use only.
* @throws If the directive does not have a valid parent.
* @nodoc
*/
ngOnInit() {
this._checkParentType();
this.formDirective.addFormArray(this);
}
/**
* A lifecycle method called before the directive's instance is destroyed. For internal use only.
* @nodoc
*/
ngOnDestroy() {
if (this.formDirective) {
this.formDirective.removeFormArray(this);
}
}
/**
* @description
* The `FormArray` bound to this directive.
*/
get control() {
return this.formDirective.getFormArray(this);
}
/**
* @description
* The top-level directive for this group if present, otherwise null.
*/
get formDirective() {
return this._parent ? this._parent.formDirective : null;
}
/**
* @description
* Returns an array that represents the path from the top-level form to this control.
* Each index is the string name of the control on that level.
*/
get path() {
return controlPath(this.name == null ? this.name : this.name.toString(), this._parent);
}
_checkParentType() {
if (_hasInvalidParent(this._parent) && (typeof ngDevMode === "undefined" || ngDevMode)) {
throw arrayParentException();
}
}
};
_FormArrayName.\u0275fac = function FormArrayName_Factory(t) {
return new (t || _FormArrayName)(\u0275\u0275directiveInject(ControlContainer, 13), \u0275\u0275directiveInject(NG_VALIDATORS, 10), \u0275\u0275directiveInject(NG_ASYNC_VALIDATORS, 10));
};
_FormArrayName.\u0275dir = /* @__PURE__ */ \u0275\u0275defineDirective({
type: _FormArrayName,
selectors: [["", "formArrayName", ""]],
inputs: {
name: [InputFlags.None, "formArrayName", "name"]
},
features: [\u0275\u0275ProvidersFeature([formArrayNameProvider]), \u0275\u0275InheritDefinitionFeature]
});
var FormArrayName = _FormArrayName;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(FormArrayName, [{
type: Directive,
args: [{
selector: "[formArrayName]",
providers: [formArrayNameProvider]
}]
}], () => [{
type: ControlContainer,
decorators: [{
type: Optional
}, {
type: Host
}, {
type: SkipSelf
}]
}, {
type: void 0,
decorators: [{
type: Optional
}, {
type: Self
}, {
type: Inject,
args: [NG_VALIDATORS]
}]
}, {
type: void 0,
decorators: [{
type: Optional
}, {
type: Self
}, {
type: Inject,
args: [NG_ASYNC_VALIDATORS]
}]
}], {
name: [{
type: Input,
args: ["formArrayName"]
}]
});
})();
function _hasInvalidParent(parent2) {
return !(parent2 instanceof FormGroupName) && !(parent2 instanceof FormGroupDirective) && !(parent2 instanceof FormArrayName);
}
var controlNameBinding = {
provide: NgControl,
useExisting: forwardRef(() => FormControlName)
};
var _FormControlName = class _FormControlName extends NgControl {
/**
* @description
* Triggers a warning in dev mode that this input should not be used with reactive forms.
*/
set isDisabled(isDisabled) {
if (typeof ngDevMode === "undefined" || ngDevMode) {
console.warn(disabledAttrWarning);
}
}
constructor(parent2, validators, asyncValidators, valueAccessors, _ngModelWarningConfig) {
super();
this._ngModelWarningConfig = _ngModelWarningConfig;
this._added = false;
this.name = null;
this.update = new EventEmitter();
this._ngModelWarningSent = false;
this._parent = parent2;
this._setValidators(validators);
this._setAsyncValidators(asyncValidators);
this.valueAccessor = selectValueAccessor(this, valueAccessors);
}
/** @nodoc */
ngOnChanges(changes) {
if (!this._added)
this._setUpControl();
if (isPropertyUpdated(changes, this.viewModel)) {
if (typeof ngDevMode === "undefined" || ngDevMode) {
_ngModelWarning("formControlName", _FormControlName, this, this._ngModelWarningConfig);
}
this.viewModel = this.model;
this.formDirective.updateModel(this, this.model);
}
}
/** @nodoc */
ngOnDestroy() {
if (this.formDirective) {
this.formDirective.removeControl(this);
}
}
/**
* @description
* Sets the new value for the view model and emits an `ngModelChange` event.
*
* @param newValue The new value for the view model.
*/
viewToModelUpdate(newValue) {
this.viewModel = newValue;
this.update.emit(newValue);
}
/**
* @description
* Returns an array that represents the path from the top-level form to this control.
* Each index is the string name of the control on that level.
*/
get path() {
return controlPath(this.name == null ? this.name : this.name.toString(), this._parent);
}
/**
* @description
* The top-level directive for this group if present, otherwise null.
*/
get formDirective() {
return this._parent ? this._parent.formDirective : null;
}
_checkParentType() {
if (typeof ngDevMode === "undefined" || ngDevMode) {
if (!(this._parent instanceof FormGroupName) && this._parent instanceof AbstractFormGroupDirective) {
throw ngModelGroupException();
} else if (!(this._parent instanceof FormGroupName) && !(this._parent instanceof FormGroupDirective) && !(this._parent instanceof FormArrayName)) {
throw controlParentException();
}
}
}
_setUpControl() {
this._checkParentType();
this.control = this.formDirective.addControl(this);
this._added = true;
}
};
_FormControlName._ngModelWarningSentOnce = false;
_FormControlName.\u0275fac = function FormControlName_Factory(t) {
return new (t || _FormControlName)(\u0275\u0275directiveInject(ControlContainer, 13), \u0275\u0275directiveInject(NG_VALIDATORS, 10), \u0275\u0275directiveInject(NG_ASYNC_VALIDATORS, 10), \u0275\u0275directiveInject(NG_VALUE_ACCESSOR, 10), \u0275\u0275directiveInject(NG_MODEL_WITH_FORM_CONTROL_WARNING, 8));
};
_FormControlName.\u0275dir = /* @__PURE__ */ \u0275\u0275defineDirective({
type: _FormControlName,
selectors: [["", "formControlName", ""]],
inputs: {
name: [InputFlags.None, "formControlName", "name"],
isDisabled: [InputFlags.None, "disabled", "isDisabled"],
model: [InputFlags.None, "ngModel", "model"]
},
outputs: {
update: "ngModelChange"
},
features: [\u0275\u0275ProvidersFeature([controlNameBinding]), \u0275\u0275InheritDefinitionFeature, \u0275\u0275NgOnChangesFeature]
});
var FormControlName = _FormControlName;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(FormControlName, [{
type: Directive,
args: [{
selector: "[formControlName]",
providers: [controlNameBinding]
}]
}], () => [{
type: ControlContainer,
decorators: [{
type: Optional
}, {
type: Host
}, {
type: SkipSelf
}]
}, {
type: void 0,
decorators: [{
type: Optional
}, {
type: Self
}, {
type: Inject,
args: [NG_VALIDATORS]
}]
}, {
type: void 0,
decorators: [{
type: Optional
}, {
type: Self
}, {
type: Inject,
args: [NG_ASYNC_VALIDATORS]
}]
}, {
type: void 0,
decorators: [{
type: Optional
}, {
type: Self
}, {
type: Inject,
args: [NG_VALUE_ACCESSOR]
}]
}, {
type: void 0,
decorators: [{
type: Optional
}, {
type: Inject,
args: [NG_MODEL_WITH_FORM_CONTROL_WARNING]
}]
}], {
name: [{
type: Input,
args: ["formControlName"]
}],
isDisabled: [{
type: Input,
args: ["disabled"]
}],
model: [{
type: Input,
args: ["ngModel"]
}],
update: [{
type: Output,
args: ["ngModelChange"]
}]
});
})();
var SELECT_VALUE_ACCESSOR = {
provide: NG_VALUE_ACCESSOR,
useExisting: forwardRef(() => SelectControlValueAccessor),
multi: true
};
function _buildValueString$1(id, value2) {
if (id == null)
return `${value2}`;
if (value2 && typeof value2 === "object")
value2 = "Object";
return `${id}: ${value2}`.slice(0, 50);
}
function _extractId$1(valueString) {
return valueString.split(":")[0];
}
var _SelectControlValueAccessor = class _SelectControlValueAccessor extends BuiltInControlValueAccessor {
constructor() {
super(...arguments);
this._optionMap = /* @__PURE__ */ new Map();
this._idCounter = 0;
this._compareWith = Object.is;
}
/**
* @description
* Tracks the option comparison algorithm for tracking identities when
* checking for changes.
*/
set compareWith(fn) {
if (typeof fn !== "function" && (typeof ngDevMode === "undefined" || ngDevMode)) {
throw new RuntimeError(1201, `compareWith must be a function, but received ${JSON.stringify(fn)}`);
}
this._compareWith = fn;
}
/**
* Sets the "value" property on the select element.
* @nodoc
*/
writeValue(value2) {
this.value = value2;
const id = this._getOptionId(value2);
const valueString = _buildValueString$1(id, value2);
this.setProperty("value", valueString);
}
/**
* Registers a function called when the control value changes.
* @nodoc
*/
registerOnChange(fn) {
this.onChange = (valueString) => {
this.value = this._getOptionValue(valueString);
fn(this.value);
};
}
/** @internal */
_registerOption() {
return (this._idCounter++).toString();
}
/** @internal */
_getOptionId(value2) {
for (const id of this._optionMap.keys()) {
if (this._compareWith(this._optionMap.get(id), value2))
return id;
}
return null;
}
/** @internal */
_getOptionValue(valueString) {
const id = _extractId$1(valueString);
return this._optionMap.has(id) ? this._optionMap.get(id) : valueString;
}
};
_SelectControlValueAccessor.\u0275fac = /* @__PURE__ */ (() => {
let \u0275SelectControlValueAccessor_BaseFactory;
return function SelectControlValueAccessor_Factory(t) {
return (\u0275SelectControlValueAccessor_BaseFactory || (\u0275SelectControlValueAccessor_BaseFactory = \u0275\u0275getInheritedFactory(_SelectControlValueAccessor)))(t || _SelectControlValueAccessor);
};
})();
_SelectControlValueAccessor.\u0275dir = /* @__PURE__ */ \u0275\u0275defineDirective({
type: _SelectControlValueAccessor,
selectors: [["select", "formControlName", "", 3, "multiple", ""], ["select", "formControl", "", 3, "multiple", ""], ["select", "ngModel", "", 3, "multiple", ""]],
hostBindings: function SelectControlValueAccessor_HostBindings(rf, ctx) {
if (rf & 1) {
\u0275\u0275listener("change", function SelectControlValueAccessor_change_HostBindingHandler($event) {
return ctx.onChange($event.target.value);
})("blur", function SelectControlValueAccessor_blur_HostBindingHandler() {
return ctx.onTouched();
});
}
},
inputs: {
compareWith: "compareWith"
},
features: [\u0275\u0275ProvidersFeature([SELECT_VALUE_ACCESSOR]), \u0275\u0275InheritDefinitionFeature]
});
var SelectControlValueAccessor = _SelectControlValueAccessor;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(SelectControlValueAccessor, [{
type: Directive,
args: [{
selector: "select:not([multiple])[formControlName],select:not([multiple])[formControl],select:not([multiple])[ngModel]",
host: {
"(change)": "onChange($event.target.value)",
"(blur)": "onTouched()"
},
providers: [SELECT_VALUE_ACCESSOR]
}]
}], null, {
compareWith: [{
type: Input
}]
});
})();
var _NgSelectOption = class _NgSelectOption {
constructor(_element, _renderer, _select) {
this._element = _element;
this._renderer = _renderer;
this._select = _select;
if (this._select)
this.id = this._select._registerOption();
}
/**
* @description
* Tracks the value bound to the option element. Unlike the value binding,
* ngValue supports binding to objects.
*/
set ngValue(value2) {
if (this._select == null)
return;
this._select._optionMap.set(this.id, value2);
this._setElementValue(_buildValueString$1(this.id, value2));
this._select.writeValue(this._select.value);
}
/**
* @description
* Tracks simple string values bound to the option element.
* For objects, use the `ngValue` input binding.
*/
set value(value2) {
this._setElementValue(value2);
if (this._select)
this._select.writeValue(this._select.value);
}
/** @internal */
_setElementValue(value2) {
this._renderer.setProperty(this._element.nativeElement, "value", value2);
}
/** @nodoc */
ngOnDestroy() {
if (this._select) {
this._select._optionMap.delete(this.id);
this._select.writeValue(this._select.value);
}
}
};
_NgSelectOption.\u0275fac = function NgSelectOption_Factory(t) {
return new (t || _NgSelectOption)(\u0275\u0275directiveInject(ElementRef), \u0275\u0275directiveInject(Renderer2), \u0275\u0275directiveInject(SelectControlValueAccessor, 9));
};
_NgSelectOption.\u0275dir = /* @__PURE__ */ \u0275\u0275defineDirective({
type: _NgSelectOption,
selectors: [["option"]],
inputs: {
ngValue: "ngValue",
value: "value"
}
});
var NgSelectOption = _NgSelectOption;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(NgSelectOption, [{
type: Directive,
args: [{
selector: "option"
}]
}], () => [{
type: ElementRef
}, {
type: Renderer2
}, {
type: SelectControlValueAccessor,
decorators: [{
type: Optional
}, {
type: Host
}]
}], {
ngValue: [{
type: Input,
args: ["ngValue"]
}],
value: [{
type: Input,
args: ["value"]
}]
});
})();
var SELECT_MULTIPLE_VALUE_ACCESSOR = {
provide: NG_VALUE_ACCESSOR,
useExisting: forwardRef(() => SelectMultipleControlValueAccessor),
multi: true
};
function _buildValueString(id, value2) {
if (id == null)
return `${value2}`;
if (typeof value2 === "string")
value2 = `'${value2}'`;
if (value2 && typeof value2 === "object")
value2 = "Object";
return `${id}: ${value2}`.slice(0, 50);
}
function _extractId(valueString) {
return valueString.split(":")[0];
}
var _SelectMultipleControlValueAccessor = class _SelectMultipleControlValueAccessor extends BuiltInControlValueAccessor {
constructor() {
super(...arguments);
this._optionMap = /* @__PURE__ */ new Map();
this._idCounter = 0;
this._compareWith = Object.is;
}
/**
* @description
* Tracks the option comparison algorithm for tracking identities when
* checking for changes.
*/
set compareWith(fn) {
if (typeof fn !== "function" && (typeof ngDevMode === "undefined" || ngDevMode)) {
throw new RuntimeError(1201, `compareWith must be a function, but received ${JSON.stringify(fn)}`);
}
this._compareWith = fn;
}
/**
* Sets the "value" property on one or of more of the select's options.
* @nodoc
*/
writeValue(value2) {
this.value = value2;
let optionSelectedStateSetter;
if (Array.isArray(value2)) {
const ids = value2.map((v) => this._getOptionId(v));
optionSelectedStateSetter = (opt, o) => {
opt._setSelected(ids.indexOf(o.toString()) > -1);
};
} else {
optionSelectedStateSetter = (opt, o) => {
opt._setSelected(false);
};
}
this._optionMap.forEach(optionSelectedStateSetter);
}
/**
* Registers a function called when the control value changes
* and writes an array of the selected options.
* @nodoc
*/
registerOnChange(fn) {
this.onChange = (element) => {
const selected = [];
const selectedOptions = element.selectedOptions;
if (selectedOptions !== void 0) {
const options = selectedOptions;
for (let i = 0; i < options.length; i++) {
const opt = options[i];
const val2 = this._getOptionValue(opt.value);
selected.push(val2);
}
} else {
const options = element.options;
for (let i = 0; i < options.length; i++) {
const opt = options[i];
if (opt.selected) {
const val2 = this._getOptionValue(opt.value);
selected.push(val2);
}
}
}
this.value = selected;
fn(selected);
};
}
/** @internal */
_registerOption(value2) {
const id = (this._idCounter++).toString();
this._optionMap.set(id, value2);
return id;
}
/** @internal */
_getOptionId(value2) {
for (const id of this._optionMap.keys()) {
if (this._compareWith(this._optionMap.get(id)._value, value2))
return id;
}
return null;
}
/** @internal */
_getOptionValue(valueString) {
const id = _extractId(valueString);
return this._optionMap.has(id) ? this._optionMap.get(id)._value : valueString;
}
};
_SelectMultipleControlValueAccessor.\u0275fac = /* @__PURE__ */ (() => {
let \u0275SelectMultipleControlValueAccessor_BaseFactory;
return function SelectMultipleControlValueAccessor_Factory(t) {
return (\u0275SelectMultipleControlValueAccessor_BaseFactory || (\u0275SelectMultipleControlValueAccessor_BaseFactory = \u0275\u0275getInheritedFactory(_SelectMultipleControlValueAccessor)))(t || _SelectMultipleControlValueAccessor);
};
})();
_SelectMultipleControlValueAccessor.\u0275dir = /* @__PURE__ */ \u0275\u0275defineDirective({
type: _SelectMultipleControlValueAccessor,
selectors: [["select", "multiple", "", "formControlName", ""], ["select", "multiple", "", "formControl", ""], ["select", "multiple", "", "ngModel", ""]],
hostBindings: function SelectMultipleControlValueAccessor_HostBindings(rf, ctx) {
if (rf & 1) {
\u0275\u0275listener("change", function SelectMultipleControlValueAccessor_change_HostBindingHandler($event) {
return ctx.onChange($event.target);
})("blur", function SelectMultipleControlValueAccessor_blur_HostBindingHandler() {
return ctx.onTouched();
});
}
},
inputs: {
compareWith: "compareWith"
},
features: [\u0275\u0275ProvidersFeature([SELECT_MULTIPLE_VALUE_ACCESSOR]), \u0275\u0275InheritDefinitionFeature]
});
var SelectMultipleControlValueAccessor = _SelectMultipleControlValueAccessor;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(SelectMultipleControlValueAccessor, [{
type: Directive,
args: [{
selector: "select[multiple][formControlName],select[multiple][formControl],select[multiple][ngModel]",
host: {
"(change)": "onChange($event.target)",
"(blur)": "onTouched()"
},
providers: [SELECT_MULTIPLE_VALUE_ACCESSOR]
}]
}], null, {
compareWith: [{
type: Input
}]
});
})();
var _\u0275NgSelectMultipleOption = class _\u0275NgSelectMultipleOption {
constructor(_element, _renderer, _select) {
this._element = _element;
this._renderer = _renderer;
this._select = _select;
if (this._select) {
this.id = this._select._registerOption(this);
}
}
/**
* @description
* Tracks the value bound to the option element. Unlike the value binding,
* ngValue supports binding to objects.
*/
set ngValue(value2) {
if (this._select == null)
return;
this._value = value2;
this._setElementValue(_buildValueString(this.id, value2));
this._select.writeValue(this._select.value);
}
/**
* @description
* Tracks simple string values bound to the option element.
* For objects, use the `ngValue` input binding.
*/
set value(value2) {
if (this._select) {
this._value = value2;
this._setElementValue(_buildValueString(this.id, value2));
this._select.writeValue(this._select.value);
} else {
this._setElementValue(value2);
}
}
/** @internal */
_setElementValue(value2) {
this._renderer.setProperty(this._element.nativeElement, "value", value2);
}
/** @internal */
_setSelected(selected) {
this._renderer.setProperty(this._element.nativeElement, "selected", selected);
}
/** @nodoc */
ngOnDestroy() {
if (this._select) {
this._select._optionMap.delete(this.id);
this._select.writeValue(this._select.value);
}
}
};
_\u0275NgSelectMultipleOption.\u0275fac = function \u0275NgSelectMultipleOption_Factory(t) {
return new (t || _\u0275NgSelectMultipleOption)(\u0275\u0275directiveInject(ElementRef), \u0275\u0275directiveInject(Renderer2), \u0275\u0275directiveInject(SelectMultipleControlValueAccessor, 9));
};
_\u0275NgSelectMultipleOption.\u0275dir = /* @__PURE__ */ \u0275\u0275defineDirective({
type: _\u0275NgSelectMultipleOption,
selectors: [["option"]],
inputs: {
ngValue: "ngValue",
value: "value"
}
});
var \u0275NgSelectMultipleOption = _\u0275NgSelectMultipleOption;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(\u0275NgSelectMultipleOption, [{
type: Directive,
args: [{
selector: "option"
}]
}], () => [{
type: ElementRef
}, {
type: Renderer2
}, {
type: SelectMultipleControlValueAccessor,
decorators: [{
type: Optional
}, {
type: Host
}]
}], {
ngValue: [{
type: Input,
args: ["ngValue"]
}],
value: [{
type: Input,
args: ["value"]
}]
});
})();
function toInteger(value2) {
return typeof value2 === "number" ? value2 : parseInt(value2, 10);
}
function toFloat(value2) {
return typeof value2 === "number" ? value2 : parseFloat(value2);
}
var _AbstractValidatorDirective = class _AbstractValidatorDirective {
constructor() {
this._validator = nullValidator;
}
/** @nodoc */
ngOnChanges(changes) {
if (this.inputName in changes) {
const input2 = this.normalizeInput(changes[this.inputName].currentValue);
this._enabled = this.enabled(input2);
this._validator = this._enabled ? this.createValidator(input2) : nullValidator;
if (this._onChange) {
this._onChange();
}
}
}
/** @nodoc */
validate(control) {
return this._validator(control);
}
/** @nodoc */
registerOnValidatorChange(fn) {
this._onChange = fn;
}
/**
* @description
* Determines whether this validator should be active or not based on an input.
* Base class implementation checks whether an input is defined (if the value is different from
* `null` and `undefined`). Validator classes that extend this base class can override this
* function with the logic specific to a particular validator directive.
*/
enabled(input2) {
return input2 != null;
}
};
_AbstractValidatorDirective.\u0275fac = function AbstractValidatorDirective_Factory(t) {
return new (t || _AbstractValidatorDirective)();
};
_AbstractValidatorDirective.\u0275dir = /* @__PURE__ */ \u0275\u0275defineDirective({
type: _AbstractValidatorDirective,
features: [\u0275\u0275NgOnChangesFeature]
});
var AbstractValidatorDirective = _AbstractValidatorDirective;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(AbstractValidatorDirective, [{
type: Directive
}], null, null);
})();
var MAX_VALIDATOR = {
provide: NG_VALIDATORS,
useExisting: forwardRef(() => MaxValidator),
multi: true
};
var _MaxValidator = class _MaxValidator extends AbstractValidatorDirective {
constructor() {
super(...arguments);
this.inputName = "max";
this.normalizeInput = (input2) => toFloat(input2);
this.createValidator = (max) => maxValidator(max);
}
};
_MaxValidator.\u0275fac = /* @__PURE__ */ (() => {
let \u0275MaxValidator_BaseFactory;
return function MaxValidator_Factory(t) {
return (\u0275MaxValidator_BaseFactory || (\u0275MaxValidator_BaseFactory = \u0275\u0275getInheritedFactory(_MaxValidator)))(t || _MaxValidator);
};
})();
_MaxValidator.\u0275dir = /* @__PURE__ */ \u0275\u0275defineDirective({
type: _MaxValidator,
selectors: [["input", "type", "number", "max", "", "formControlName", ""], ["input", "type", "number", "max", "", "formControl", ""], ["input", "type", "number", "max", "", "ngModel", ""]],
hostVars: 1,
hostBindings: function MaxValidator_HostBindings(rf, ctx) {
if (rf & 2) {
\u0275\u0275attribute("max", ctx._enabled ? ctx.max : null);
}
},
inputs: {
max: "max"
},
features: [\u0275\u0275ProvidersFeature([MAX_VALIDATOR]), \u0275\u0275InheritDefinitionFeature]
});
var MaxValidator = _MaxValidator;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(MaxValidator, [{
type: Directive,
args: [{
selector: "input[type=number][max][formControlName],input[type=number][max][formControl],input[type=number][max][ngModel]",
providers: [MAX_VALIDATOR],
host: {
"[attr.max]": "_enabled ? max : null"
}
}]
}], null, {
max: [{
type: Input
}]
});
})();
var MIN_VALIDATOR = {
provide: NG_VALIDATORS,
useExisting: forwardRef(() => MinValidator),
multi: true
};
var _MinValidator = class _MinValidator extends AbstractValidatorDirective {
constructor() {
super(...arguments);
this.inputName = "min";
this.normalizeInput = (input2) => toFloat(input2);
this.createValidator = (min) => minValidator(min);
}
};
_MinValidator.\u0275fac = /* @__PURE__ */ (() => {
let \u0275MinValidator_BaseFactory;
return function MinValidator_Factory(t) {
return (\u0275MinValidator_BaseFactory || (\u0275MinValidator_BaseFactory = \u0275\u0275getInheritedFactory(_MinValidator)))(t || _MinValidator);
};
})();
_MinValidator.\u0275dir = /* @__PURE__ */ \u0275\u0275defineDirective({
type: _MinValidator,
selectors: [["input", "type", "number", "min", "", "formControlName", ""], ["input", "type", "number", "min", "", "formControl", ""], ["input", "type", "number", "min", "", "ngModel", ""]],
hostVars: 1,
hostBindings: function MinValidator_HostBindings(rf, ctx) {
if (rf & 2) {
\u0275\u0275attribute("min", ctx._enabled ? ctx.min : null);
}
},
inputs: {
min: "min"
},
features: [\u0275\u0275ProvidersFeature([MIN_VALIDATOR]), \u0275\u0275InheritDefinitionFeature]
});
var MinValidator = _MinValidator;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(MinValidator, [{
type: Directive,
args: [{
selector: "input[type=number][min][formControlName],input[type=number][min][formControl],input[type=number][min][ngModel]",
providers: [MIN_VALIDATOR],
host: {
"[attr.min]": "_enabled ? min : null"
}
}]
}], null, {
min: [{
type: Input
}]
});
})();
var REQUIRED_VALIDATOR = {
provide: NG_VALIDATORS,
useExisting: forwardRef(() => RequiredValidator),
multi: true
};
var CHECKBOX_REQUIRED_VALIDATOR = {
provide: NG_VALIDATORS,
useExisting: forwardRef(() => CheckboxRequiredValidator),
multi: true
};
var _RequiredValidator = class _RequiredValidator extends AbstractValidatorDirective {
constructor() {
super(...arguments);
this.inputName = "required";
this.normalizeInput = booleanAttribute;
this.createValidator = (input2) => requiredValidator;
}
/** @nodoc */
enabled(input2) {
return input2;
}
};
_RequiredValidator.\u0275fac = /* @__PURE__ */ (() => {
let \u0275RequiredValidator_BaseFactory;
return function RequiredValidator_Factory(t) {
return (\u0275RequiredValidator_BaseFactory || (\u0275RequiredValidator_BaseFactory = \u0275\u0275getInheritedFactory(_RequiredValidator)))(t || _RequiredValidator);
};
})();
_RequiredValidator.\u0275dir = /* @__PURE__ */ \u0275\u0275defineDirective({
type: _RequiredValidator,
selectors: [["", "required", "", "formControlName", "", 3, "type", "checkbox"], ["", "required", "", "formControl", "", 3, "type", "checkbox"], ["", "required", "", "ngModel", "", 3, "type", "checkbox"]],
hostVars: 1,
hostBindings: function RequiredValidator_HostBindings(rf, ctx) {
if (rf & 2) {
\u0275\u0275attribute("required", ctx._enabled ? "" : null);
}
},
inputs: {
required: "required"
},
features: [\u0275\u0275ProvidersFeature([REQUIRED_VALIDATOR]), \u0275\u0275InheritDefinitionFeature]
});
var RequiredValidator = _RequiredValidator;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(RequiredValidator, [{
type: Directive,
args: [{
selector: ":not([type=checkbox])[required][formControlName],:not([type=checkbox])[required][formControl],:not([type=checkbox])[required][ngModel]",
providers: [REQUIRED_VALIDATOR],
host: {
"[attr.required]": '_enabled ? "" : null'
}
}]
}], null, {
required: [{
type: Input
}]
});
})();
var _CheckboxRequiredValidator = class _CheckboxRequiredValidator extends RequiredValidator {
constructor() {
super(...arguments);
this.createValidator = (input2) => requiredTrueValidator;
}
};
_CheckboxRequiredValidator.\u0275fac = /* @__PURE__ */ (() => {
let \u0275CheckboxRequiredValidator_BaseFactory;
return function CheckboxRequiredValidator_Factory(t) {
return (\u0275CheckboxRequiredValidator_BaseFactory || (\u0275CheckboxRequiredValidator_BaseFactory = \u0275\u0275getInheritedFactory(_CheckboxRequiredValidator)))(t || _CheckboxRequiredValidator);
};
})();
_CheckboxRequiredValidator.\u0275dir = /* @__PURE__ */ \u0275\u0275defineDirective({
type: _CheckboxRequiredValidator,
selectors: [["input", "type", "checkbox", "required", "", "formControlName", ""], ["input", "type", "checkbox", "required", "", "formControl", ""], ["input", "type", "checkbox", "required", "", "ngModel", ""]],
hostVars: 1,
hostBindings: function CheckboxRequiredValidator_HostBindings(rf, ctx) {
if (rf & 2) {
\u0275\u0275attribute("required", ctx._enabled ? "" : null);
}
},
features: [\u0275\u0275ProvidersFeature([CHECKBOX_REQUIRED_VALIDATOR]), \u0275\u0275InheritDefinitionFeature]
});
var CheckboxRequiredValidator = _CheckboxRequiredValidator;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(CheckboxRequiredValidator, [{
type: Directive,
args: [{
selector: "input[type=checkbox][required][formControlName],input[type=checkbox][required][formControl],input[type=checkbox][required][ngModel]",
providers: [CHECKBOX_REQUIRED_VALIDATOR],
host: {
"[attr.required]": '_enabled ? "" : null'
}
}]
}], null, null);
})();
var EMAIL_VALIDATOR = {
provide: NG_VALIDATORS,
useExisting: forwardRef(() => EmailValidator),
multi: true
};
var _EmailValidator = class _EmailValidator extends AbstractValidatorDirective {
constructor() {
super(...arguments);
this.inputName = "email";
this.normalizeInput = booleanAttribute;
this.createValidator = (input2) => emailValidator;
}
/** @nodoc */
enabled(input2) {
return input2;
}
};
_EmailValidator.\u0275fac = /* @__PURE__ */ (() => {
let \u0275EmailValidator_BaseFactory;
return function EmailValidator_Factory(t) {
return (\u0275EmailValidator_BaseFactory || (\u0275EmailValidator_BaseFactory = \u0275\u0275getInheritedFactory(_EmailValidator)))(t || _EmailValidator);
};
})();
_EmailValidator.\u0275dir = /* @__PURE__ */ \u0275\u0275defineDirective({
type: _EmailValidator,
selectors: [["", "email", "", "formControlName", ""], ["", "email", "", "formControl", ""], ["", "email", "", "ngModel", ""]],
inputs: {
email: "email"
},
features: [\u0275\u0275ProvidersFeature([EMAIL_VALIDATOR]), \u0275\u0275InheritDefinitionFeature]
});
var EmailValidator = _EmailValidator;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(EmailValidator, [{
type: Directive,
args: [{
selector: "[email][formControlName],[email][formControl],[email][ngModel]",
providers: [EMAIL_VALIDATOR]
}]
}], null, {
email: [{
type: Input
}]
});
})();
var MIN_LENGTH_VALIDATOR = {
provide: NG_VALIDATORS,
useExisting: forwardRef(() => MinLengthValidator),
multi: true
};
var _MinLengthValidator = class _MinLengthValidator extends AbstractValidatorDirective {
constructor() {
super(...arguments);
this.inputName = "minlength";
this.normalizeInput = (input2) => toInteger(input2);
this.createValidator = (minlength) => minLengthValidator(minlength);
}
};
_MinLengthValidator.\u0275fac = /* @__PURE__ */ (() => {
let \u0275MinLengthValidator_BaseFactory;
return function MinLengthValidator_Factory(t) {
return (\u0275MinLengthValidator_BaseFactory || (\u0275MinLengthValidator_BaseFactory = \u0275\u0275getInheritedFactory(_MinLengthValidator)))(t || _MinLengthValidator);
};
})();
_MinLengthValidator.\u0275dir = /* @__PURE__ */ \u0275\u0275defineDirective({
type: _MinLengthValidator,
selectors: [["", "minlength", "", "formControlName", ""], ["", "minlength", "", "formControl", ""], ["", "minlength", "", "ngModel", ""]],
hostVars: 1,
hostBindings: function MinLengthValidator_HostBindings(rf, ctx) {
if (rf & 2) {
\u0275\u0275attribute("minlength", ctx._enabled ? ctx.minlength : null);
}
},
inputs: {
minlength: "minlength"
},
features: [\u0275\u0275ProvidersFeature([MIN_LENGTH_VALIDATOR]), \u0275\u0275InheritDefinitionFeature]
});
var MinLengthValidator = _MinLengthValidator;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(MinLengthValidator, [{
type: Directive,
args: [{
selector: "[minlength][formControlName],[minlength][formControl],[minlength][ngModel]",
providers: [MIN_LENGTH_VALIDATOR],
host: {
"[attr.minlength]": "_enabled ? minlength : null"
}
}]
}], null, {
minlength: [{
type: Input
}]
});
})();
var MAX_LENGTH_VALIDATOR = {
provide: NG_VALIDATORS,
useExisting: forwardRef(() => MaxLengthValidator),
multi: true
};
var _MaxLengthValidator = class _MaxLengthValidator extends AbstractValidatorDirective {
constructor() {
super(...arguments);
this.inputName = "maxlength";
this.normalizeInput = (input2) => toInteger(input2);
this.createValidator = (maxlength) => maxLengthValidator(maxlength);
}
};
_MaxLengthValidator.\u0275fac = /* @__PURE__ */ (() => {
let \u0275MaxLengthValidator_BaseFactory;
return function MaxLengthValidator_Factory(t) {
return (\u0275MaxLengthValidator_BaseFactory || (\u0275MaxLengthValidator_BaseFactory = \u0275\u0275getInheritedFactory(_MaxLengthValidator)))(t || _MaxLengthValidator);
};
})();
_MaxLengthValidator.\u0275dir = /* @__PURE__ */ \u0275\u0275defineDirective({
type: _MaxLengthValidator,
selectors: [["", "maxlength", "", "formControlName", ""], ["", "maxlength", "", "formControl", ""], ["", "maxlength", "", "ngModel", ""]],
hostVars: 1,
hostBindings: function MaxLengthValidator_HostBindings(rf, ctx) {
if (rf & 2) {
\u0275\u0275attribute("maxlength", ctx._enabled ? ctx.maxlength : null);
}
},
inputs: {
maxlength: "maxlength"
},
features: [\u0275\u0275ProvidersFeature([MAX_LENGTH_VALIDATOR]), \u0275\u0275InheritDefinitionFeature]
});
var MaxLengthValidator = _MaxLengthValidator;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(MaxLengthValidator, [{
type: Directive,
args: [{
selector: "[maxlength][formControlName],[maxlength][formControl],[maxlength][ngModel]",
providers: [MAX_LENGTH_VALIDATOR],
host: {
"[attr.maxlength]": "_enabled ? maxlength : null"
}
}]
}], null, {
maxlength: [{
type: Input
}]
});
})();
var PATTERN_VALIDATOR = {
provide: NG_VALIDATORS,
useExisting: forwardRef(() => PatternValidator),
multi: true
};
var _PatternValidator = class _PatternValidator extends AbstractValidatorDirective {
constructor() {
super(...arguments);
this.inputName = "pattern";
this.normalizeInput = (input2) => input2;
this.createValidator = (input2) => patternValidator(input2);
}
};
_PatternValidator.\u0275fac = /* @__PURE__ */ (() => {
let \u0275PatternValidator_BaseFactory;
return function PatternValidator_Factory(t) {
return (\u0275PatternValidator_BaseFactory || (\u0275PatternValidator_BaseFactory = \u0275\u0275getInheritedFactory(_PatternValidator)))(t || _PatternValidator);
};
})();
_PatternValidator.\u0275dir = /* @__PURE__ */ \u0275\u0275defineDirective({
type: _PatternValidator,
selectors: [["", "pattern", "", "formControlName", ""], ["", "pattern", "", "formControl", ""], ["", "pattern", "", "ngModel", ""]],
hostVars: 1,
hostBindings: function PatternValidator_HostBindings(rf, ctx) {
if (rf & 2) {
\u0275\u0275attribute("pattern", ctx._enabled ? ctx.pattern : null);
}
},
inputs: {
pattern: "pattern"
},
features: [\u0275\u0275ProvidersFeature([PATTERN_VALIDATOR]), \u0275\u0275InheritDefinitionFeature]
});
var PatternValidator = _PatternValidator;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(PatternValidator, [{
type: Directive,
args: [{
selector: "[pattern][formControlName],[pattern][formControl],[pattern][ngModel]",
providers: [PATTERN_VALIDATOR],
host: {
"[attr.pattern]": "_enabled ? pattern : null"
}
}]
}], null, {
pattern: [{
type: Input
}]
});
})();
var SHARED_FORM_DIRECTIVES = [\u0275NgNoValidate, NgSelectOption, \u0275NgSelectMultipleOption, DefaultValueAccessor, NumberValueAccessor, RangeValueAccessor, CheckboxControlValueAccessor, SelectControlValueAccessor, SelectMultipleControlValueAccessor, RadioControlValueAccessor, NgControlStatus, NgControlStatusGroup, RequiredValidator, MinLengthValidator, MaxLengthValidator, PatternValidator, CheckboxRequiredValidator, EmailValidator, MinValidator, MaxValidator];
var TEMPLATE_DRIVEN_DIRECTIVES = [NgModel, NgModelGroup, NgForm];
var REACTIVE_DRIVEN_DIRECTIVES = [FormControlDirective, FormGroupDirective, FormControlName, FormGroupName, FormArrayName];
var _\u0275InternalFormsSharedModule = class _\u0275InternalFormsSharedModule {
};
_\u0275InternalFormsSharedModule.\u0275fac = function \u0275InternalFormsSharedModule_Factory(t) {
return new (t || _\u0275InternalFormsSharedModule)();
};
_\u0275InternalFormsSharedModule.\u0275mod = /* @__PURE__ */ \u0275\u0275defineNgModule({
type: _\u0275InternalFormsSharedModule
});
_\u0275InternalFormsSharedModule.\u0275inj = /* @__PURE__ */ \u0275\u0275defineInjector({});
var \u0275InternalFormsSharedModule = _\u0275InternalFormsSharedModule;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(\u0275InternalFormsSharedModule, [{
type: NgModule,
args: [{
declarations: SHARED_FORM_DIRECTIVES,
exports: SHARED_FORM_DIRECTIVES
}]
}], null, null);
})();
var FormArray = class extends AbstractControl {
/**
* Creates a new `FormArray` instance.
*
* @param controls An array of child controls. Each child control is given an index
* where it is registered.
*
* @param validatorOrOpts A synchronous validator function, or an array of
* such functions, or an `AbstractControlOptions` object that contains validation functions
* and a validation trigger.
*
* @param asyncValidator A single async validator or array of async validator functions
*
*/
constructor(controls, validatorOrOpts, asyncValidator) {
super(pickValidators(validatorOrOpts), pickAsyncValidators(asyncValidator, validatorOrOpts));
this.controls = controls;
this._initObservables();
this._setUpdateStrategy(validatorOrOpts);
this._setUpControls();
this.updateValueAndValidity({
onlySelf: true,
// If `asyncValidator` is present, it will trigger control status change from `PENDING` to
// `VALID` or `INVALID`.
// The status should be broadcasted via the `statusChanges` observable, so we set `emitEvent`
// to `true` to allow that during the control creation process.
emitEvent: !!this.asyncValidator
});
}
/**
* Get the `AbstractControl` at the given `index` in the array.
*
* @param index Index in the array to retrieve the control. If `index` is negative, it will wrap
* around from the back, and if index is greatly negative (less than `-length`), the result is
* undefined. This behavior is the same as `Array.at(index)`.
*/
at(index2) {
return this.controls[this._adjustIndex(index2)];
}
/**
* Insert a new `AbstractControl` at the end of the array.
*
* @param control Form control to be inserted
* @param options Specifies whether this FormArray instance should emit events after a new
* control is added.
* * `emitEvent`: When true or not supplied (the default), both the `statusChanges` and
* `valueChanges` observables emit events with the latest status and value when the control is
* inserted. When false, no events are emitted.
*/
push(control, options = {}) {
this.controls.push(control);
this._registerControl(control);
this.updateValueAndValidity({
emitEvent: options.emitEvent
});
this._onCollectionChange();
}
/**
* Insert a new `AbstractControl` at the given `index` in the array.
*
* @param index Index in the array to insert the control. If `index` is negative, wraps around
* from the back. If `index` is greatly negative (less than `-length`), prepends to the array.
* This behavior is the same as `Array.splice(index, 0, control)`.
* @param control Form control to be inserted
* @param options Specifies whether this FormArray instance should emit events after a new
* control is inserted.
* * `emitEvent`: When true or not supplied (the default), both the `statusChanges` and
* `valueChanges` observables emit events with the latest status and value when the control is
* inserted. When false, no events are emitted.
*/
insert(index2, control, options = {}) {
this.controls.splice(index2, 0, control);
this._registerControl(control);
this.updateValueAndValidity({
emitEvent: options.emitEvent
});
}
/**
* Remove the control at the given `index` in the array.
*
* @param index Index in the array to remove the control. If `index` is negative, wraps around
* from the back. If `index` is greatly negative (less than `-length`), removes the first
* element. This behavior is the same as `Array.splice(index, 1)`.
* @param options Specifies whether this FormArray instance should emit events after a
* control is removed.
* * `emitEvent`: When true or not supplied (the default), both the `statusChanges` and
* `valueChanges` observables emit events with the latest status and value when the control is
* removed. When false, no events are emitted.
*/
removeAt(index2, options = {}) {
let adjustedIndex = this._adjustIndex(index2);
if (adjustedIndex < 0)
adjustedIndex = 0;
if (this.controls[adjustedIndex])
this.controls[adjustedIndex]._registerOnCollectionChange(() => {
});
this.controls.splice(adjustedIndex, 1);
this.updateValueAndValidity({
emitEvent: options.emitEvent
});
}
/**
* Replace an existing control.
*
* @param index Index in the array to replace the control. If `index` is negative, wraps around
* from the back. If `index` is greatly negative (less than `-length`), replaces the first
* element. This behavior is the same as `Array.splice(index, 1, control)`.
* @param control The `AbstractControl` control to replace the existing control
* @param options Specifies whether this FormArray instance should emit events after an
* existing control is replaced with a new one.
* * `emitEvent`: When true or not supplied (the default), both the `statusChanges` and
* `valueChanges` observables emit events with the latest status and value when the control is
* replaced with a new one. When false, no events are emitted.
*/
setControl(index2, control, options = {}) {
let adjustedIndex = this._adjustIndex(index2);
if (adjustedIndex < 0)
adjustedIndex = 0;
if (this.controls[adjustedIndex])
this.controls[adjustedIndex]._registerOnCollectionChange(() => {
});
this.controls.splice(adjustedIndex, 1);
if (control) {
this.controls.splice(adjustedIndex, 0, control);
this._registerControl(control);
}
this.updateValueAndValidity({
emitEvent: options.emitEvent
});
this._onCollectionChange();
}
/**
* Length of the control array.
*/
get length() {
return this.controls.length;
}
/**
* Sets the value of the `FormArray`. It accepts an array that matches
* the structure of the control.
*
* This method performs strict checks, and throws an error if you try
* to set the value of a control that doesn't exist or if you exclude the
* value of a control.
*
* @usageNotes
* ### Set the values for the controls in the form array
*
* ```
* const arr = new FormArray([
* new FormControl(),
* new FormControl()
* ]);
* console.log(arr.value); // [null, null]
*
* arr.setValue(['Nancy', 'Drew']);
* console.log(arr.value); // ['Nancy', 'Drew']
* ```
*
* @param value Array of values for the controls
* @param options Configure options that determine how the control propagates changes and
* emits events after the value changes
*
* * `onlySelf`: When true, each change only affects this control, and not its parent. Default
* is false.
* * `emitEvent`: When true or not supplied (the default), both the `statusChanges` and
* `valueChanges`
* observables emit events with the latest status and value when the control value is updated.
* When false, no events are emitted.
* The configuration options are passed to the {@link AbstractControl#updateValueAndValidity
* updateValueAndValidity} method.
*/
setValue(value2, options = {}) {
assertAllValuesPresent(this, false, value2);
value2.forEach((newValue, index2) => {
assertControlPresent(this, false, index2);
this.at(index2).setValue(newValue, {
onlySelf: true,
emitEvent: options.emitEvent
});
});
this.updateValueAndValidity(options);
}
/**
* Patches the value of the `FormArray`. It accepts an array that matches the
* structure of the control, and does its best to match the values to the correct
* controls in the group.
*
* It accepts both super-sets and sub-sets of the array without throwing an error.
*
* @usageNotes
* ### Patch the values for controls in a form array
*
* ```
* const arr = new FormArray([
* new FormControl(),
* new FormControl()
* ]);
* console.log(arr.value); // [null, null]
*
* arr.patchValue(['Nancy']);
* console.log(arr.value); // ['Nancy', null]
* ```
*
* @param value Array of latest values for the controls
* @param options Configure options that determine how the control propagates changes and
* emits events after the value changes
*
* * `onlySelf`: When true, each change only affects this control, and not its parent. Default
* is false.
* * `emitEvent`: When true or not supplied (the default), both the `statusChanges` and
* `valueChanges` observables emit events with the latest status and value when the control
* value is updated. When false, no events are emitted. The configuration options are passed to
* the {@link AbstractControl#updateValueAndValidity updateValueAndValidity} method.
*/
patchValue(value2, options = {}) {
if (value2 == null)
return;
value2.forEach((newValue, index2) => {
if (this.at(index2)) {
this.at(index2).patchValue(newValue, {
onlySelf: true,
emitEvent: options.emitEvent
});
}
});
this.updateValueAndValidity(options);
}
/**
* Resets the `FormArray` and all descendants are marked `pristine` and `untouched`, and the
* value of all descendants to null or null maps.
*
* You reset to a specific form state by passing in an array of states
* that matches the structure of the control. The state is a standalone value
* or a form state object with both a value and a disabled status.
*
* @usageNotes
* ### Reset the values in a form array
*
* ```ts
* const arr = new FormArray([
* new FormControl(),
* new FormControl()
* ]);
* arr.reset(['name', 'last name']);
*
* console.log(arr.value); // ['name', 'last name']
* ```
*
* ### Reset the values in a form array and the disabled status for the first control
*
* ```
* arr.reset([
* {value: 'name', disabled: true},
* 'last'
* ]);
*
* console.log(arr.value); // ['last']
* console.log(arr.at(0).status); // 'DISABLED'
* ```
*
* @param value Array of values for the controls
* @param options Configure options that determine how the control propagates changes and
* emits events after the value changes
*
* * `onlySelf`: When true, each change only affects this control, and not its parent. Default
* is false.
* * `emitEvent`: When true or not supplied (the default), both the `statusChanges` and
* `valueChanges`
* observables emit events with the latest status and value when the control is reset.
* When false, no events are emitted.
* The configuration options are passed to the {@link AbstractControl#updateValueAndValidity
* updateValueAndValidity} method.
*/
reset(value2 = [], options = {}) {
this._forEachChild((control, index2) => {
control.reset(value2[index2], {
onlySelf: true,
emitEvent: options.emitEvent
});
});
this._updatePristine(options);
this._updateTouched(options);
this.updateValueAndValidity(options);
}
/**
* The aggregate value of the array, including any disabled controls.
*
* Reports all values regardless of disabled status.
*/
getRawValue() {
return this.controls.map((control) => control.getRawValue());
}
/**
* Remove all controls in the `FormArray`.
*
* @param options Specifies whether this FormArray instance should emit events after all
* controls are removed.
* * `emitEvent`: When true or not supplied (the default), both the `statusChanges` and
* `valueChanges` observables emit events with the latest status and value when all controls
* in this FormArray instance are removed. When false, no events are emitted.
*
* @usageNotes
* ### Remove all elements from a FormArray
*
* ```ts
* const arr = new FormArray([
* new FormControl(),
* new FormControl()
* ]);
* console.log(arr.length); // 2
*
* arr.clear();
* console.log(arr.length); // 0
* ```
*
* It's a simpler and more efficient alternative to removing all elements one by one:
*
* ```ts
* const arr = new FormArray([
* new FormControl(),
* new FormControl()
* ]);
*
* while (arr.length) {
* arr.removeAt(0);
* }
* ```
*/
clear(options = {}) {
if (this.controls.length < 1)
return;
this._forEachChild((control) => control._registerOnCollectionChange(() => {
}));
this.controls.splice(0);
this.updateValueAndValidity({
emitEvent: options.emitEvent
});
}
/**
* Adjusts a negative index by summing it with the length of the array. For very negative
* indices, the result may remain negative.
* @internal
*/
_adjustIndex(index2) {
return index2 < 0 ? index2 + this.length : index2;
}
/** @internal */
_syncPendingControls() {
let subtreeUpdated = this.controls.reduce((updated, child) => {
return child._syncPendingControls() ? true : updated;
}, false);
if (subtreeUpdated)
this.updateValueAndValidity({
onlySelf: true
});
return subtreeUpdated;
}
/** @internal */
_forEachChild(cb) {
this.controls.forEach((control, index2) => {
cb(control, index2);
});
}
/** @internal */
_updateValue() {
this.value = this.controls.filter((control) => control.enabled || this.disabled).map((control) => control.value);
}
/** @internal */
_anyControls(condition) {
return this.controls.some((control) => control.enabled && condition(control));
}
/** @internal */
_setUpControls() {
this._forEachChild((control) => this._registerControl(control));
}
/** @internal */
_allControlsDisabled() {
for (const control of this.controls) {
if (control.enabled)
return false;
}
return this.controls.length > 0 || this.disabled;
}
_registerControl(control) {
control.setParent(this);
control._registerOnCollectionChange(this._onCollectionChange);
}
/** @internal */
_find(name2) {
return this.at(name2) ?? null;
}
};
function isAbstractControlOptions(options) {
return !!options && (options.asyncValidators !== void 0 || options.validators !== void 0 || options.updateOn !== void 0);
}
var _FormBuilder = class _FormBuilder {
constructor() {
this.useNonNullable = false;
}
/**
* @description
* Returns a FormBuilder in which automatically constructed `FormControl` elements
* have `{nonNullable: true}` and are non-nullable.
*
* **Constructing non-nullable controls**
*
* When constructing a control, it will be non-nullable, and will reset to its initial value.
*
* ```ts
* let nnfb = new FormBuilder().nonNullable;
* let name = nnfb.control('Alex'); // FormControl<string>
* name.reset();
* console.log(name); // 'Alex'
* ```
*
* **Constructing non-nullable groups or arrays**
*
* When constructing a group or array, all automatically created inner controls will be
* non-nullable, and will reset to their initial values.
*
* ```ts
* let nnfb = new FormBuilder().nonNullable;
* let name = nnfb.group({who: 'Alex'}); // FormGroup<{who: FormControl<string>}>
* name.reset();
* console.log(name); // {who: 'Alex'}
* ```
* **Constructing *nullable* fields on groups or arrays**
*
* It is still possible to have a nullable field. In particular, any `FormControl` which is
* *already* constructed will not be altered. For example:
*
* ```ts
* let nnfb = new FormBuilder().nonNullable;
* // FormGroup<{who: FormControl<string|null>}>
* let name = nnfb.group({who: new FormControl('Alex')});
* name.reset(); console.log(name); // {who: null}
* ```
*
* Because the inner control is constructed explicitly by the caller, the builder has
* no control over how it is created, and cannot exclude the `null`.
*/
get nonNullable() {
const nnfb = new _FormBuilder();
nnfb.useNonNullable = true;
return nnfb;
}
group(controls, options = null) {
const reducedControls = this._reduceControls(controls);
let newOptions = {};
if (isAbstractControlOptions(options)) {
newOptions = options;
} else if (options !== null) {
newOptions.validators = options.validator;
newOptions.asyncValidators = options.asyncValidator;
}
return new FormGroup(reducedControls, newOptions);
}
/**
* @description
* Constructs a new `FormRecord` instance. Accepts a single generic argument, which is an object
* containing all the keys and corresponding inner control types.
*
* @param controls A collection of child controls. The key for each child is the name
* under which it is registered.
*
* @param options Configuration options object for the `FormRecord`. The object should have the
* `AbstractControlOptions` type and might contain the following fields:
* * `validators`: A synchronous validator function, or an array of validator functions.
* * `asyncValidators`: A single async validator or array of async validator functions.
* * `updateOn`: The event upon which the control should be updated (options: 'change' | 'blur'
* | submit').
*/
record(controls, options = null) {
const reducedControls = this._reduceControls(controls);
return new FormRecord(reducedControls, options);
}
/**
* @description
* Constructs a new `FormControl` with the given state, validators and options. Sets
* `{nonNullable: true}` in the options to get a non-nullable control. Otherwise, the
* control will be nullable. Accepts a single generic argument, which is the type of the
* control's value.
*
* @param formState Initializes the control with an initial state value, or
* with an object that contains both a value and a disabled status.
*
* @param validatorOrOpts A synchronous validator function, or an array of
* such functions, or a `FormControlOptions` object that contains
* validation functions and a validation trigger.
*
* @param asyncValidator A single async validator or array of async validator
* functions.
*
* @usageNotes
*
* ### Initialize a control as disabled
*
* The following example returns a control with an initial value in a disabled state.
*
* <code-example path="forms/ts/formBuilder/form_builder_example.ts" region="disabled-control">
* </code-example>
*/
control(formState, validatorOrOpts, asyncValidator) {
let newOptions = {};
if (!this.useNonNullable) {
return new FormControl(formState, validatorOrOpts, asyncValidator);
}
if (isAbstractControlOptions(validatorOrOpts)) {
newOptions = validatorOrOpts;
} else {
newOptions.validators = validatorOrOpts;
newOptions.asyncValidators = asyncValidator;
}
return new FormControl(formState, __spreadProps(__spreadValues({}, newOptions), {
nonNullable: true
}));
}
/**
* Constructs a new `FormArray` from the given array of configurations,
* validators and options. Accepts a single generic argument, which is the type of each control
* inside the array.
*
* @param controls An array of child controls or control configs. Each child control is given an
* index when it is registered.
*
* @param validatorOrOpts A synchronous validator function, or an array of such functions, or an
* `AbstractControlOptions` object that contains
* validation functions and a validation trigger.
*
* @param asyncValidator A single async validator or array of async validator functions.
*/
array(controls, validatorOrOpts, asyncValidator) {
const createdControls = controls.map((c) => this._createControl(c));
return new FormArray(createdControls, validatorOrOpts, asyncValidator);
}
/** @internal */
_reduceControls(controls) {
const createdControls = {};
Object.keys(controls).forEach((controlName) => {
createdControls[controlName] = this._createControl(controls[controlName]);
});
return createdControls;
}
/** @internal */
_createControl(controls) {
if (controls instanceof FormControl) {
return controls;
} else if (controls instanceof AbstractControl) {
return controls;
} else if (Array.isArray(controls)) {
const value2 = controls[0];
const validator = controls.length > 1 ? controls[1] : null;
const asyncValidator = controls.length > 2 ? controls[2] : null;
return this.control(value2, validator, asyncValidator);
} else {
return this.control(controls);
}
}
};
_FormBuilder.\u0275fac = function FormBuilder_Factory(t) {
return new (t || _FormBuilder)();
};
_FormBuilder.\u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
token: _FormBuilder,
factory: _FormBuilder.\u0275fac,
providedIn: "root"
});
var FormBuilder = _FormBuilder;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(FormBuilder, [{
type: Injectable,
args: [{
providedIn: "root"
}]
}], null, null);
})();
var _NonNullableFormBuilder = class _NonNullableFormBuilder {
};
_NonNullableFormBuilder.\u0275fac = function NonNullableFormBuilder_Factory(t) {
return new (t || _NonNullableFormBuilder)();
};
_NonNullableFormBuilder.\u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
token: _NonNullableFormBuilder,
factory: () => (() => inject(FormBuilder).nonNullable)(),
providedIn: "root"
});
var NonNullableFormBuilder = _NonNullableFormBuilder;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(NonNullableFormBuilder, [{
type: Injectable,
args: [{
providedIn: "root",
useFactory: () => inject(FormBuilder).nonNullable
}]
}], null, null);
})();
var _UntypedFormBuilder = class _UntypedFormBuilder extends FormBuilder {
group(controlsConfig, options = null) {
return super.group(controlsConfig, options);
}
/**
* Like `FormBuilder#control`, except the resulting control is untyped.
*/
control(formState, validatorOrOpts, asyncValidator) {
return super.control(formState, validatorOrOpts, asyncValidator);
}
/**
* Like `FormBuilder#array`, except the resulting array is untyped.
*/
array(controlsConfig, validatorOrOpts, asyncValidator) {
return super.array(controlsConfig, validatorOrOpts, asyncValidator);
}
};
_UntypedFormBuilder.\u0275fac = /* @__PURE__ */ (() => {
let \u0275UntypedFormBuilder_BaseFactory;
return function UntypedFormBuilder_Factory(t) {
return (\u0275UntypedFormBuilder_BaseFactory || (\u0275UntypedFormBuilder_BaseFactory = \u0275\u0275getInheritedFactory(_UntypedFormBuilder)))(t || _UntypedFormBuilder);
};
})();
_UntypedFormBuilder.\u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
token: _UntypedFormBuilder,
factory: _UntypedFormBuilder.\u0275fac,
providedIn: "root"
});
var UntypedFormBuilder = _UntypedFormBuilder;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(UntypedFormBuilder, [{
type: Injectable,
args: [{
providedIn: "root"
}]
}], null, null);
})();
var VERSION5 = new Version("17.3.12");
var _FormsModule = class _FormsModule {
/**
* @description
* Provides options for configuring the forms module.
*
* @param opts An object of configuration options
* * `callSetDisabledState` Configures whether to `always` call `setDisabledState`, which is more
* correct, or to only call it `whenDisabled`, which is the legacy behavior.
*/
static withConfig(opts) {
return {
ngModule: _FormsModule,
providers: [{
provide: CALL_SET_DISABLED_STATE,
useValue: opts.callSetDisabledState ?? setDisabledStateDefault
}]
};
}
};
_FormsModule.\u0275fac = function FormsModule_Factory(t) {
return new (t || _FormsModule)();
};
_FormsModule.\u0275mod = /* @__PURE__ */ \u0275\u0275defineNgModule({
type: _FormsModule
});
_FormsModule.\u0275inj = /* @__PURE__ */ \u0275\u0275defineInjector({
imports: [\u0275InternalFormsSharedModule]
});
var FormsModule = _FormsModule;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(FormsModule, [{
type: NgModule,
args: [{
declarations: TEMPLATE_DRIVEN_DIRECTIVES,
exports: [\u0275InternalFormsSharedModule, TEMPLATE_DRIVEN_DIRECTIVES]
}]
}], null, null);
})();
var _ReactiveFormsModule = class _ReactiveFormsModule {
/**
* @description
* Provides options for configuring the reactive forms module.
*
* @param opts An object of configuration options
* * `warnOnNgModelWithFormControl` Configures when to emit a warning when an `ngModel`
* binding is used with reactive form directives.
* * `callSetDisabledState` Configures whether to `always` call `setDisabledState`, which is more
* correct, or to only call it `whenDisabled`, which is the legacy behavior.
*/
static withConfig(opts) {
return {
ngModule: _ReactiveFormsModule,
providers: [{
provide: NG_MODEL_WITH_FORM_CONTROL_WARNING,
useValue: opts.warnOnNgModelWithFormControl ?? "always"
}, {
provide: CALL_SET_DISABLED_STATE,
useValue: opts.callSetDisabledState ?? setDisabledStateDefault
}]
};
}
};
_ReactiveFormsModule.\u0275fac = function ReactiveFormsModule_Factory(t) {
return new (t || _ReactiveFormsModule)();
};
_ReactiveFormsModule.\u0275mod = /* @__PURE__ */ \u0275\u0275defineNgModule({
type: _ReactiveFormsModule
});
_ReactiveFormsModule.\u0275inj = /* @__PURE__ */ \u0275\u0275defineInjector({
imports: [\u0275InternalFormsSharedModule]
});
var ReactiveFormsModule = _ReactiveFormsModule;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(ReactiveFormsModule, [{
type: NgModule,
args: [{
declarations: [REACTIVE_DRIVEN_DIRECTIVES],
exports: [\u0275InternalFormsSharedModule, REACTIVE_DRIVEN_DIRECTIVES]
}]
}], null, null);
})();
// src/app/shared/components/input-field/input-field.component.ts
function InputFieldComponent_div_4_Template(rf, ctx) {
if (rf & 1) {
\u0275\u0275elementStart(0, "div", 4);
\u0275\u0275text(1);
\u0275\u0275elementEnd();
}
if (rf & 2) {
const ctx_r0 = \u0275\u0275nextContext();
\u0275\u0275advance();
\u0275\u0275textInterpolate1("\n", ctx_r0.errorMessage, "\n");
}
}
var _InputFieldComponent = class _InputFieldComponent {
constructor() {
this.label = "";
this.placeholder = "";
this.value = "";
this.errorMessage = "Invalid input";
this.pattern = ".*";
this.maxLength = null;
this.startValidate = false;
this.valueChange = new EventEmitter();
this.isFocused = false;
}
onInputChange(newValue) {
this.value = newValue;
this.valueChange.emit(newValue);
}
// Validates the input value
isValid() {
const regex = new RegExp(this.pattern);
return regex.test(this.value);
}
};
_InputFieldComponent.\u0275fac = function InputFieldComponent_Factory(t) {
return new (t || _InputFieldComponent)();
};
_InputFieldComponent.\u0275cmp = /* @__PURE__ */ \u0275\u0275defineComponent({ type: _InputFieldComponent, selectors: [["app-input-field"]], inputs: { label: "label", placeholder: "placeholder", value: "value", errorMessage: "errorMessage", pattern: "pattern", maxLength: "maxLength", startValidate: "startValidate" }, outputs: { valueChange: "valueChange" }, standalone: true, features: [\u0275\u0275StandaloneFeature], decls: 5, vars: 14, consts: [[1, "relative", "w-[25rem]", "lg:w-screen", "max-w-[80vw]", "lg:max-w-[35vw]", "px-6", "py-3", "rounded-3xl", "shadow-sm", "bg-white"], ["for", "input", 1, "absolute", "left-6", "top-4", "transition-all", "text-xl", "pointer-events-none"], ["id", "input", "type", "text", 1, "block", "w-full", "bg-white", "px-4", "mt-4", "text-gray-900", "placeholder-transparent", "rounded-lg", "focus:outline-none", "text-xl", 3, "ngModelChange", "focus", "blur", "ngModel", "placeholder", "pattern", "maxlength"], ["class", "text-red-500 text-base mt-2 ml-5", 4, "ngIf"], [1, "text-red-500", "text-base", "mt-2", "ml-5"]], template: function InputFieldComponent_Template(rf, ctx) {
if (rf & 1) {
\u0275\u0275elementStart(0, "div", 0)(1, "label", 1);
\u0275\u0275text(2);
\u0275\u0275elementEnd();
\u0275\u0275elementStart(3, "input", 2);
\u0275\u0275twoWayListener("ngModelChange", function InputFieldComponent_Template_input_ngModelChange_3_listener($event) {
\u0275\u0275twoWayBindingSet(ctx.value, $event) || (ctx.value = $event);
return $event;
});
\u0275\u0275listener("ngModelChange", function InputFieldComponent_Template_input_ngModelChange_3_listener($event) {
return ctx.onInputChange($event);
})("focus", function InputFieldComponent_Template_input_focus_3_listener() {
return ctx.isFocused = true;
})("blur", function InputFieldComponent_Template_input_blur_3_listener() {
return ctx.isFocused = ctx.value !== "";
});
\u0275\u0275elementEnd()();
\u0275\u0275template(4, InputFieldComponent_div_4_Template, 2, 1, "div", 3);
}
if (rf & 2) {
\u0275\u0275advance();
\u0275\u0275classProp("text-gray-400", !ctx.value && !ctx.isFocused)("text-xs", ctx.value || ctx.isFocused)("text-gray-500", ctx.value || ctx.isFocused)("-translate-y-3", ctx.value || ctx.isFocused);
\u0275\u0275advance();
\u0275\u0275textInterpolate1(" ", ctx.label, " ");
\u0275\u0275advance();
\u0275\u0275twoWayProperty("ngModel", ctx.value);
\u0275\u0275property("placeholder", ctx.isFocused ? "" : ctx.placeholder)("pattern", ctx.pattern)("maxlength", ctx.maxLength);
\u0275\u0275advance();
\u0275\u0275property("ngIf", ctx.startValidate && !ctx.isValid());
}
}, dependencies: [FormsModule, DefaultValueAccessor, NgControlStatus, MaxLengthValidator, PatternValidator, NgModel, NgIf], encapsulation: 2 });
var InputFieldComponent = _InputFieldComponent;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && \u0275setClassDebugInfo(InputFieldComponent, { className: "InputFieldComponent", filePath: "src/app/shared/components/input-field/input-field.component.ts", lineNumber: 11 });
})();
// src/app/payment-form/payment-form.component.ts
var _PaymentFormComponent = class _PaymentFormComponent {
constructor(router, route, location2, linkServ) {
this.router = router;
this.route = route;
this.location = location2;
this.linkServ = linkServ;
this.linkInfo = {};
this.paymentMethod = "";
this.paymentNumber = signal("");
this.submited = false;
this.nb = inject(NonNullableFormBuilder);
this.form = this.nb.group({
paymentNr: this.nb.control("")
});
}
ngOnInit() {
this.linkInfo = this.linkServ.getLinkInformation();
if (this.linkInfo.amount == void 0) {
this.goBack();
}
this.paymentMethod = this.route.snapshot.paramMap.get("method");
this.paymentNumber.set(this.linkServ.getPaymentNumber());
}
goBack() {
this.linkServ.setPaymentInput("", "");
this.location.back();
}
getPattern() {
switch (this.paymentMethod) {
case "mKesh":
return "^8(2|3)[0-9]{7}$";
case "MPesa":
return "^8(4|5)[0-9]{7}$";
case "eMola":
return "^8(6|7)[0-9]{7}$";
default:
return "^8[2-7][0-9]{7}|[2-9][0-9]{8}$";
}
}
onSubmit() {
if (RegExp(this.getPattern()).test(this.paymentNumber())) {
this.linkServ.setPaymentInput(this.paymentMethod, this.paymentNumber());
this.router.navigate(["pay/confirmation"]);
} else {
this.submited = true;
}
}
};
_PaymentFormComponent.\u0275fac = function PaymentFormComponent_Factory(t) {
return new (t || _PaymentFormComponent)(\u0275\u0275directiveInject(Router), \u0275\u0275directiveInject(ActivatedRoute), \u0275\u0275directiveInject(Location), \u0275\u0275directiveInject(LinkService));
};
_PaymentFormComponent.\u0275cmp = /* @__PURE__ */ \u0275\u0275defineComponent({ type: _PaymentFormComponent, selectors: [["app-payment-form"]], standalone: true, features: [\u0275\u0275StandaloneFeature], decls: 33, vars: 15, consts: [[1, "flex", "bg-slate-200", 3, "keydown.enter"], [1, "h-screen", "flex-[7]", "flex", "flex-col", "justify-center"], [1, "flex", "flex-col"], [1, "space-y-8", "px-[3rem]", "sm:px-[9rem]", "md:px-[12rem]", "lg:px-[14rem]", "xl:px-[16rem]", "2xl:px-[18rem]"], [3, "click"], ["src", "assets/images/left_arrow.png", "alt", "back", 3, "width"], [1, "text-2xl", "sm:text-3xl", "lg:text-2xl", "xl:text-4xl", "font-bold"], [1, "space-y-3"], [1, "text-sm", "md:text-base"], [1, "font-bold"], [1, "text-2xl", "md:text-3xl"], [1, "flex", "justify-center", "py-10"], [3, "valueChange", "label", "value", "pattern", "maxLength", "startValidate", "errorMessage"], [1, "flex", "justify-center", "py-20"], [1, "w-[50vw]", "lg:w-[25vw]"], ["type", "submit", 1, "w-full", "py-2", "rounded-full", "bg-customGreen", "text-xl", "text-white", 3, "click"], [1, "flex-[3]", "hidden", "lg:block"], [1, "flex", "flex-col", "justify-around", "items-center", "h-screen", "rounded-s-[2rem]", "bg-white", "drop-shadow-md"], ["src", "assets/images/imali_logo.png", "alt", "imali_logo", 1, "w-20"], [1, "py-10"], ["href", "https://imali.co.mz/", "target", "_blank", 1, "underline"]], template: function PaymentFormComponent_Template(rf, ctx) {
if (rf & 1) {
\u0275\u0275elementStart(0, "div", 0);
\u0275\u0275listener("keydown.enter", function PaymentFormComponent_Template_div_keydown_enter_0_listener() {
return ctx.onSubmit();
}, false, \u0275\u0275resolveWindow);
\u0275\u0275elementStart(1, "div", 1)(2, "div", 2)(3, "div", 3)(4, "button", 4);
\u0275\u0275listener("click", function PaymentFormComponent_Template_button_click_4_listener() {
return ctx.goBack();
});
\u0275\u0275element(5, "img", 5);
\u0275\u0275elementEnd();
\u0275\u0275elementStart(6, "p", 6);
\u0275\u0275text(7);
\u0275\u0275elementEnd();
\u0275\u0275elementStart(8, "div", 7)(9, "p", 8);
\u0275\u0275text(10, " Comerciante: ");
\u0275\u0275elementStart(11, "span", 9);
\u0275\u0275text(12);
\u0275\u0275elementEnd()();
\u0275\u0275elementStart(13, "p", 10)(14, "span", 9);
\u0275\u0275text(15);
\u0275\u0275pipe(16, "currency");
\u0275\u0275elementEnd();
\u0275\u0275elementStart(17, "span");
\u0275\u0275text(18, " MZN ");
\u0275\u0275elementEnd()()()()();
\u0275\u0275elementStart(19, "form", 11)(20, "app-input-field", 12);
\u0275\u0275listener("valueChange", function PaymentFormComponent_Template_app_input_field_valueChange_20_listener($event) {
return ctx.paymentNumber.set($event);
});
\u0275\u0275elementEnd()();
\u0275\u0275elementStart(21, "div", 13)(22, "div", 14)(23, "button", 15);
\u0275\u0275listener("click", function PaymentFormComponent_Template_button_click_23_listener() {
return ctx.onSubmit();
});
\u0275\u0275text(24, " Continuar ");
\u0275\u0275elementEnd()()()();
\u0275\u0275elementStart(25, "div", 16)(26, "div", 17)(27, "div");
\u0275\u0275element(28, "img", 18);
\u0275\u0275elementStart(29, "p", 19);
\u0275\u0275text(30, "Aproveita o teu dinheiro da melhor forma.");
\u0275\u0275elementEnd();
\u0275\u0275elementStart(31, "a", 20);
\u0275\u0275text(32, "Saber Mais");
\u0275\u0275elementEnd()()()()();
}
if (rf & 2) {
\u0275\u0275advance(5);
\u0275\u0275property("width", 20);
\u0275\u0275advance(2);
\u0275\u0275textInterpolate1('A pagar com "', ctx.paymentMethod, '"');
\u0275\u0275advance(5);
\u0275\u0275textInterpolate(ctx.linkInfo.store_name);
\u0275\u0275advance(3);
\u0275\u0275textInterpolate(\u0275\u0275pipeBind4(16, 10, ctx.linkInfo.amount, "", "", "1.2-2"));
\u0275\u0275advance(5);
\u0275\u0275property("label", ctx.paymentMethod === "iMali" ? "N\xFAmero de telefone ou conta" : "N\xFAmero de telefone")("value", ctx.paymentNumber())("pattern", ctx.getPattern())("maxLength", 9)("startValidate", ctx.submited)("errorMessage", ctx.paymentMethod === "iMali" ? "N\xFAmero de telefone ou conta esta invalido!" : "N\xFAmero de telefone invalido!");
}
}, dependencies: [CurrencyPipe, InputFieldComponent, FormsModule, \u0275NgNoValidate, NgControlStatusGroup, NgForm] });
var PaymentFormComponent = _PaymentFormComponent;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && \u0275setClassDebugInfo(PaymentFormComponent, { className: "PaymentFormComponent", filePath: "src/app/payment-form/payment-form.component.ts", lineNumber: 16 });
})();
// node_modules/@angular/core/fesm2022/rxjs-interop.mjs
function takeUntilDestroyed(destroyRef) {
if (!destroyRef) {
assertInInjectionContext(takeUntilDestroyed);
destroyRef = inject(DestroyRef);
}
const destroyed$ = new Observable((observer) => {
const unregisterFn = destroyRef.onDestroy(observer.next.bind(observer));
return unregisterFn;
});
return (source) => {
return source.pipe(takeUntil(destroyed$));
};
}
// node_modules/ngx-lottie/fesm2022/ngx-lottie.mjs
var _c03 = ["container"];
var LOTTIE_OPTIONS = new InjectionToken("LottieOptions");
function convertPlayerOrLoaderToObservable() {
const ngZone = inject(NgZone);
const {
player: player2,
useWebWorker
} = inject(LOTTIE_OPTIONS);
const playerOrLoader = ngZone.runOutsideAngular(() => player2());
const player$ = isPromise2(playerOrLoader) ? from(playerOrLoader).pipe(map((module2) => module2.default || module2)) : of(playerOrLoader);
return player$.pipe(
// eslint-disable-next-line @typescript-eslint/no-explicit-any
tap((player3) => player3.useWebWorker?.(useWebWorker)),
shareReplay({
bufferSize: 1,
refCount: true
})
);
}
var _AnimationLoader = class _AnimationLoader {
constructor() {
this.player$ = convertPlayerOrLoaderToObservable().pipe(mergeMap((player2) => raf$(this.ngZone).pipe(map(() => player2))));
this.ngZone = inject(NgZone);
}
loadAnimation(options) {
return this.player$.pipe(map((player2) => this.createAnimationItem(player2, options)));
}
resolveOptions(options, container) {
return Object.assign({
container,
renderer: "svg",
loop: true,
autoplay: true
}, options);
}
createAnimationItem(player2, options) {
return this.ngZone.runOutsideAngular(() => player2.loadAnimation(options));
}
};
_AnimationLoader.\u0275fac = function AnimationLoader_Factory(t) {
return new (t || _AnimationLoader)();
};
_AnimationLoader.\u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
token: _AnimationLoader,
factory: _AnimationLoader.\u0275fac,
providedIn: "root"
});
var AnimationLoader = _AnimationLoader;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(AnimationLoader, [{
type: Injectable,
args: [{
providedIn: "root"
}]
}], null, null);
})();
function raf$(ngZone) {
return new Observable((subscriber) => {
const requestId = ngZone.runOutsideAngular(() => requestAnimationFrame(() => {
subscriber.next();
subscriber.complete();
}));
return () => cancelAnimationFrame(requestId);
});
}
var _CacheableAnimationLoader = class _CacheableAnimationLoader extends AnimationLoader {
constructor() {
super(...arguments);
this.cache = /* @__PURE__ */ new Map();
}
ngOnDestroy() {
this.cache.clear();
}
loadAnimation(options) {
return this.player$.pipe(map((player2) => {
const animationItem = this.createAnimationItem(player2, this.transformOptions(options));
this.awaitConfigAndCache(options, animationItem);
return animationItem;
}));
}
awaitConfigAndCache(options, animationItem) {
if (this.isAnimationConfigWithPath(options)) {
if (this.cache.has(options.path)) {
return;
}
animationItem.addEventListener("config_ready", () => {
this.cache.set(options.path, JSON.stringify(animationItem["animationData"]));
});
}
}
transformOptions(options) {
if (this.isAnimationConfigWithPath(options) && this.cache.has(options.path)) {
return __spreadProps(__spreadValues({}, options), {
path: void 0,
// Caretaker note: `lottie-web` cannot re-use the `animationData` object between animations, and we
// have to retrieve a new object each time an animation is created.
// https://github.com/airbnb/lottie-web#html
// See comments for the `animationData` property.
animationData: JSON.parse(this.cache.get(options.path))
});
} else {
return options;
}
}
isAnimationConfigWithPath(options) {
return typeof options.path === "string";
}
};
_CacheableAnimationLoader.\u0275fac = /* @__PURE__ */ (() => {
let \u0275CacheableAnimationLoader_BaseFactory;
return function CacheableAnimationLoader_Factory(t) {
return (\u0275CacheableAnimationLoader_BaseFactory || (\u0275CacheableAnimationLoader_BaseFactory = \u0275\u0275getInheritedFactory(_CacheableAnimationLoader)))(t || _CacheableAnimationLoader);
};
})();
_CacheableAnimationLoader.\u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
token: _CacheableAnimationLoader,
factory: _CacheableAnimationLoader.\u0275fac,
providedIn: "root"
});
var CacheableAnimationLoader = _CacheableAnimationLoader;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(CacheableAnimationLoader, [{
type: Injectable,
args: [{
providedIn: "root"
}]
}], null, null);
})();
function provideLottieOptions(options) {
return [{
provide: LOTTIE_OPTIONS,
useValue: options
}];
}
var _BaseDirective = class _BaseDirective {
constructor() {
this.options = input(null);
this.containerClass = input(null);
this.styles = input(null);
this.animationCreated = this.getAnimationItem();
this.complete = this.awaitAnimationItemAndStartListening("complete");
this.loopComplete = this.awaitAnimationItemAndStartListening("loopComplete");
this.enterFrame = this.awaitAnimationItemAndStartListening("enterFrame");
this.segmentStart = this.awaitAnimationItemAndStartListening("segmentStart");
this.configReady = this.awaitAnimationItemAndStartListening("config_ready");
this.dataReady = this.awaitAnimationItemAndStartListening("data_ready");
this.domLoaded = this.awaitAnimationItemAndStartListening("DOMLoaded");
this.destroy = this.awaitAnimationItemAndStartListening("destroy");
this.error = this.awaitAnimationItemAndStartListening("error");
this.ngZone = inject(NgZone);
this.isBrowser = isPlatformBrowser2(inject(PLATFORM_ID));
this.animationLoader = inject(AnimationLoader);
this.loadAnimation$ = new Subject();
this.animationItem$ = new BehaviorSubject(null);
this.setupLoadAnimationListener();
}
ngOnDestroy() {
this.destroyAnimation();
}
loadAnimation(changes, container) {
this.ngZone.runOutsideAngular(() => this.loadAnimation$.next([changes, container]));
}
getAnimationItem() {
return defer(() => this.animationItem$).pipe(filter((animationItem) => animationItem !== null));
}
awaitAnimationItemAndStartListening(name2) {
return this.getAnimationItem().pipe(switchMap((animationItem) => (
// `fromEvent` will try to call `removeEventListener` when `unsubscribe()` is invoked.
// The problem is that `ngOnDestroy()` is called before Angular unsubscribes from
// `@Output()` properties, thus `animationItem` will be `null` already, also `lottie-web`
// removes event listeners when calling `destroy()`.
new Observable((observer) => {
this.ngZone.runOutsideAngular(() => {
animationItem.addEventListener(name2, (event) => {
this.ngZone.runOutsideAngular(() => {
observer.next(event);
});
});
});
})
)));
}
setupLoadAnimationListener() {
const loadAnimation$ = this.loadAnimation$.pipe(filter(([changes]) => this.isBrowser && changes.options !== void 0));
loadAnimation$.pipe(switchMap(([changes, container]) => {
this.destroyAnimation();
return this.animationLoader.loadAnimation(this.animationLoader.resolveOptions(changes.options.currentValue, container));
}), takeUntilDestroyed()).subscribe((animationItem) => {
this.ngZone.run(() => this.animationItem$.next(animationItem));
});
}
destroyAnimation() {
const animationItem = this.animationItem$.getValue();
if (animationItem === null) {
return;
}
animationItem.destroy();
this.animationItem$.next(null);
}
};
_BaseDirective.\u0275fac = function BaseDirective_Factory(t) {
return new (t || _BaseDirective)();
};
_BaseDirective.\u0275dir = /* @__PURE__ */ \u0275\u0275defineDirective({
type: _BaseDirective,
selectors: [["", "lottie", ""]],
inputs: {
options: [InputFlags.SignalBased, "options"],
containerClass: [InputFlags.SignalBased, "containerClass"],
styles: [InputFlags.SignalBased, "styles"]
},
outputs: {
animationCreated: "animationCreated",
complete: "complete",
loopComplete: "loopComplete",
enterFrame: "enterFrame",
segmentStart: "segmentStart",
configReady: "configReady",
dataReady: "dataReady",
domLoaded: "domLoaded",
destroy: "destroy",
error: "error"
}
});
var BaseDirective = _BaseDirective;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(BaseDirective, [{
type: Directive,
args: [{
selector: "[lottie]"
}]
}], () => [], {
animationCreated: [{
type: Output
}],
complete: [{
type: Output
}],
loopComplete: [{
type: Output
}],
enterFrame: [{
type: Output
}],
segmentStart: [{
type: Output
}],
configReady: [{
type: Output
}],
dataReady: [{
type: Output
}],
domLoaded: [{
type: Output
}],
destroy: [{
type: Output
}],
error: [{
type: Output
}]
});
})();
var _LottieDirective = class _LottieDirective extends BaseDirective {
constructor() {
super(...arguments);
this.host = inject(ElementRef);
}
ngOnChanges(changes) {
super.loadAnimation(changes, this.host.nativeElement);
}
};
_LottieDirective.\u0275fac = /* @__PURE__ */ (() => {
let \u0275LottieDirective_BaseFactory;
return function LottieDirective_Factory(t) {
return (\u0275LottieDirective_BaseFactory || (\u0275LottieDirective_BaseFactory = \u0275\u0275getInheritedFactory(_LottieDirective)))(t || _LottieDirective);
};
})();
_LottieDirective.\u0275dir = /* @__PURE__ */ \u0275\u0275defineDirective({
type: _LottieDirective,
selectors: [["", "lottie", ""]],
standalone: true,
features: [\u0275\u0275InheritDefinitionFeature, \u0275\u0275NgOnChangesFeature]
});
var LottieDirective = _LottieDirective;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(LottieDirective, [{
type: Directive,
args: [{
selector: "[lottie]",
standalone: true
}]
}], null, null);
})();
var _LottieComponent = class _LottieComponent extends BaseDirective {
constructor() {
super(...arguments);
this.width = input(null);
this.height = input(null);
this.container = null;
}
ngOnChanges(changes) {
super.loadAnimation(changes, this.container.nativeElement);
}
};
_LottieComponent.\u0275fac = /* @__PURE__ */ (() => {
let \u0275LottieComponent_BaseFactory;
return function LottieComponent_Factory(t) {
return (\u0275LottieComponent_BaseFactory || (\u0275LottieComponent_BaseFactory = \u0275\u0275getInheritedFactory(_LottieComponent)))(t || _LottieComponent);
};
})();
_LottieComponent.\u0275cmp = /* @__PURE__ */ \u0275\u0275defineComponent({
type: _LottieComponent,
selectors: [["ng-lottie"]],
viewQuery: function LottieComponent_Query(rf, ctx) {
if (rf & 1) {
\u0275\u0275viewQuery(_c03, 7);
}
if (rf & 2) {
let _t;
\u0275\u0275queryRefresh(_t = \u0275\u0275loadQuery()) && (ctx.container = _t.first);
}
},
inputs: {
width: [InputFlags.SignalBased, "width"],
height: [InputFlags.SignalBased, "height"]
},
standalone: true,
features: [\u0275\u0275InheritDefinitionFeature, \u0275\u0275NgOnChangesFeature, \u0275\u0275StandaloneFeature],
decls: 2,
vars: 6,
consts: [["container", ""], [3, "ngStyle", "ngClass"]],
template: function LottieComponent_Template(rf, ctx) {
if (rf & 1) {
\u0275\u0275element(0, "div", 1, 0);
}
if (rf & 2) {
\u0275\u0275styleProp("width", ctx.width() || "100%")("height", ctx.height() || "100%");
\u0275\u0275property("ngStyle", ctx.styles())("ngClass", ctx.containerClass());
}
},
dependencies: [NgStyle, NgClass],
encapsulation: 2,
changeDetection: 0
});
var LottieComponent = _LottieComponent;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(LottieComponent, [{
type: Component,
args: [{
selector: "ng-lottie",
template: `
<div
#container
[style.width]="width() || '100%'"
[style.height]="height() || '100%'"
[ngStyle]="styles()"
[ngClass]="containerClass()"
></div>
`,
changeDetection: ChangeDetectionStrategy.OnPush,
standalone: true,
imports: [NgStyle, NgClass]
}]
}], null, {
container: [{
type: ViewChild,
args: ["container", {
static: true
}]
}]
});
})();
function transformAnimationFilenameToKey(animation) {
const [animationName] = animation.split(".json");
return `animation-${animationName}`;
}
var _LottieTransferState = class _LottieTransferState {
constructor(transferState) {
this.transferState = transferState;
}
get(animation) {
const animationKey = transformAnimationFilenameToKey(animation);
const stateKey = makeStateKey(animationKey);
return this.transferState.get(stateKey, null);
}
};
_LottieTransferState.\u0275fac = function LottieTransferState_Factory(t) {
return new (t || _LottieTransferState)(\u0275\u0275inject(TransferState));
};
_LottieTransferState.\u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
token: _LottieTransferState,
factory: _LottieTransferState.\u0275fac,
providedIn: "root"
});
var LottieTransferState = _LottieTransferState;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(LottieTransferState, [{
type: Injectable,
args: [{
providedIn: "root"
}]
}], () => [{
type: TransferState
}], null);
})();
// src/app/not-found/not-found.component.ts
var _NotFoundComponent = class _NotFoundComponent {
constructor() {
this.options = {
path: "assets/animations/not-found.json"
};
}
};
_NotFoundComponent.\u0275fac = function NotFoundComponent_Factory(t) {
return new (t || _NotFoundComponent)();
};
_NotFoundComponent.\u0275cmp = /* @__PURE__ */ \u0275\u0275defineComponent({ type: _NotFoundComponent, selectors: [["app-not-found"]], standalone: true, features: [\u0275\u0275StandaloneFeature], decls: 4, vars: 1, consts: [[1, "h-screen", "flex", "flex-col", "justify-center", "items-center"], [3, "options"], [1, "text-2xl", "sm:text-5xl", "font-semibold", "text-[#009D90]"]], template: function NotFoundComponent_Template(rf, ctx) {
if (rf & 1) {
\u0275\u0275elementStart(0, "div", 0);
\u0275\u0275element(1, "ng-lottie", 1);
\u0275\u0275elementStart(2, "p", 2);
\u0275\u0275text(3, " P\xE1gina n\xE3o foi encontrada ");
\u0275\u0275elementEnd()();
}
if (rf & 2) {
\u0275\u0275advance();
\u0275\u0275property("options", ctx.options);
}
}, dependencies: [LottieComponent] });
var NotFoundComponent = _NotFoundComponent;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && \u0275setClassDebugInfo(NotFoundComponent, { className: "NotFoundComponent", filePath: "src/app/not-found/not-found.component.ts", lineNumber: 11 });
})();
// src/app/payment-confirmation/payment-confirmation.component.ts
var _PaymentConfirmationComponent = class _PaymentConfirmationComponent {
constructor(router, location2, linkServ) {
this.router = router;
this.location = location2;
this.linkServ = linkServ;
this.linkInfo = {};
}
ngOnInit() {
this.linkInfo = this.linkServ.getLinkInformation();
if (this.linkInfo.amount == void 0) {
this.goBack();
}
}
goBack() {
this.location.back();
}
confirm() {
this.router.navigate(["pay/processing"]);
}
};
_PaymentConfirmationComponent.\u0275fac = function PaymentConfirmationComponent_Factory(t) {
return new (t || _PaymentConfirmationComponent)(\u0275\u0275directiveInject(Router), \u0275\u0275directiveInject(Location), \u0275\u0275directiveInject(LinkService));
};
_PaymentConfirmationComponent.\u0275cmp = /* @__PURE__ */ \u0275\u0275defineComponent({ type: _PaymentConfirmationComponent, selectors: [["app-payment-confirmation"]], standalone: true, features: [\u0275\u0275StandaloneFeature], decls: 49, vars: 11, consts: [[1, "flex", "bg-slate-200", 3, "keydown.enter"], [1, "h-screen", "flex-[7]", "flex", "flex-col", "justify-center"], [1, "flex", "justify-center", "mr-[22rem]", "py-10"], [3, "click"], ["src", "assets/images/left_arrow.png", "alt", "back", 3, "width"], [1, "text-4xl", "text-center", "font-semibold", "md:ml-[7rem]"], [1, "md:ml-[8rem]"], [1, "space-y-4", "p-6", "max-w-md", "mx-auto"], [1, "bg-white", "rounded-xl", "p-4"], [1, "text-gray-500"], [1, "text-black", "font-medium", "mt-2"], [1, "flex", "justify-between"], [1, "text-black", "font-medium"], [1, "flex", "justify-between", "mt-2"], [1, "bg-white", "rounded-xl", "p-4", "space-y-2"], [1, "flex", "justify-center", "md:ml-[10rem]", "py-20"], [1, "w-[50vw]", "md:w-[25vw]"], [1, "w-full", "py-2", "rounded-full", "bg-customGreen", "text-xl", "text-white", 3, "click"], [1, "flex-[3]", "hidden", "lg:block"], [1, "flex", "flex-col", "justify-around", "items-center", "h-screen", "rounded-s-[2rem]", "bg-white", "drop-shadow-md"], ["src", "assets/images/imali_logo.png", "alt", "imali_logo", 1, "w-20"], [1, "py-10"], ["href", "https://imali.co.mz/", "target", "_blank", 1, "underline"]], template: function PaymentConfirmationComponent_Template(rf, ctx) {
if (rf & 1) {
\u0275\u0275elementStart(0, "div", 0);
\u0275\u0275listener("keydown.enter", function PaymentConfirmationComponent_Template_div_keydown_enter_0_listener() {
return ctx.confirm();
}, false, \u0275\u0275resolveWindow);
\u0275\u0275elementStart(1, "div", 1)(2, "div", 2)(3, "button", 3);
\u0275\u0275listener("click", function PaymentConfirmationComponent_Template_button_click_3_listener() {
return ctx.goBack();
});
\u0275\u0275element(4, "img", 4);
\u0275\u0275elementEnd()();
\u0275\u0275elementStart(5, "h1", 5);
\u0275\u0275text(6, "Confirmar Pagamento");
\u0275\u0275elementEnd();
\u0275\u0275elementStart(7, "div", 6)(8, "div", 7)(9, "div", 8)(10, "span", 9);
\u0275\u0275text(11, "Nome do Produto");
\u0275\u0275elementEnd();
\u0275\u0275elementStart(12, "p", 10);
\u0275\u0275text(13);
\u0275\u0275elementEnd()();
\u0275\u0275elementStart(14, "div", 8)(15, "span", 9);
\u0275\u0275text(16, "Nota");
\u0275\u0275elementEnd();
\u0275\u0275elementStart(17, "p", 10);
\u0275\u0275text(18);
\u0275\u0275elementEnd()();
\u0275\u0275elementStart(19, "div", 8)(20, "div", 11)(21, "span", 9);
\u0275\u0275text(22, "Pagar para");
\u0275\u0275elementEnd();
\u0275\u0275elementStart(23, "span", 12);
\u0275\u0275text(24);
\u0275\u0275elementEnd()();
\u0275\u0275elementStart(25, "div", 13)(26, "span", 9);
\u0275\u0275text(27, "Pagar com");
\u0275\u0275elementEnd();
\u0275\u0275elementStart(28, "span", 12);
\u0275\u0275text(29);
\u0275\u0275elementEnd()()();
\u0275\u0275elementStart(30, "div", 14)(31, "div", 11)(32, "span", 9);
\u0275\u0275text(33, "Montante");
\u0275\u0275elementEnd();
\u0275\u0275elementStart(34, "span", 12);
\u0275\u0275text(35);
\u0275\u0275pipe(36, "currency");
\u0275\u0275elementEnd()()()()();
\u0275\u0275elementStart(37, "div", 15)(38, "div", 16)(39, "button", 17);
\u0275\u0275listener("click", function PaymentConfirmationComponent_Template_button_click_39_listener() {
return ctx.confirm();
});
\u0275\u0275text(40, " Continuar ");
\u0275\u0275elementEnd()()()();
\u0275\u0275elementStart(41, "div", 18)(42, "div", 19)(43, "div");
\u0275\u0275element(44, "img", 20);
\u0275\u0275elementStart(45, "p", 21);
\u0275\u0275text(46, "Aproveita o teu dinheiro da melhor forma.");
\u0275\u0275elementEnd();
\u0275\u0275elementStart(47, "a", 22);
\u0275\u0275text(48, "Saber Mais");
\u0275\u0275elementEnd()()()()();
}
if (rf & 2) {
\u0275\u0275advance(4);
\u0275\u0275property("width", 25);
\u0275\u0275advance(9);
\u0275\u0275textInterpolate(ctx.linkInfo.title);
\u0275\u0275advance(5);
\u0275\u0275textInterpolate(ctx.linkInfo.short_description);
\u0275\u0275advance(6);
\u0275\u0275textInterpolate(ctx.linkInfo.store_name);
\u0275\u0275advance(5);
\u0275\u0275textInterpolate(ctx.linkServ.getPaymentNumber());
\u0275\u0275advance(6);
\u0275\u0275textInterpolate1("", \u0275\u0275pipeBind4(36, 6, ctx.linkInfo.amount, "", "", "1.2-2"), " MZN");
}
}, dependencies: [CurrencyPipe] });
var PaymentConfirmationComponent = _PaymentConfirmationComponent;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && \u0275setClassDebugInfo(PaymentConfirmationComponent, { className: "PaymentConfirmationComponent", filePath: "src/app/payment-confirmation/payment-confirmation.component.ts", lineNumber: 14 });
})();
// src/app/expired-link/expired-link.component.ts
var _ExpiredLinkComponent = class _ExpiredLinkComponent {
constructor() {
this.options = {
path: "assets/animations/expired-link.json",
loop: 1
};
}
close() {
closeWindow();
}
};
_ExpiredLinkComponent.\u0275fac = function ExpiredLinkComponent_Factory(t) {
return new (t || _ExpiredLinkComponent)();
};
_ExpiredLinkComponent.\u0275cmp = /* @__PURE__ */ \u0275\u0275defineComponent({ type: _ExpiredLinkComponent, selectors: [["app-expired-link"]], standalone: true, features: [\u0275\u0275StandaloneFeature], decls: 9, vars: 1, consts: [[1, "h-screen", "flex", "flex-col", "space-y-10", "justify-center", "items-center"], [1, "h-[6.5rem]", "sm:h-[8rem]", "md:h-[10rem]", 3, "options"], [1, "space-y-2", "text-center"], [1, "font-bold", "text-xl", "sm:text-2xl", "md:text-4xl"], [1, "text-lg", "sm:text-xl", "md:text-2xl"], [1, "px-16", "py-2", "md:px-20", "md:py-3", "rounded-full", "text-lg", "sm:text-xl", "md:text-2xl", "text-white", "bg-[#2D2D2D]", 3, "click"]], template: function ExpiredLinkComponent_Template(rf, ctx) {
if (rf & 1) {
\u0275\u0275elementStart(0, "div", 0);
\u0275\u0275element(1, "ng-lottie", 1);
\u0275\u0275elementStart(2, "div", 2)(3, "p", 3);
\u0275\u0275text(4, "O link expirou!");
\u0275\u0275elementEnd();
\u0275\u0275elementStart(5, "p", 4);
\u0275\u0275text(6, "Solicita ao comerciante um novo link.");
\u0275\u0275elementEnd()();
\u0275\u0275elementStart(7, "button", 5);
\u0275\u0275listener("click", function ExpiredLinkComponent_Template_button_click_7_listener() {
return ctx.close();
});
\u0275\u0275text(8, " Sair ");
\u0275\u0275elementEnd()();
}
if (rf & 2) {
\u0275\u0275advance();
\u0275\u0275property("options", ctx.options);
}
}, dependencies: [LottieComponent] });
var ExpiredLinkComponent = _ExpiredLinkComponent;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && \u0275setClassDebugInfo(ExpiredLinkComponent, { className: "ExpiredLinkComponent", filePath: "src/app/expired-link/expired-link.component.ts", lineNumber: 12 });
})();
// src/app/used-link/used-link.component.ts
var _UsedLinkComponent = class _UsedLinkComponent {
constructor() {
this.options = {
path: "assets/animations/success.json",
loop: 0
};
}
close() {
closeWindow();
}
};
_UsedLinkComponent.\u0275fac = function UsedLinkComponent_Factory(t) {
return new (t || _UsedLinkComponent)();
};
_UsedLinkComponent.\u0275cmp = /* @__PURE__ */ \u0275\u0275defineComponent({ type: _UsedLinkComponent, selectors: [["app-used-link"]], standalone: true, features: [\u0275\u0275StandaloneFeature], decls: 9, vars: 1, consts: [[1, "h-screen", "flex", "flex-col", "space-y-10", "justify-center", "items-center"], [1, "h-[8rem]", "sm:h-[10rem]", "md:h-[12rem]", 3, "options"], [1, "space-y-2", "text-center"], [1, "font-bold", "text-xl", "sm:text-2xl", "md:text-4xl"], [1, "text-lg", "sm:text-xl", "md:text-2xl"], [1, "px-16", "py-2", "md:px-20", "md:py-3", "rounded-full", "text-lg", "sm:text-xl", "md:text-2xl", "text-white", "bg-[#40AD53]", 3, "click"]], template: function UsedLinkComponent_Template(rf, ctx) {
if (rf & 1) {
\u0275\u0275elementStart(0, "div", 0);
\u0275\u0275element(1, "ng-lottie", 1);
\u0275\u0275elementStart(2, "div", 2)(3, "p", 3);
\u0275\u0275text(4, "Opera\xE7\xE3o bem sucedida!");
\u0275\u0275elementEnd();
\u0275\u0275elementStart(5, "p", 4);
\u0275\u0275text(6, "O teu pagamento foi conclu\xEDdo.");
\u0275\u0275elementEnd()();
\u0275\u0275elementStart(7, "button", 5);
\u0275\u0275listener("click", function UsedLinkComponent_Template_button_click_7_listener() {
return ctx.close();
});
\u0275\u0275text(8, " Sair ");
\u0275\u0275elementEnd()();
}
if (rf & 2) {
\u0275\u0275advance();
\u0275\u0275property("options", ctx.options);
}
}, dependencies: [LottieComponent] });
var UsedLinkComponent = _UsedLinkComponent;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && \u0275setClassDebugInfo(UsedLinkComponent, { className: "UsedLinkComponent", filePath: "src/app/used-link/used-link.component.ts", lineNumber: 12 });
})();
// src/app/inactive-link/inactive-link.component.ts
var _InactiveLinkComponent = class _InactiveLinkComponent {
constructor() {
this.options = {
path: "assets/animations/inactive-link.json",
loop: 1
};
}
close() {
closeWindow();
}
};
_InactiveLinkComponent.\u0275fac = function InactiveLinkComponent_Factory(t) {
return new (t || _InactiveLinkComponent)();
};
_InactiveLinkComponent.\u0275cmp = /* @__PURE__ */ \u0275\u0275defineComponent({ type: _InactiveLinkComponent, selectors: [["app-inactive-link"]], standalone: true, features: [\u0275\u0275StandaloneFeature], decls: 9, vars: 1, consts: [[1, "h-screen", "flex", "flex-col", "space-y-10", "justify-center", "items-center"], [1, "h-[6.5rem]", "sm:h-[8rem]", "md:h-[10rem]", 3, "options"], [1, "space-y-2", "text-center"], [1, "font-bold", "text-xl", "sm:text-2xl", "md:text-4xl"], [1, "text-lg", "sm:text-xl", "md:text-2xl"], [1, "px-16", "py-2", "md:px-20", "md:py-3", "rounded-full", "text-lg", "sm:text-xl", "md:text-2xl", "text-white", "bg-[#2D2D2D]", 3, "click"]], template: function InactiveLinkComponent_Template(rf, ctx) {
if (rf & 1) {
\u0275\u0275elementStart(0, "div", 0);
\u0275\u0275element(1, "ng-lottie", 1);
\u0275\u0275elementStart(2, "div", 2)(3, "p", 3);
\u0275\u0275text(4, "O link est\xE1 inactivo!");
\u0275\u0275elementEnd();
\u0275\u0275elementStart(5, "p", 4);
\u0275\u0275text(6, "Solicita ao comerciante um novo link.");
\u0275\u0275elementEnd()();
\u0275\u0275elementStart(7, "button", 5);
\u0275\u0275listener("click", function InactiveLinkComponent_Template_button_click_7_listener() {
return ctx.close();
});
\u0275\u0275text(8, " Sair ");
\u0275\u0275elementEnd()();
}
if (rf & 2) {
\u0275\u0275advance();
\u0275\u0275property("options", ctx.options);
}
}, dependencies: [LottieComponent] });
var InactiveLinkComponent = _InactiveLinkComponent;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && \u0275setClassDebugInfo(InactiveLinkComponent, { className: "InactiveLinkComponent", filePath: "src/app/inactive-link/inactive-link.component.ts", lineNumber: 12 });
})();
// src/app/payment-failed/payment-failed.component.ts
var _PaymentFailedComponent = class _PaymentFailedComponent {
constructor() {
this.options = {
path: "assets/animations/failed.json",
loop: 0
};
this.location = inject(Location);
}
tryAgain() {
this.location.back();
}
};
_PaymentFailedComponent.\u0275fac = function PaymentFailedComponent_Factory(t) {
return new (t || _PaymentFailedComponent)();
};
_PaymentFailedComponent.\u0275cmp = /* @__PURE__ */ \u0275\u0275defineComponent({ type: _PaymentFailedComponent, selectors: [["app-payment-failed"]], standalone: true, features: [\u0275\u0275StandaloneFeature], decls: 9, vars: 1, consts: [[1, "h-screen", "flex", "flex-col", "space-y-10", "justify-center", "items-center"], [1, "h-[8.5rem]", "sm:h-[10rem]", "md:h-[12rem]", 3, "options"], [1, "space-y-2", "text-center"], [1, "font-bold", "text-xl", "sm:text-2xl", "md:text-4xl"], [1, "text-lg", "sm:text-xl", "md:text-2xl"], [1, "px-16", "py-2", "md:px-20", "md:py-3", "rounded-full", "text-lg", "sm:text-xl", "md:text-2xl", "text-white", "bg-[#2D2D2D]", 3, "click"]], template: function PaymentFailedComponent_Template(rf, ctx) {
if (rf & 1) {
\u0275\u0275elementStart(0, "div", 0);
\u0275\u0275element(1, "ng-lottie", 1);
\u0275\u0275elementStart(2, "div", 2)(3, "p", 3);
\u0275\u0275text(4, "Pagamento sem sucesso!");
\u0275\u0275elementEnd();
\u0275\u0275elementStart(5, "p", 4);
\u0275\u0275text(6, "Volte a tentar fazer o pagamento.");
\u0275\u0275elementEnd()();
\u0275\u0275elementStart(7, "button", 5);
\u0275\u0275listener("click", function PaymentFailedComponent_Template_button_click_7_listener() {
return ctx.tryAgain();
});
\u0275\u0275text(8, " Tentar Novamente ");
\u0275\u0275elementEnd()();
}
if (rf & 2) {
\u0275\u0275advance();
\u0275\u0275property("options", ctx.options);
}
}, dependencies: [LottieComponent] });
var PaymentFailedComponent = _PaymentFailedComponent;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && \u0275setClassDebugInfo(PaymentFailedComponent, { className: "PaymentFailedComponent", filePath: "src/app/payment-failed/payment-failed.component.ts", lineNumber: 12 });
})();
// src/app/shared/enums/payment-types.ts
var PaymentType;
(function(PaymentType2) {
PaymentType2["PUSH"] = "push";
PaymentType2["QRCODE"] = "qrcode";
})(PaymentType || (PaymentType = {}));
// src/app/shared/components/countdown-timer/countdown-timer.component.ts
var _CountdownTimerComponent = class _CountdownTimerComponent {
constructor() {
this.minutes = 0;
this.seconds = 0;
this.countdownCompleted = new EventEmitter();
this.displayMinutes = "00";
this.displaySeconds = "00";
this.progressPercentage = 100;
this.circleColor = "stroke-green-500";
}
ngOnInit() {
this.totalSeconds = this.minutes * 60 + this.seconds;
this.initialTotalSeconds = this.totalSeconds;
this.updateDisplay();
this.startCountdown();
}
startCountdown() {
this.subscription = interval(1e3).subscribe(() => {
if (this.totalSeconds > 0) {
this.totalSeconds--;
this.updateDisplay();
this.updateProgress();
} else {
this.subscription.unsubscribe();
this.countdownCompleted.emit();
}
});
}
updateDisplay() {
const mins = Math.floor(this.totalSeconds / 60);
const secs = this.totalSeconds % 60;
this.displayMinutes = String(mins).padStart(2, "0");
this.displaySeconds = String(secs).padStart(2, "0");
}
updateProgress() {
this.progressPercentage = this.totalSeconds / this.initialTotalSeconds * 100;
if (this.progressPercentage <= 25) {
this.circleColor = "stroke-red-500";
} else if (this.progressPercentage <= 50) {
this.circleColor = "stroke-yellow-500";
} else {
this.circleColor = "stroke-green-500";
}
}
ngOnDestroy() {
if (this.subscription) {
this.subscription.unsubscribe();
}
}
};
_CountdownTimerComponent.\u0275fac = function CountdownTimerComponent_Factory(t) {
return new (t || _CountdownTimerComponent)();
};
_CountdownTimerComponent.\u0275cmp = /* @__PURE__ */ \u0275\u0275defineComponent({ type: _CountdownTimerComponent, selectors: [["app-countdown-timer"]], inputs: { minutes: "minutes", seconds: "seconds" }, outputs: { countdownCompleted: "countdownCompleted" }, standalone: true, features: [\u0275\u0275StandaloneFeature], decls: 7, vars: 4, consts: [[1, "relative", "w-48", "h-48", "flex", "items-center", "justify-center", "rounded-full"], ["viewBox", "0 0 100 100", 1, "absolute", "w-full", "h-full", "rotate-[-90deg]"], ["cx", "50", "cy", "50", "r", "45", "stroke-width", "6", "stroke-linecap", "round", "stroke-dasharray", "282.743", "fill", "none"], [1, "text-3xl", "font-bold", "text-gray-700"]], template: function CountdownTimerComponent_Template(rf, ctx) {
if (rf & 1) {
\u0275\u0275elementStart(0, "div", 0);
\u0275\u0275namespaceSVG();
\u0275\u0275elementStart(1, "svg", 1);
\u0275\u0275element(2, "circle", 2);
\u0275\u0275elementEnd();
\u0275\u0275namespaceHTML();
\u0275\u0275elementStart(3, "div", 3);
\u0275\u0275text(4);
\u0275\u0275elementStart(5, "span");
\u0275\u0275text(6);
\u0275\u0275elementEnd()()();
}
if (rf & 2) {
\u0275\u0275advance(2);
\u0275\u0275attribute("class", "transition-all duration-1000 " + ctx.circleColor)("stroke-dashoffset", (1 - ctx.progressPercentage / 100) * 282.743);
\u0275\u0275advance(2);
\u0275\u0275textInterpolate1(" ", ctx.displayMinutes, ":");
\u0275\u0275advance(2);
\u0275\u0275textInterpolate(ctx.displaySeconds);
}
}, encapsulation: 2 });
var CountdownTimerComponent = _CountdownTimerComponent;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && \u0275setClassDebugInfo(CountdownTimerComponent, { className: "CountdownTimerComponent", filePath: "src/app/shared/components/countdown-timer/countdown-timer.component.ts", lineNumber: 10 });
})();
// src/app/payment-loading/payment-loading.component.ts
function PaymentLoadingComponent_li_6_Template(rf, ctx) {
if (rf & 1) {
\u0275\u0275elementStart(0, "li");
\u0275\u0275text(1);
\u0275\u0275elementEnd();
}
if (rf & 2) {
const step_r1 = ctx.$implicit;
\u0275\u0275advance();
\u0275\u0275textInterpolate1(" ", step_r1, " ");
}
}
var _PaymentLoadingComponent = class _PaymentLoadingComponent {
constructor(router, location2, linkServ, paymentServ) {
this.router = router;
this.location = location2;
this.linkServ = linkServ;
this.paymentServ = paymentServ;
this.linkInfo = {};
this.onDestroy$ = new Subject();
this.steps = [
"Deve ir para o seu telefone;",
"Ver\xE1 um push notification;",
"Deve Colocar o seu PIN;",
"Por fim deve aceitar."
];
}
ngOnInit() {
this.linkInfo = this.linkServ.getLinkInformation();
if (this.linkInfo.amount == void 0) {
this.location.back();
} else {
this.makePayment();
}
}
ngOnDestroy() {
this.onDestroy$.next();
this.onDestroy$.complete();
}
makePayment() {
this.paymentServ.createPayment(this.linkServ.getPaymentNumber(), this.linkInfo.amount, this.linkInfo.store_account_number, this.linkServ.getPaymentMethod(), PaymentType.PUSH).pipe(takeUntil(this.onDestroy$)).subscribe((data2) => {
console.log(data2);
if (data2.status !== PaymentStatus.PENDING) {
this.linkServ.clear();
switch (data2.status) {
case PaymentStatus.EXPIRED:
this.router.navigate(["expired"]);
break;
case PaymentStatus.FAILED:
this.router.navigate(["pay/failed"]);
break;
case PaymentStatus.SUCCESS:
this.router.navigate(["used"]);
break;
default:
this.router.navigate(["pay/failed"]);
break;
}
}
});
}
onTimeout() {
this.linkServ.clear();
this.router.navigate(["pay/failed"]);
}
};
_PaymentLoadingComponent.\u0275fac = function PaymentLoadingComponent_Factory(t) {
return new (t || _PaymentLoadingComponent)(\u0275\u0275directiveInject(Router), \u0275\u0275directiveInject(Location), \u0275\u0275directiveInject(LinkService), \u0275\u0275directiveInject(PaymentService));
};
_PaymentLoadingComponent.\u0275cmp = /* @__PURE__ */ \u0275\u0275defineComponent({ type: _PaymentLoadingComponent, selectors: [["app-payment-loading"]], standalone: true, features: [\u0275\u0275StandaloneFeature], decls: 7, vars: 3, consts: [[1, "h-screen", "flex", "flex-col", "space-y-10", "pt-10", "lg:space-y-20", "lg:pt-30", "justify-center", "items-center", "bg-slate-200"], [3, "countdownCompleted", "minutes", "seconds"], [1, "space-y-3", "text-gray-700"], [1, "text-base", "lg:text-lg", "font-semibold"], [1, "list-decimal", "list-inside", "ml-4", "lg:ml-6", "space-y-1", "text-sm", "lg:text-base"], [4, "ngFor", "ngForOf"]], template: function PaymentLoadingComponent_Template(rf, ctx) {
if (rf & 1) {
\u0275\u0275elementStart(0, "div", 0)(1, "app-countdown-timer", 1);
\u0275\u0275listener("countdownCompleted", function PaymentLoadingComponent_Template_app_countdown_timer_countdownCompleted_1_listener() {
return ctx.onTimeout();
});
\u0275\u0275elementEnd();
\u0275\u0275elementStart(2, "div", 2)(3, "p", 3);
\u0275\u0275text(4, "Para concluir com o pagamento: ");
\u0275\u0275elementEnd();
\u0275\u0275elementStart(5, "ol", 4);
\u0275\u0275template(6, PaymentLoadingComponent_li_6_Template, 2, 1, "li", 5);
\u0275\u0275elementEnd()()();
}
if (rf & 2) {
\u0275\u0275advance();
\u0275\u0275property("minutes", 3)("seconds", 0);
\u0275\u0275advance(5);
\u0275\u0275property("ngForOf", ctx.steps);
}
}, dependencies: [CountdownTimerComponent, NgForOf] });
var PaymentLoadingComponent = _PaymentLoadingComponent;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && \u0275setClassDebugInfo(PaymentLoadingComponent, { className: "PaymentLoadingComponent", filePath: "src/app/payment-loading/payment-loading.component.ts", lineNumber: 20 });
})();
// src/app/app.routes.ts
var routes = [
{ path: "", redirectTo: "not-found", pathMatch: "full" },
{
path: "not-found",
component: NotFoundComponent
},
{
path: "expired",
component: ExpiredLinkComponent
},
{
path: "used",
component: UsedLinkComponent
},
{
path: "inactive",
component: InactiveLinkComponent
},
{
path: "payment/:method",
component: PaymentFormComponent
},
{
path: "pay/confirmation",
component: PaymentConfirmationComponent
},
{
path: "pay/processing",
component: PaymentLoadingComponent
},
{
path: "pay/failed",
component: PaymentFailedComponent
},
{
path: ":linkId",
component: HomeComponent
}
];
// src/app/shared/interfaces/encrypt.ts
var forge = __toESM(require_lib());
var EncryptionService = class {
generatePrivateKey() {
const keypair = forge.pki.rsa.generateKeyPair(2048);
return forge.pki.privateKeyToPem(keypair.privateKey);
}
generatePublicKey() {
const keypair = forge.pki.rsa.generateKeyPair(2048);
return forge.pki.publicKeyToPem(keypair.publicKey);
}
static encryptData(publicKey, data2) {
const publicKeyObj = forge.pki.publicKeyFromPem(publicKey);
const encryptedData = publicKeyObj.encrypt(data2, "RSAES-PKCS1-V1_5");
return forge.util.encode64(encryptedData);
}
};
// src/app/interceptors/auth-interceptor.interceptor.ts
var authInterceptorInterceptor = (req, next) => {
const encryptedToken = EncryptionService.encryptData(environment.apiPublicKey, environment.apiKey);
const authReq = req.clone({
setHeaders: {
"Authorization": `Bearer ${encryptedToken}`,
"X-APP-ID": environment.appId,
"Accept": "Application/json",
"Content-Type": "Application/json"
}
});
return next(authReq);
};
// src/app/app.config.ts
var import_lottie_web = __toESM(require_lottie());
var appConfig = {
providers: [
provideRouter(routes),
provideHttpClient(withInterceptors([
authInterceptorInterceptor
])),
provideLottieOptions({
player: () => import_lottie_web.default
})
]
};
// src/app/app.component.ts
var _AppComponent = class _AppComponent {
};
_AppComponent.\u0275fac = function AppComponent_Factory(t) {
return new (t || _AppComponent)();
};
_AppComponent.\u0275cmp = /* @__PURE__ */ \u0275\u0275defineComponent({ type: _AppComponent, selectors: [["app-root"]], standalone: true, features: [\u0275\u0275StandaloneFeature], decls: 1, vars: 0, template: function AppComponent_Template(rf, ctx) {
if (rf & 1) {
\u0275\u0275element(0, "router-outlet");
}
}, dependencies: [RouterOutlet, CommonModule, ReactiveFormsModule] });
var AppComponent = _AppComponent;
(() => {
(typeof ngDevMode === "undefined" || ngDevMode) && \u0275setClassDebugInfo(AppComponent, { className: "AppComponent", filePath: "src/app/app.component.ts", lineNumber: 13 });
})();
// src/main.ts
bootstrapApplication(AppComponent, appConfig).catch((err) => console.error(err));
/*! Bundled license information:
pusher-js/dist/web/pusher.js:
(*!
* Pusher JavaScript Library v8.4.0
* https://pusher.com/
*
* Copyright 2020, Pusher
* Released under the MIT licence.
*)
lottie-web/build/player/lottie.js:
(*!
Transformation Matrix v2.0
(c) Epistemex 2014-2015
www.epistemex.com
By Ken Fyrstenberg
Contributions by leeoniya.
License: MIT, header required.
*)
@angular/core/fesm2022/primitives/signals.mjs:
(**
* @license Angular v17.3.12
* (c) 2010-2024 Google LLC. https://angular.io/
* License: MIT
*)
@angular/core/fesm2022/core.mjs:
(**
* @license Angular v17.3.12
* (c) 2010-2024 Google LLC. https://angular.io/
* License: MIT
*)
@angular/core/fesm2022/core.mjs:
(*!
* @license
* Copyright Google LLC All Rights Reserved.
*
* Use of this source code is governed by an MIT-style license that can be
* found in the LICENSE file at https://angular.io/license
*)
@angular/core/fesm2022/core.mjs:
(*!
* @license
* Copyright Google LLC All Rights Reserved.
*
* Use of this source code is governed by an MIT-style license that can be
* found in the LICENSE file at https://angular.io/license
*)
@angular/core/fesm2022/core.mjs:
(*!
* @license
* Copyright Google LLC All Rights Reserved.
*
* Use of this source code is governed by an MIT-style license that can be
* found in the LICENSE file at https://angular.io/license
*)
@angular/core/fesm2022/core.mjs:
(*!
* @license
* Copyright Google LLC All Rights Reserved.
*
* Use of this source code is governed by an MIT-style license that can be
* found in the LICENSE file at https://angular.io/license
*)
@angular/core/fesm2022/core.mjs:
(*!
* @license
* Copyright Google LLC All Rights Reserved.
*
* Use of this source code is governed by an MIT-style license that can be
* found in the LICENSE file at https://angular.io/license
*)
@angular/common/fesm2022/common.mjs:
(**
* @license Angular v17.3.12
* (c) 2010-2024 Google LLC. https://angular.io/
* License: MIT
*)
@angular/common/fesm2022/http.mjs:
(**
* @license Angular v17.3.12
* (c) 2010-2024 Google LLC. https://angular.io/
* License: MIT
*)
@angular/platform-browser/fesm2022/platform-browser.mjs:
(**
* @license Angular v17.3.12
* (c) 2010-2024 Google LLC. https://angular.io/
* License: MIT
*)
@angular/router/fesm2022/router.mjs:
(**
* @license Angular v17.3.12
* (c) 2010-2024 Google LLC. https://angular.io/
* License: MIT
*)
@angular/forms/fesm2022/forms.mjs:
(**
* @license Angular v17.3.12
* (c) 2010-2024 Google LLC. https://angular.io/
* License: MIT
*)
@angular/core/fesm2022/rxjs-interop.mjs:
(**
* @license Angular v17.3.12
* (c) 2010-2024 Google LLC. https://angular.io/
* License: MIT
*)
*/
//# sourceMappingURL=main.js.map