+ if (!this.preserveMultipleSlashes) {
+ for (let i = 1; i < parts.length - 1; i++) {
+ const p = parts[i];
+ // don't squeeze out UNC patterns
+ if (i === 1 && p === '' && parts[0] === '')
+ continue;
+ if (p === '.' || p === '') {
+ didSomething = true;
+ parts.splice(i, 1);
+ i--;
+ }
+ }
+ if (parts[0] === '.' &&
+ parts.length === 2 &&
+ (parts[1] === '.' || parts[1] === '')) {
+ didSomething = true;
+ parts.pop();
+ }
+ }
+ // //../ -> /
+ let dd = 0;
+ while (-1 !== (dd = parts.indexOf('..', dd + 1))) {
+ const p = parts[dd - 1];
+ if (p &&
+ p !== '.' &&
+ p !== '..' &&
+ p !== '**' &&
+ !(this.isWindows && /^[a-z]:$/i.test(p))) {
+ didSomething = true;
+ parts.splice(dd - 1, 2);
+ dd -= 2;
+ }
+ }
+ } while (didSomething);
+ return parts.length === 0 ? [''] : parts;
+ }
+ // First phase: single-pattern processing
+ // is 1 or more portions
+ // is 1 or more portions
+ // is any portion other than ., .., '', or **
+ // is . or ''
+ //
+ // **/.. is *brutal* for filesystem walking performance, because
+ // it effectively resets the recursive walk each time it occurs,
+ // and ** cannot be reduced out by a .. pattern part like a regexp
+ // or most strings (other than .., ., and '') can be.
+ //
+ // /**/..//
/ -> {/..//
/,/**//
/}
+ // // -> /
+ // //../ -> /
+ // **/**/ -> **/
+ //
+ // **/*/ -> */**/ <== not valid because ** doesn't follow
+ // this WOULD be allowed if ** did follow symlinks, or * didn't
+ firstPhasePreProcess(globParts) {
+ let didSomething = false;
+ do {
+ didSomething = false;
+ // /**/..//
/ -> {/..//
/,/**//
/}
+ for (let parts of globParts) {
+ let gs = -1;
+ while (-1 !== (gs = parts.indexOf('**', gs + 1))) {
+ let gss = gs;
+ while (parts[gss + 1] === '**') {
+ // /**/**/ -> /**/
+ gss++;
+ }
+ // eg, if gs is 2 and gss is 4, that means we have 3 **
+ // parts, and can remove 2 of them.
+ if (gss > gs) {
+ parts.splice(gs + 1, gss - gs);
+ }
+ let next = parts[gs + 1];
+ const p = parts[gs + 2];
+ const p2 = parts[gs + 3];
+ if (next !== '..')
+ continue;
+ if (!p ||
+ p === '.' ||
+ p === '..' ||
+ !p2 ||
+ p2 === '.' ||
+ p2 === '..') {
+ continue;
+ }
+ didSomething = true;
+ // edit parts in place, and push the new one
+ parts.splice(gs, 1);
+ const other = parts.slice(0);
+ other[gs] = '**';
+ globParts.push(other);
+ gs--;
+ }
+ // // -> /
+ if (!this.preserveMultipleSlashes) {
+ for (let i = 1; i < parts.length - 1; i++) {
+ const p = parts[i];
+ // don't squeeze out UNC patterns
+ if (i === 1 && p === '' && parts[0] === '')
+ continue;
+ if (p === '.' || p === '') {
+ didSomething = true;
+ parts.splice(i, 1);
+ i--;
+ }
+ }
+ if (parts[0] === '.' &&
+ parts.length === 2 &&
+ (parts[1] === '.' || parts[1] === '')) {
+ didSomething = true;
+ parts.pop();
+ }
+ }
+ // //../ -> /
+ let dd = 0;
+ while (-1 !== (dd = parts.indexOf('..', dd + 1))) {
+ const p = parts[dd - 1];
+ if (p && p !== '.' && p !== '..' && p !== '**') {
+ didSomething = true;
+ const needDot = dd === 1 && parts[dd + 1] === '**';
+ const splin = needDot ? ['.'] : [];
+ parts.splice(dd - 1, 2, ...splin);
+ if (parts.length === 0)
+ parts.push('');
+ dd -= 2;
+ }
+ }
+ }
+ } while (didSomething);
+ return globParts;
+ }
+ // second phase: multi-pattern dedupes
+ // {/*/,//} -> /*/
+ // {/,/} -> /
+ // {/**/,/} -> /**/
+ //
+ // {/**/,/**//} -> /**/
+ // ^-- not valid because ** doens't follow symlinks
+ secondPhasePreProcess(globParts) {
+ for (let i = 0; i < globParts.length - 1; i++) {
+ for (let j = i + 1; j < globParts.length; j++) {
+ const matched = this.partsMatch(globParts[i], globParts[j], !this.preserveMultipleSlashes);
+ if (matched) {
+ globParts[i] = [];
+ globParts[j] = matched;
+ break;
+ }
+ }
+ }
+ return globParts.filter(gs => gs.length);
+ }
+ partsMatch(a, b, emptyGSMatch = false) {
+ let ai = 0;
+ let bi = 0;
+ let result = [];
+ let which = '';
+ while (ai < a.length && bi < b.length) {
+ if (a[ai] === b[bi]) {
+ result.push(which === 'b' ? b[bi] : a[ai]);
+ ai++;
+ bi++;
+ }
+ else if (emptyGSMatch && a[ai] === '**' && b[bi] === a[ai + 1]) {
+ result.push(a[ai]);
+ ai++;
+ }
+ else if (emptyGSMatch && b[bi] === '**' && a[ai] === b[bi + 1]) {
+ result.push(b[bi]);
+ bi++;
+ }
+ else if (a[ai] === '*' &&
+ b[bi] &&
+ (this.options.dot || !b[bi].startsWith('.')) &&
+ b[bi] !== '**') {
+ if (which === 'b')
+ return false;
+ which = 'a';
+ result.push(a[ai]);
+ ai++;
+ bi++;
+ }
+ else if (b[bi] === '*' &&
+ a[ai] &&
+ (this.options.dot || !a[ai].startsWith('.')) &&
+ a[ai] !== '**') {
+ if (which === 'a')
+ return false;
+ which = 'b';
+ result.push(b[bi]);
+ ai++;
+ bi++;
+ }
+ else {
+ return false;
+ }
+ }
+ // if we fall out of the loop, it means they two are identical
+ // as long as their lengths match
+ return a.length === b.length && result;
+ }
+ parseNegate() {
+ if (this.nonegate)
+ return;
+ const pattern = this.pattern;
+ let negate = false;
+ let negateOffset = 0;
+ for (let i = 0; i < pattern.length && pattern.charAt(i) === '!'; i++) {
+ negate = !negate;
+ negateOffset++;
+ }
+ if (negateOffset)
+ this.pattern = pattern.slice(negateOffset);
+ this.negate = negate;
+ }
+ // set partial to true to test if, for example,
+ // "/a/b" matches the start of "/*/b/*/d"
+ // Partial means, if you run out of file before you run
+ // out of pattern, then that's fine, as long as all
+ // the parts match.
+ matchOne(file, pattern, partial = false) {
+ let fileStartIndex = 0;
+ let patternStartIndex = 0;
+ // UNC paths like //?/X:/... can match X:/... and vice versa
+ // Drive letters in absolute drive or unc paths are always compared
+ // case-insensitively.
+ if (this.isWindows) {
+ const fileDrive = typeof file[0] === 'string' && /^[a-z]:$/i.test(file[0]);
+ const fileUNC = !fileDrive &&
+ file[0] === '' &&
+ file[1] === '' &&
+ file[2] === '?' &&
+ /^[a-z]:$/i.test(file[3]);
+ const patternDrive = typeof pattern[0] === 'string' && /^[a-z]:$/i.test(pattern[0]);
+ const patternUNC = !patternDrive &&
+ pattern[0] === '' &&
+ pattern[1] === '' &&
+ pattern[2] === '?' &&
+ typeof pattern[3] === 'string' &&
+ /^[a-z]:$/i.test(pattern[3]);
+ const fdi = fileUNC ? 3
+ : fileDrive ? 0
+ : undefined;
+ const pdi = patternUNC ? 3
+ : patternDrive ? 0
+ : undefined;
+ if (typeof fdi === 'number' && typeof pdi === 'number') {
+ const [fd, pd] = [
+ file[fdi],
+ pattern[pdi],
+ ];
+ // start matching at the drive letter index of each
+ if (fd.toLowerCase() === pd.toLowerCase()) {
+ pattern[pdi] = fd;
+ patternStartIndex = pdi;
+ fileStartIndex = fdi;
+ }
+ }
+ }
+ // resolve and reduce . and .. portions in the file as well.
+ // don't need to do the second phase, because it's only one string[]
+ const { optimizationLevel = 1 } = this.options;
+ if (optimizationLevel >= 2) {
+ file = this.levelTwoFileOptimize(file);
+ }
+ if (pattern.includes(GLOBSTAR)) {
+ return this.#matchGlobstar(file, pattern, partial, fileStartIndex, patternStartIndex);
+ }
+ return this.#matchOne(file, pattern, partial, fileStartIndex, patternStartIndex);
+ }
+ #matchGlobstar(file, pattern, partial, fileIndex, patternIndex) {
+ // split the pattern into head, tail, and middle of ** delimited parts
+ const firstgs = pattern.indexOf(GLOBSTAR, patternIndex);
+ const lastgs = pattern.lastIndexOf(GLOBSTAR);
+ // split the pattern up into globstar-delimited sections
+ // the tail has to be at the end, and the others just have
+ // to be found in order from the head.
+ const [head, body, tail] = partial ?
+ [
+ pattern.slice(patternIndex, firstgs),
+ pattern.slice(firstgs + 1),
+ [],
+ ]
+ : [
+ pattern.slice(patternIndex, firstgs),
+ pattern.slice(firstgs + 1, lastgs),
+ pattern.slice(lastgs + 1),
+ ];
+ // check the head, from the current file/pattern index.
+ if (head.length) {
+ const fileHead = file.slice(fileIndex, fileIndex + head.length);
+ if (!this.#matchOne(fileHead, head, partial, 0, 0)) {
+ return false;
+ }
+ fileIndex += head.length;
+ patternIndex += head.length;
+ }
+ // now we know the head matches!
+ // if the last portion is not empty, it MUST match the end
+ // check the tail
+ let fileTailMatch = 0;
+ if (tail.length) {
+ // if head + tail > file, then we cannot possibly match
+ if (tail.length + fileIndex > file.length)
+ return false;
+ // try to match the tail
+ let tailStart = file.length - tail.length;
+ if (this.#matchOne(file, tail, partial, tailStart, 0)) {
+ fileTailMatch = tail.length;
+ }
+ else {
+ // affordance for stuff like a/**/* matching a/b/
+ // if the last file portion is '', and there's more to the pattern
+ // then try without the '' bit.
+ if (file[file.length - 1] !== '' ||
+ fileIndex + tail.length === file.length) {
+ return false;
+ }
+ tailStart--;
+ if (!this.#matchOne(file, tail, partial, tailStart, 0)) {
+ return false;
+ }
+ fileTailMatch = tail.length + 1;
+ }
+ }
+ // now we know the tail matches!
+ // the middle is zero or more portions wrapped in **, possibly
+ // containing more ** sections.
+ // so a/**/b/**/c/**/d has become **/b/**/c/**
+ // if it's empty, it means a/**/b, just verify we have no bad dots
+ // if there's no tail, so it ends on /**, then we must have *something*
+ // after the head, or it's not a matc
+ if (!body.length) {
+ let sawSome = !!fileTailMatch;
+ for (let i = fileIndex; i < file.length - fileTailMatch; i++) {
+ const f = String(file[i]);
+ sawSome = true;
+ if (f === '.' ||
+ f === '..' ||
+ (!this.options.dot && f.startsWith('.'))) {
+ return false;
+ }
+ }
+ // in partial mode, we just need to get past all file parts
+ return partial || sawSome;
+ }
+ // now we know that there's one or more body sections, which can
+ // be matched anywhere from the 0 index (because the head was pruned)
+ // through to the length-fileTailMatch index.
+ // split the body up into sections, and note the minimum index it can
+ // be found at (start with the length of all previous segments)
+ // [section, before, after]
+ const bodySegments = [[[], 0]];
+ let currentBody = bodySegments[0];
+ let nonGsParts = 0;
+ const nonGsPartsSums = [0];
+ for (const b of body) {
+ if (b === GLOBSTAR) {
+ nonGsPartsSums.push(nonGsParts);
+ currentBody = [[], 0];
+ bodySegments.push(currentBody);
+ }
+ else {
+ currentBody[0].push(b);
+ nonGsParts++;
+ }
+ }
+ let i = bodySegments.length - 1;
+ const fileLength = file.length - fileTailMatch;
+ for (const b of bodySegments) {
+ b[1] = fileLength - (nonGsPartsSums[i--] + b[0].length);
+ }
+ return !!this.#matchGlobStarBodySections(file, bodySegments, fileIndex, 0, partial, 0, !!fileTailMatch);
+ }
+ // return false for "nope, not matching"
+ // return null for "not matching, cannot keep trying"
+ #matchGlobStarBodySections(file,
+ // pattern section, last possible position for it
+ bodySegments, fileIndex, bodyIndex, partial, globStarDepth, sawTail) {
+ // take the first body segment, and walk from fileIndex to its "after"
+ // value at the end
+ // If it doesn't match at that position, we increment, until we hit
+ // that final possible position, and give up.
+ // If it does match, then advance and try to rest.
+ // If any of them fail we keep walking forward.
+ // this is still a bit recursively painful, but it's more constrained
+ // than previous implementations, because we never test something that
+ // can't possibly be a valid matching condition.
+ const bs = bodySegments[bodyIndex];
+ if (!bs) {
+ // just make sure that there's no bad dots
+ for (let i = fileIndex; i < file.length; i++) {
+ sawTail = true;
+ const f = file[i];
+ if (f === '.' ||
+ f === '..' ||
+ (!this.options.dot && f.startsWith('.'))) {
+ return false;
+ }
+ }
+ return sawTail;
+ }
+ // have a non-globstar body section to test
+ const [body, after] = bs;
+ while (fileIndex <= after) {
+ const m = this.#matchOne(file.slice(0, fileIndex + body.length), body, partial, fileIndex, 0);
+ // if limit exceeded, no match. intentional false negative,
+ // acceptable break in correctness for security.
+ if (m && globStarDepth < this.maxGlobstarRecursion) {
+ // match! see if the rest match. if so, we're done!
+ const sub = this.#matchGlobStarBodySections(file, bodySegments, fileIndex + body.length, bodyIndex + 1, partial, globStarDepth + 1, sawTail);
+ if (sub !== false) {
+ return sub;
+ }
+ }
+ const f = file[fileIndex];
+ if (f === '.' ||
+ f === '..' ||
+ (!this.options.dot && f.startsWith('.'))) {
+ return false;
+ }
+ fileIndex++;
+ }
+ // walked off. no point continuing
+ return partial || null;
+ }
+ #matchOne(file, pattern, partial, fileIndex, patternIndex) {
+ let fi;
+ let pi;
+ let pl;
+ let fl;
+ for (fi = fileIndex,
+ pi = patternIndex,
+ fl = file.length,
+ pl = pattern.length; fi < fl && pi < pl; fi++, pi++) {
+ this.debug('matchOne loop');
+ let p = pattern[pi];
+ let f = file[fi];
+ this.debug(pattern, p, f);
+ // should be impossible.
+ // some invalid regexp stuff in the set.
+ /* c8 ignore start */
+ if (p === false || p === GLOBSTAR) {
+ return false;
+ }
+ /* c8 ignore stop */
+ // something other than **
+ // non-magic patterns just have to match exactly
+ // patterns with magic have been turned into regexps.
+ let hit;
+ if (typeof p === 'string') {
+ hit = f === p;
+ this.debug('string match', p, f, hit);
+ }
+ else {
+ hit = p.test(f);
+ this.debug('pattern match', p, f, hit);
+ }
+ if (!hit)
+ return false;
+ }
+ // Note: ending in / means that we'll get a final ""
+ // at the end of the pattern. This can only match a
+ // corresponding "" at the end of the file.
+ // If the file ends in /, then it can only match a
+ // a pattern that ends in /, unless the pattern just
+ // doesn't have any more for it. But, a/b/ should *not*
+ // match "a/b/*", even though "" matches against the
+ // [^/]*? pattern, except in partial mode, where it might
+ // simply not be reached yet.
+ // However, a/b/ should still satisfy a/*
+ // now either we fell off the end of the pattern, or we're done.
+ if (fi === fl && pi === pl) {
+ // ran out of pattern and filename at the same time.
+ // an exact hit!
+ return true;
+ }
+ else if (fi === fl) {
+ // ran out of file, but still had pattern left.
+ // this is ok if we're doing the match as part of
+ // a glob fs traversal.
+ return partial;
+ }
+ else if (pi === pl) {
+ // ran out of pattern, still have file left.
+ // this is only acceptable if we're on the very last
+ // empty segment of a file with a trailing slash.
+ // a/* should match a/b/
+ return fi === fl - 1 && file[fi] === '';
+ /* c8 ignore start */
+ }
+ else {
+ // should be unreachable.
+ throw new Error('wtf?');
+ }
+ /* c8 ignore stop */
+ }
+ braceExpand() {
+ return braceExpand(this.pattern, this.options);
+ }
+ parse(pattern) {
+ assertValidPattern(pattern);
+ const options = this.options;
+ // shortcuts
+ if (pattern === '**')
+ return GLOBSTAR;
+ if (pattern === '')
+ return '';
+ // far and away, the most common glob pattern parts are
+ // *, *.*, and *. Add a fast check method for those.
+ let m;
+ let fastTest = null;
+ if ((m = pattern.match(starRE))) {
+ fastTest = options.dot ? starTestDot : starTest;
+ }
+ else if ((m = pattern.match(starDotExtRE))) {
+ fastTest = (options.nocase ?
+ options.dot ?
+ starDotExtTestNocaseDot
+ : starDotExtTestNocase
+ : options.dot ? starDotExtTestDot
+ : starDotExtTest)(m[1]);
+ }
+ else if ((m = pattern.match(qmarksRE))) {
+ fastTest = (options.nocase ?
+ options.dot ?
+ qmarksTestNocaseDot
+ : qmarksTestNocase
+ : options.dot ? qmarksTestDot
+ : qmarksTest)(m);
+ }
+ else if ((m = pattern.match(starDotStarRE))) {
+ fastTest = options.dot ? starDotStarTestDot : starDotStarTest;
+ }
+ else if ((m = pattern.match(dotStarRE))) {
+ fastTest = dotStarTest;
+ }
+ const re = AST.fromGlob(pattern, this.options).toMMPattern();
+ if (fastTest && typeof re === 'object') {
+ // Avoids overriding in frozen environments
+ Reflect.defineProperty(re, 'test', { value: fastTest });
+ }
+ return re;
+ }
+ makeRe() {
+ if (this.regexp || this.regexp === false)
+ return this.regexp;
+ // at this point, this.set is a 2d array of partial
+ // pattern strings, or "**".
+ //
+ // It's better to use .match(). This function shouldn't
+ // be used, really, but it's pretty convenient sometimes,
+ // when you just want to work with a regex.
+ const set = this.set;
+ if (!set.length) {
+ this.regexp = false;
+ return this.regexp;
+ }
+ const options = this.options;
+ const twoStar = options.noglobstar ? esm_star
+ : options.dot ? twoStarDot
+ : twoStarNoDot;
+ const flags = new Set(options.nocase ? ['i'] : []);
+ // regexpify non-globstar patterns
+ // if ** is only item, then we just do one twoStar
+ // if ** is first, and there are more, prepend (\/|twoStar\/)? to next
+ // if ** is last, append (\/twoStar|) to previous
+ // if ** is in the middle, append (\/|\/twoStar\/) to previous
+ // then filter out GLOBSTAR symbols
+ let re = set
+ .map(pattern => {
+ const pp = pattern.map(p => {
+ if (p instanceof RegExp) {
+ for (const f of p.flags.split(''))
+ flags.add(f);
+ }
+ return (typeof p === 'string' ? esm_regExpEscape(p)
+ : p === GLOBSTAR ? GLOBSTAR
+ : p._src);
+ });
+ pp.forEach((p, i) => {
+ const next = pp[i + 1];
+ const prev = pp[i - 1];
+ if (p !== GLOBSTAR || prev === GLOBSTAR) {
+ return;
+ }
+ if (prev === undefined) {
+ if (next !== undefined && next !== GLOBSTAR) {
+ pp[i + 1] = '(?:\\/|' + twoStar + '\\/)?' + next;
+ }
+ else {
+ pp[i] = twoStar;
+ }
+ }
+ else if (next === undefined) {
+ pp[i - 1] = prev + '(?:\\/|\\/' + twoStar + ')?';
+ }
+ else if (next !== GLOBSTAR) {
+ pp[i - 1] = prev + '(?:\\/|\\/' + twoStar + '\\/)' + next;
+ pp[i + 1] = GLOBSTAR;
+ }
+ });
+ const filtered = pp.filter(p => p !== GLOBSTAR);
+ // For partial matches, we need to make the pattern match
+ // any prefix of the full path. We do this by generating
+ // alternative patterns that match progressively longer prefixes.
+ if (this.partial && filtered.length >= 1) {
+ const prefixes = [];
+ for (let i = 1; i <= filtered.length; i++) {
+ prefixes.push(filtered.slice(0, i).join('/'));
+ }
+ return '(?:' + prefixes.join('|') + ')';
+ }
+ return filtered.join('/');
+ })
+ .join('|');
+ // need to wrap in parens if we had more than one thing with |,
+ // otherwise only the first will be anchored to ^ and the last to $
+ const [open, close] = set.length > 1 ? ['(?:', ')'] : ['', ''];
+ // must match entire pattern
+ // ending in a * or ** will make it less strict.
+ re = '^' + open + re + close + '$';
+ // In partial mode, '/' should always match as it's a valid prefix for any pattern
+ if (this.partial) {
+ re = '^(?:\\/|' + open + re.slice(1, -1) + close + ')$';
+ }
+ // can match anything, as long as it's not this.
+ if (this.negate)
+ re = '^(?!' + re + ').+$';
+ try {
+ this.regexp = new RegExp(re, [...flags].join(''));
+ /* c8 ignore start */
+ }
+ catch {
+ // should be impossible
+ this.regexp = false;
+ }
+ /* c8 ignore stop */
+ return this.regexp;
+ }
+ slashSplit(p) {
+ // if p starts with // on windows, we preserve that
+ // so that UNC paths aren't broken. Otherwise, any number of
+ // / characters are coalesced into one, unless
+ // preserveMultipleSlashes is set to true.
+ if (this.preserveMultipleSlashes) {
+ return p.split('/');
+ }
+ else if (this.isWindows && /^\/\/[^/]+/.test(p)) {
+ // add an extra '' for the one we lose
+ return ['', ...p.split(/\/+/)];
+ }
+ else {
+ return p.split(/\/+/);
+ }
+ }
+ match(f, partial = this.partial) {
+ this.debug('match', f, this.pattern);
+ // short-circuit in the case of busted things.
+ // comments, etc.
+ if (this.comment) {
+ return false;
+ }
+ if (this.empty) {
+ return f === '';
+ }
+ if (f === '/' && partial) {
+ return true;
+ }
+ const options = this.options;
+ // windows: need to use /, not \
+ if (this.isWindows) {
+ f = f.split('\\').join('/');
+ }
+ // treat the test path as a set of pathparts.
+ const ff = this.slashSplit(f);
+ this.debug(this.pattern, 'split', ff);
+ // just ONE of the pattern sets in this.set needs to match
+ // in order for it to be valid. If negating, then just one
+ // match means that we have failed.
+ // Either way, return on the first hit.
+ const set = this.set;
+ this.debug(this.pattern, 'set', set);
+ // Find the basename of the path by looking for the last non-empty segment
+ let filename = ff[ff.length - 1];
+ if (!filename) {
+ for (let i = ff.length - 2; !filename && i >= 0; i--) {
+ filename = ff[i];
+ }
+ }
+ for (const pattern of set) {
+ let file = ff;
+ if (options.matchBase && pattern.length === 1) {
+ file = [filename];
+ }
+ const hit = this.matchOne(file, pattern, partial);
+ if (hit) {
+ if (options.flipNegate) {
+ return true;
+ }
+ return !this.negate;
+ }
+ }
+ // didn't get any hits. this is success if it's a negative
+ // pattern, failure otherwise.
+ if (options.flipNegate) {
+ return false;
+ }
+ return this.negate;
+ }
+ static defaults(def) {
+ return minimatch.defaults(def).Minimatch;
+ }
+}
+/* c8 ignore start */
+
+
+
+/* c8 ignore stop */
+minimatch.AST = AST;
+minimatch.Minimatch = Minimatch;
+minimatch.escape = escape_escape;
+minimatch.unescape = unescape_unescape;
+//# sourceMappingURL=index.js.map
+;// CONCATENATED MODULE: ./node_modules/@actions/glob/lib/internal-path.js
+
+
+
+const internal_path_IS_WINDOWS = process.platform === 'win32';
+/**
+ * Helper class for parsing paths into segments
+ */
+class Path {
+ /**
+ * Constructs a Path
+ * @param itemPath Path or array of segments
+ */
+ constructor(itemPath) {
+ this.segments = [];
+ // String
+ if (typeof itemPath === 'string') {
+ external_assert_(itemPath, `Parameter 'itemPath' must not be empty`);
+ // Normalize slashes and trim unnecessary trailing slash
+ itemPath = safeTrimTrailingSeparator(itemPath);
+ // Not rooted
+ if (!hasRoot(itemPath)) {
+ this.segments = itemPath.split(external_path_.sep);
+ }
+ // Rooted
+ else {
+ // Add all segments, while not at the root
+ let remaining = itemPath;
+ let dir = dirname(remaining);
+ while (dir !== remaining) {
+ // Add the segment
+ const basename = external_path_.basename(remaining);
+ this.segments.unshift(basename);
+ // Truncate the last segment
+ remaining = dir;
+ dir = dirname(remaining);
+ }
+ // Remainder is the root
+ this.segments.unshift(remaining);
+ }
+ }
+ // Array
+ else {
+ // Must not be empty
+ external_assert_(itemPath.length > 0, `Parameter 'itemPath' must not be an empty array`);
+ // Each segment
+ for (let i = 0; i < itemPath.length; i++) {
+ let segment = itemPath[i];
+ // Must not be empty
+ external_assert_(segment, `Parameter 'itemPath' must not contain any empty segments`);
+ // Normalize slashes
+ segment = normalizeSeparators(itemPath[i]);
+ // Root segment
+ if (i === 0 && hasRoot(segment)) {
+ segment = safeTrimTrailingSeparator(segment);
+ external_assert_(segment === dirname(segment), `Parameter 'itemPath' root segment contains information for multiple segments`);
+ this.segments.push(segment);
+ }
+ // All other segments
+ else {
+ // Must not contain slash
+ external_assert_(!segment.includes(external_path_.sep), `Parameter 'itemPath' contains unexpected path separators`);
+ this.segments.push(segment);
+ }
+ }
+ }
+ }
+ /**
+ * Converts the path to it's string representation
+ */
+ toString() {
+ // First segment
+ let result = this.segments[0];
+ // All others
+ let skipSlash = result.endsWith(external_path_.sep) || (internal_path_IS_WINDOWS && /^[A-Z]:$/i.test(result));
+ for (let i = 1; i < this.segments.length; i++) {
+ if (skipSlash) {
+ skipSlash = false;
+ }
+ else {
+ result += external_path_.sep;
+ }
+ result += this.segments[i];
+ }
+ return result;
+ }
+}
+//# sourceMappingURL=internal-path.js.map
+;// CONCATENATED MODULE: ./node_modules/@actions/glob/lib/internal-pattern.js
+
+
+
+
+
+
+
+const internal_pattern_IS_WINDOWS = process.platform === 'win32';
+class Pattern {
+ constructor(patternOrNegate, isImplicitPattern = false, segments, homedir) {
+ /**
+ * Indicates whether matches should be excluded from the result set
+ */
+ this.negate = false;
+ // Pattern overload
+ let pattern;
+ if (typeof patternOrNegate === 'string') {
+ pattern = patternOrNegate.trim();
+ }
+ // Segments overload
+ else {
+ // Convert to pattern
+ segments = segments || [];
+ external_assert_(segments.length, `Parameter 'segments' must not empty`);
+ const root = Pattern.getLiteral(segments[0]);
+ external_assert_(root && hasAbsoluteRoot(root), `Parameter 'segments' first element must be a root path`);
+ pattern = new Path(segments).toString().trim();
+ if (patternOrNegate) {
+ pattern = `!${pattern}`;
+ }
+ }
+ // Negate
+ while (pattern.startsWith('!')) {
+ this.negate = !this.negate;
+ pattern = pattern.substr(1).trim();
+ }
+ // Normalize slashes and ensures absolute root
+ pattern = Pattern.fixupPattern(pattern, homedir);
+ // Segments
+ this.segments = new Path(pattern).segments;
+ // Trailing slash indicates the pattern should only match directories, not regular files
+ this.trailingSeparator = normalizeSeparators(pattern)
+ .endsWith(external_path_.sep);
+ pattern = safeTrimTrailingSeparator(pattern);
+ // Search path (literal path prior to the first glob segment)
+ let foundGlob = false;
+ const searchSegments = this.segments
+ .map(x => Pattern.getLiteral(x))
+ .filter(x => !foundGlob && !(foundGlob = x === ''));
+ this.searchPath = new Path(searchSegments).toString();
+ // Root RegExp (required when determining partial match)
+ this.rootRegExp = new RegExp(Pattern.regExpEscape(searchSegments[0]), internal_pattern_IS_WINDOWS ? 'i' : '');
+ this.isImplicitPattern = isImplicitPattern;
+ // Create minimatch
+ const minimatchOptions = {
+ dot: true,
+ nobrace: true,
+ nocase: internal_pattern_IS_WINDOWS,
+ nocomment: true,
+ noext: true,
+ nonegate: true
+ };
+ pattern = internal_pattern_IS_WINDOWS ? pattern.replace(/\\/g, '/') : pattern;
+ this.minimatch = new Minimatch(pattern, minimatchOptions);
+ }
+ /**
+ * Matches the pattern against the specified path
+ */
+ match(itemPath) {
+ // Last segment is globstar?
+ if (this.segments[this.segments.length - 1] === '**') {
+ // Normalize slashes
+ itemPath = normalizeSeparators(itemPath);
+ // Append a trailing slash. Otherwise Minimatch will not match the directory immediately
+ // preceding the globstar. For example, given the pattern `/foo/**`, Minimatch returns
+ // false for `/foo` but returns true for `/foo/`. Append a trailing slash to handle that quirk.
+ if (!itemPath.endsWith(external_path_.sep) && this.isImplicitPattern === false) {
+ // Note, this is safe because the constructor ensures the pattern has an absolute root.
+ // For example, formats like C: and C:foo on Windows are resolved to an absolute root.
+ itemPath = `${itemPath}${external_path_.sep}`;
+ }
+ }
+ else {
+ // Normalize slashes and trim unnecessary trailing slash
+ itemPath = safeTrimTrailingSeparator(itemPath);
+ }
+ // Match
+ if (this.minimatch.match(itemPath)) {
+ return this.trailingSeparator ? MatchKind.Directory : MatchKind.All;
+ }
+ return MatchKind.None;
+ }
+ /**
+ * Indicates whether the pattern may match descendants of the specified path
+ */
+ partialMatch(itemPath) {
+ // Normalize slashes and trim unnecessary trailing slash
+ itemPath = safeTrimTrailingSeparator(itemPath);
+ // matchOne does not handle root path correctly
+ if (dirname(itemPath) === itemPath) {
+ return this.rootRegExp.test(itemPath);
+ }
+ return this.minimatch.matchOne(itemPath.split(internal_pattern_IS_WINDOWS ? /\\+/ : /\/+/), this.minimatch.set[0], true);
+ }
+ /**
+ * Escapes glob patterns within a path
+ */
+ static globEscape(s) {
+ return (internal_pattern_IS_WINDOWS ? s : s.replace(/\\/g, '\\\\')) // escape '\' on Linux/macOS
+ .replace(/(\[)(?=[^/]+\])/g, '[[]') // escape '[' when ']' follows within the path segment
+ .replace(/\?/g, '[?]') // escape '?'
+ .replace(/\*/g, '[*]'); // escape '*'
+ }
+ /**
+ * Normalizes slashes and ensures absolute root
+ */
+ static fixupPattern(pattern, homedir) {
+ // Empty
+ external_assert_(pattern, 'pattern cannot be empty');
+ // Must not contain `.` segment, unless first segment
+ // Must not contain `..` segment
+ const literalSegments = new Path(pattern).segments.map(x => Pattern.getLiteral(x));
+ external_assert_(literalSegments.every((x, i) => (x !== '.' || i === 0) && x !== '..'), `Invalid pattern '${pattern}'. Relative pathing '.' and '..' is not allowed.`);
+ // Must not contain globs in root, e.g. Windows UNC path \\foo\b*r
+ external_assert_(!hasRoot(pattern) || literalSegments[0], `Invalid pattern '${pattern}'. Root segment must not contain globs.`);
+ // Normalize slashes
+ pattern = normalizeSeparators(pattern);
+ // Replace leading `.` segment
+ if (pattern === '.' || pattern.startsWith(`.${external_path_.sep}`)) {
+ pattern = Pattern.globEscape(process.cwd()) + pattern.substr(1);
+ }
+ // Replace leading `~` segment
+ else if (pattern === '~' || pattern.startsWith(`~${external_path_.sep}`)) {
+ homedir = homedir || external_os_.homedir();
+ external_assert_(homedir, 'Unable to determine HOME directory');
+ external_assert_(hasAbsoluteRoot(homedir), `Expected HOME directory to be a rooted path. Actual '${homedir}'`);
+ pattern = Pattern.globEscape(homedir) + pattern.substr(1);
+ }
+ // Replace relative drive root, e.g. pattern is C: or C:foo
+ else if (internal_pattern_IS_WINDOWS &&
+ (pattern.match(/^[A-Z]:$/i) || pattern.match(/^[A-Z]:[^\\]/i))) {
+ let root = ensureAbsoluteRoot('C:\\dummy-root', pattern.substr(0, 2));
+ if (pattern.length > 2 && !root.endsWith('\\')) {
+ root += '\\';
+ }
+ pattern = Pattern.globEscape(root) + pattern.substr(2);
+ }
+ // Replace relative root, e.g. pattern is \ or \foo
+ else if (internal_pattern_IS_WINDOWS && (pattern === '\\' || pattern.match(/^\\[^\\]/))) {
+ let root = ensureAbsoluteRoot('C:\\dummy-root', '\\');
+ if (!root.endsWith('\\')) {
+ root += '\\';
+ }
+ pattern = Pattern.globEscape(root) + pattern.substr(1);
+ }
+ // Otherwise ensure absolute root
+ else {
+ pattern = ensureAbsoluteRoot(Pattern.globEscape(process.cwd()), pattern);
+ }
+ return normalizeSeparators(pattern);
+ }
+ /**
+ * Attempts to unescape a pattern segment to create a literal path segment.
+ * Otherwise returns empty string.
+ */
+ static getLiteral(segment) {
+ let literal = '';
+ for (let i = 0; i < segment.length; i++) {
+ const c = segment[i];
+ // Escape
+ if (c === '\\' && !internal_pattern_IS_WINDOWS && i + 1 < segment.length) {
+ literal += segment[++i];
+ continue;
+ }
+ // Wildcard
+ else if (c === '*' || c === '?') {
+ return '';
+ }
+ // Character set
+ else if (c === '[' && i + 1 < segment.length) {
+ let set = '';
+ let closed = -1;
+ for (let i2 = i + 1; i2 < segment.length; i2++) {
+ const c2 = segment[i2];
+ // Escape
+ if (c2 === '\\' && !internal_pattern_IS_WINDOWS && i2 + 1 < segment.length) {
+ set += segment[++i2];
+ continue;
+ }
+ // Closed
+ else if (c2 === ']') {
+ closed = i2;
+ break;
+ }
+ // Otherwise
+ else {
+ set += c2;
+ }
+ }
+ // Closed?
+ if (closed >= 0) {
+ // Cannot convert
+ if (set.length > 1) {
+ return '';
+ }
+ // Convert to literal
+ if (set) {
+ literal += set;
+ i = closed;
+ continue;
+ }
+ }
+ // Otherwise fall thru
+ }
+ // Append
+ literal += c;
+ }
+ return literal;
+ }
+ /**
+ * Escapes regexp special characters
+ * https://javascript.info/regexp-escaping
+ */
+ static regExpEscape(s) {
+ return s.replace(/[[\\^$.|?*+()]/g, '\\$&');
+ }
+}
+//# sourceMappingURL=internal-pattern.js.map
+;// CONCATENATED MODULE: ./node_modules/@actions/glob/lib/internal-search-state.js
+class SearchState {
+ constructor(path, level) {
+ this.path = path;
+ this.level = level;
+ }
+}
+//# sourceMappingURL=internal-search-state.js.map
+;// CONCATENATED MODULE: ./node_modules/@actions/glob/lib/internal-globber.js
+var __awaiter = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
+ function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+ return new (P || (P = Promise))(function (resolve, reject) {
+ function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+ function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+ function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+ step((generator = generator.apply(thisArg, _arguments || [])).next());
+ });
+};
+var __asyncValues = (undefined && undefined.__asyncValues) || function (o) {
+ if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+ var m = o[Symbol.asyncIterator], i;
+ return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+ function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+ function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+var __await = (undefined && undefined.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
+var __asyncGenerator = (undefined && undefined.__asyncGenerator) || function (thisArg, _arguments, generator) {
+ if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+ var g = generator.apply(thisArg, _arguments || []), i, q = [];
+ return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), 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(value) { resume("next", value); }
+ function reject(value) { resume("throw", value); }
+ function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+};
+
+
+
+
+
+
+
+
+const internal_globber_IS_WINDOWS = process.platform === 'win32';
+class DefaultGlobber {
+ constructor(options) {
+ this.patterns = [];
+ this.searchPaths = [];
+ this.options = getOptions(options);
+ }
+ getSearchPaths() {
+ // Return a copy
+ return this.searchPaths.slice();
+ }
+ glob() {
+ return __awaiter(this, void 0, void 0, function* () {
+ var _a, e_1, _b, _c;
+ const result = [];
+ try {
+ for (var _d = true, _e = __asyncValues(this.globGenerator()), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
+ _c = _f.value;
+ _d = false;
+ const itemPath = _c;
+ result.push(itemPath);
+ }
+ }
+ catch (e_1_1) { e_1 = { error: e_1_1 }; }
+ finally {
+ try {
+ if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
+ }
+ finally { if (e_1) throw e_1.error; }
+ }
+ return result;
+ });
+ }
+ globGenerator() {
+ return __asyncGenerator(this, arguments, function* globGenerator_1() {
+ // Fill in defaults options
+ const options = getOptions(this.options);
+ // Implicit descendants?
+ const patterns = [];
+ for (const pattern of this.patterns) {
+ patterns.push(pattern);
+ if (options.implicitDescendants &&
+ (pattern.trailingSeparator ||
+ pattern.segments[pattern.segments.length - 1] !== '**')) {
+ patterns.push(new Pattern(pattern.negate, true, pattern.segments.concat('**')));
+ }
+ }
+ // Push the search paths
+ const stack = [];
+ for (const searchPath of getSearchPaths(patterns)) {
+ core/* debug */.Yz(`Search path '${searchPath}'`);
+ // Exists?
+ try {
+ // Intentionally using lstat. Detection for broken symlink
+ // will be performed later (if following symlinks).
+ yield __await(external_fs_.promises.lstat(searchPath));
+ }
+ catch (err) {
+ if (err.code === 'ENOENT') {
+ continue;
+ }
+ throw err;
+ }
+ stack.unshift(new SearchState(searchPath, 1));
+ }
+ // Search
+ const traversalChain = []; // used to detect cycles
+ while (stack.length) {
+ // Pop
+ const item = stack.pop();
+ // Match?
+ const match = internal_pattern_helper_match(patterns, item.path);
+ const partialMatch = !!match || internal_pattern_helper_partialMatch(patterns, item.path);
+ if (!match && !partialMatch) {
+ continue;
+ }
+ // Stat
+ const stats = yield __await(DefaultGlobber.stat(item, options, traversalChain)
+ // Broken symlink, or symlink cycle detected, or no longer exists
+ );
+ // Broken symlink, or symlink cycle detected, or no longer exists
+ if (!stats) {
+ continue;
+ }
+ // Hidden file or directory?
+ if (options.excludeHiddenFiles && external_path_.basename(item.path).match(/^\./)) {
+ continue;
+ }
+ // Directory
+ if (stats.isDirectory()) {
+ // Matched
+ if (match & MatchKind.Directory && options.matchDirectories) {
+ yield yield __await(item.path);
+ }
+ // Descend?
+ else if (!partialMatch) {
+ continue;
+ }
+ // Push the child items in reverse
+ const childLevel = item.level + 1;
+ const childItems = (yield __await(external_fs_.promises.readdir(item.path))).map(x => new SearchState(external_path_.join(item.path, x), childLevel));
+ stack.push(...childItems.reverse());
+ }
+ // File
+ else if (match & MatchKind.File) {
+ yield yield __await(item.path);
+ }
+ }
+ });
+ }
+ /**
+ * Constructs a DefaultGlobber
+ */
+ static create(patterns, options) {
+ return __awaiter(this, void 0, void 0, function* () {
+ const result = new DefaultGlobber(options);
+ if (internal_globber_IS_WINDOWS) {
+ patterns = patterns.replace(/\r\n/g, '\n');
+ patterns = patterns.replace(/\r/g, '\n');
+ }
+ const lines = patterns.split('\n').map(x => x.trim());
+ for (const line of lines) {
+ // Empty or comment
+ if (!line || line.startsWith('#')) {
+ continue;
+ }
+ // Pattern
+ else {
+ result.patterns.push(new Pattern(line));
+ }
+ }
+ result.searchPaths.push(...getSearchPaths(result.patterns));
+ return result;
+ });
+ }
+ static stat(item, options, traversalChain) {
+ return __awaiter(this, void 0, void 0, function* () {
+ // Note:
+ // `stat` returns info about the target of a symlink (or symlink chain)
+ // `lstat` returns info about a symlink itself
+ let stats;
+ if (options.followSymbolicLinks) {
+ try {
+ // Use `stat` (following symlinks)
+ stats = yield external_fs_.promises.stat(item.path);
+ }
+ catch (err) {
+ if (err.code === 'ENOENT') {
+ if (options.omitBrokenSymbolicLinks) {
+ core/* debug */.Yz(`Broken symlink '${item.path}'`);
+ return undefined;
+ }
+ throw new Error(`No information found for the path '${item.path}'. This may indicate a broken symbolic link.`);
+ }
+ throw err;
+ }
+ }
+ else {
+ // Use `lstat` (not following symlinks)
+ stats = yield external_fs_.promises.lstat(item.path);
+ }
+ // Note, isDirectory() returns false for the lstat of a symlink
+ if (stats.isDirectory() && options.followSymbolicLinks) {
+ // Get the realpath
+ const realPath = yield external_fs_.promises.realpath(item.path);
+ // Fixup the traversal chain to match the item level
+ while (traversalChain.length >= item.level) {
+ traversalChain.pop();
+ }
+ // Test for a cycle
+ if (traversalChain.some((x) => x === realPath)) {
+ core/* debug */.Yz(`Symlink cycle detected for path '${item.path}' and realpath '${realPath}'`);
+ return undefined;
+ }
+ // Update the traversal chain
+ traversalChain.push(realPath);
+ }
+ return stats;
+ });
+ }
+}
+//# sourceMappingURL=internal-globber.js.map
+// EXTERNAL MODULE: external "crypto"
+var external_crypto_ = __webpack_require__(6982);
+// EXTERNAL MODULE: external "stream"
+var external_stream_ = __webpack_require__(2203);
+// EXTERNAL MODULE: external "util"
+var external_util_ = __webpack_require__(9023);
+;// CONCATENATED MODULE: ./node_modules/@actions/glob/lib/internal-hash-files.js
+var internal_hash_files_awaiter = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
+ function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+ return new (P || (P = Promise))(function (resolve, reject) {
+ function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+ function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+ function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+ step((generator = generator.apply(thisArg, _arguments || [])).next());
+ });
+};
+var internal_hash_files_asyncValues = (undefined && undefined.__asyncValues) || function (o) {
+ if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+ var m = o[Symbol.asyncIterator], i;
+ return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+ function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+ function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+
+
+
+
+
+
+function hashFiles(globber_1, currentWorkspace_1) {
+ return internal_hash_files_awaiter(this, arguments, void 0, function* (globber, currentWorkspace, verbose = false) {
+ var _a, e_1, _b, _c;
+ var _d;
+ const writeDelegate = verbose ? core/* info */.pq : core/* debug */.Yz;
+ let hasMatch = false;
+ const githubWorkspace = currentWorkspace
+ ? currentWorkspace
+ : ((_d = process.env['GITHUB_WORKSPACE']) !== null && _d !== void 0 ? _d : process.cwd());
+ const result = external_crypto_.createHash('sha256');
+ let count = 0;
+ try {
+ for (var _e = true, _f = internal_hash_files_asyncValues(globber.globGenerator()), _g; _g = yield _f.next(), _a = _g.done, !_a; _e = true) {
+ _c = _g.value;
+ _e = false;
+ const file = _c;
+ writeDelegate(file);
+ if (!file.startsWith(`${githubWorkspace}${external_path_.sep}`)) {
+ writeDelegate(`Ignore '${file}' since it is not under GITHUB_WORKSPACE.`);
+ continue;
+ }
+ if (external_fs_.statSync(file).isDirectory()) {
+ writeDelegate(`Skip directory '${file}'.`);
+ continue;
+ }
+ const hash = external_crypto_.createHash('sha256');
+ const pipeline = external_util_.promisify(external_stream_.pipeline);
+ yield pipeline(external_fs_.createReadStream(file), hash);
+ result.write(hash.digest());
+ count++;
+ if (!hasMatch) {
+ hasMatch = true;
+ }
+ }
+ }
+ catch (e_1_1) { e_1 = { error: e_1_1 }; }
+ finally {
+ try {
+ if (!_e && !_a && (_b = _f.return)) yield _b.call(_f);
+ }
+ finally { if (e_1) throw e_1.error; }
+ }
+ result.end();
+ if (hasMatch) {
+ writeDelegate(`Found ${count} files to hash.`);
+ return result.digest('hex');
+ }
+ else {
+ writeDelegate(`No matches found for glob`);
+ return '';
+ }
+ });
+}
+//# sourceMappingURL=internal-hash-files.js.map
+;// CONCATENATED MODULE: ./node_modules/@actions/glob/lib/glob.js
+var glob_awaiter = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
+ function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+ return new (P || (P = Promise))(function (resolve, reject) {
+ function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+ function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+ function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+ step((generator = generator.apply(thisArg, _arguments || [])).next());
+ });
+};
+
+
+/**
+ * Constructs a globber
+ *
+ * @param patterns Patterns separated by newlines
+ * @param options Glob options
+ */
+function create(patterns, options) {
+ return glob_awaiter(this, void 0, void 0, function* () {
+ return yield DefaultGlobber.create(patterns, options);
+ });
+}
+/**
+ * Computes the sha256 hash of a glob
+ *
+ * @param patterns Patterns separated by newlines
+ * @param currentWorkspace Workspace used when matching files
+ * @param options Glob options
+ * @param verbose Enables verbose logging
+ */
+function glob_hashFiles(patterns_1) {
+ return glob_awaiter(this, arguments, void 0, function* (patterns, currentWorkspace = '', options, verbose = false) {
+ let followSymbolicLinks = true;
+ if (options && typeof options.followSymbolicLinks === 'boolean') {
+ followSymbolicLinks = options.followSymbolicLinks;
+ }
+ const globber = yield create(patterns, { followSymbolicLinks });
+ return hashFiles(globber, currentWorkspace, verbose);
+ });
+}
+//# sourceMappingURL=glob.js.map
+
+/***/ }),
+
+/***/ 4012:
+/***/ ((module) => {
+
+module.exports = /*#__PURE__*/JSON.parse('{"name":"@actions/cache","version":"6.2.0","description":"Actions cache lib","keywords":["github","actions","cache"],"homepage":"https://github.com/actions/toolkit/tree/main/packages/cache","license":"MIT","type":"module","main":"lib/cache.js","types":"lib/cache.d.ts","exports":{".":{"types":"./lib/cache.d.ts","import":"./lib/cache.js"}},"directories":{"lib":"lib","test":"__tests__"},"files":["lib","!.DS_Store"],"publishConfig":{"access":"public"},"repository":{"type":"git","url":"git+https://github.com/actions/toolkit.git","directory":"packages/cache"},"scripts":{"audit-moderate":"npm install && npm audit --json --audit-level=moderate > audit.json","test":"echo \\"Error: run tests from root\\" && exit 1","tsc":"tsc && cp src/internal/shared/package-version.cjs lib/internal/shared/"},"bugs":{"url":"https://github.com/actions/toolkit/issues"},"dependencies":{"@actions/core":"^3.0.1","@actions/exec":"^3.0.0","@actions/glob":"^0.6.1","@actions/http-client":"^4.0.1","@actions/io":"^3.0.2","@azure/core-rest-pipeline":"^1.23.0","@azure/storage-blob":"^12.31.0","@protobuf-ts/runtime-rpc":"^2.11.1","semver":"^7.7.4"},"devDependencies":{"@protobuf-ts/plugin":"^2.11.1","@types/node":"^25.6.0","@types/semver":"^7.7.1","typescript":"^5.9.3"},"overrides":{"uri-js":"npm:uri-js-replace@^1.0.1","node-fetch":"^3.3.2"}}');
+
+/***/ })
+
+};
diff --git a/dist/setup/index.js b/dist/setup/index.js
index 9f4be9b9..3b8ef45c 100644
--- a/dist/setup/index.js
+++ b/dist/setup/index.js
@@ -1,21510 +1,6 @@
import { createRequire as __WEBPACK_EXTERNAL_createRequire } from "module";
/******/ var __webpack_modules__ = ({
-/***/ 5878:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.abort_add = abort_add;
-exports.abort_remove = abort_remove;
-exports.abort_signalAbort = abort_signalAbort;
-const EventAlgorithm_1 = __nccwpck_require__(8012);
-/**
- * Adds an algorithm to the given abort signal.
- *
- * @param algorithm - an algorithm
- * @param signal - abort signal
- */
-function abort_add(algorithm, signal) {
- /**
- * 1. If signal’s aborted flag is set, then return.
- * 2. Append algorithm to signal’s abort algorithms.
- */
- if (signal._abortedFlag)
- return;
- signal._abortAlgorithms.add(algorithm);
-}
-/**
- * Removes an algorithm from the given abort signal.
- *
- * @param algorithm - an algorithm
- * @param signal - abort signal
- */
-function abort_remove(algorithm, signal) {
- /**
- * To remove an algorithm algorithm from an AbortSignal signal, remove
- * algorithm from signal’s abort algorithms.
- */
- signal._abortAlgorithms.delete(algorithm);
-}
-/**
- * Signals abort on the given abort signal.
- *
- * @param signal - abort signal
- */
-function abort_signalAbort(signal) {
- /**
- * 1. If signal’s aborted flag is set, then return.
- * 2. Set signal’s aborted flag.
- * 3. For each algorithm in signal’s abort algorithms: run algorithm.
- * 4. Empty signal’s abort algorithms.
- * 5. Fire an event named abort at signal.
- */
- if (signal._abortedFlag)
- return;
- signal._abortedFlag = true;
- for (const algorithm of signal._abortAlgorithms) {
- algorithm.call(signal);
- }
- signal._abortAlgorithms.clear();
- (0, EventAlgorithm_1.event_fireAnEvent)("abort", signal);
-}
-//# sourceMappingURL=AbortAlgorithm.js.map
-
-/***/ }),
-
-/***/ 8365:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.attr_setAnExistingAttributeValue = attr_setAnExistingAttributeValue;
-const ElementAlgorithm_1 = __nccwpck_require__(2720);
-/**
- * Changes the value of an existing attribute.
- *
- * @param attribute - an attribute node
- * @param value - attribute value
- */
-function attr_setAnExistingAttributeValue(attribute, value) {
- /**
- * 1. If attribute’s element is null, then set attribute’s value to value.
- * 2. Otherwise, change attribute from attribute’s element to value.
- */
- if (attribute._element === null) {
- attribute._value = value;
- }
- else {
- (0, ElementAlgorithm_1.element_change)(attribute, attribute._element, value);
- }
-}
-//# sourceMappingURL=AttrAlgorithm.js.map
-
-/***/ }),
-
-/***/ 8652:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.boundaryPoint_position = boundaryPoint_position;
-const interfaces_1 = __nccwpck_require__(9454);
-const TreeAlgorithm_1 = __nccwpck_require__(3532);
-/**
- * Defines the position of a boundary point relative to another.
- *
- * @param bp - a boundary point
- * @param relativeTo - a boundary point to compare to
- */
-function boundaryPoint_position(bp, relativeTo) {
- const nodeA = bp[0];
- const offsetA = bp[1];
- const nodeB = relativeTo[0];
- const offsetB = relativeTo[1];
- /**
- * 1. Assert: nodeA and nodeB have the same root.
- */
- console.assert((0, TreeAlgorithm_1.tree_rootNode)(nodeA) === (0, TreeAlgorithm_1.tree_rootNode)(nodeB), "Boundary points must share the same root node.");
- /**
- * 2. If nodeA is nodeB, then return equal if offsetA is offsetB, before
- * if offsetA is less than offsetB, and after if offsetA is greater than
- * offsetB.
- */
- if (nodeA === nodeB) {
- if (offsetA === offsetB) {
- return interfaces_1.BoundaryPosition.Equal;
- }
- else if (offsetA < offsetB) {
- return interfaces_1.BoundaryPosition.Before;
- }
- else {
- return interfaces_1.BoundaryPosition.After;
- }
- }
- /**
- * 3. If nodeA is following nodeB, then if the position of (nodeB, offsetB)
- * relative to (nodeA, offsetA) is before, return after, and if it is after,
- * return before.
- */
- if ((0, TreeAlgorithm_1.tree_isFollowing)(nodeB, nodeA)) {
- const pos = boundaryPoint_position([nodeB, offsetB], [nodeA, offsetA]);
- if (pos === interfaces_1.BoundaryPosition.Before) {
- return interfaces_1.BoundaryPosition.After;
- }
- else if (pos === interfaces_1.BoundaryPosition.After) {
- return interfaces_1.BoundaryPosition.Before;
- }
- }
- /**
- * 4. If nodeA is an ancestor of nodeB:
- */
- if ((0, TreeAlgorithm_1.tree_isAncestorOf)(nodeB, nodeA)) {
- /**
- * 4.1. Let child be nodeB.
- * 4.2. While child is not a child of nodeA, set child to its parent.
- * 4.3. If child’s index is less than offsetA, then return after.
- */
- let child = nodeB;
- while (!(0, TreeAlgorithm_1.tree_isChildOf)(nodeA, child)) {
- /* istanbul ignore else */
- if (child._parent !== null) {
- child = child._parent;
- }
- }
- if ((0, TreeAlgorithm_1.tree_index)(child) < offsetA) {
- return interfaces_1.BoundaryPosition.After;
- }
- }
- /**
- * 5. Return before.
- */
- return interfaces_1.BoundaryPosition.Before;
-}
-//# sourceMappingURL=BoundaryPointAlgorithm.js.map
-
-/***/ }),
-
-/***/ 7785:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.characterData_replaceData = characterData_replaceData;
-exports.characterData_substringData = characterData_substringData;
-const DOMImpl_1 = __nccwpck_require__(698);
-const util_1 = __nccwpck_require__(8247);
-const DOMException_1 = __nccwpck_require__(7175);
-const TreeAlgorithm_1 = __nccwpck_require__(3532);
-const MutationObserverAlgorithm_1 = __nccwpck_require__(3243);
-const DOMAlgorithm_1 = __nccwpck_require__(9484);
-/**
- * Replaces character data.
- *
- * @param node - a character data node
- * @param offset - start offset
- * @param count - count of characters to replace
- * @param data - new data
- */
-function characterData_replaceData(node, offset, count, data) {
- /**
- * 1. Let length be node’s length.
- * 2. If offset is greater than length, then throw an "IndexSizeError"
- * DOMException.
- * 3. If offset plus count is greater than length, then set count to length
- * minus offset.
- */
- const length = (0, TreeAlgorithm_1.tree_nodeLength)(node);
- if (offset > length) {
- throw new DOMException_1.IndexSizeError(`Offset exceeds character data length. Offset: ${offset}, Length: ${length}, Node is ${node.nodeName}.`);
- }
- if (offset + count > length) {
- count = length - offset;
- }
- /**
- * 4. Queue a mutation record of "characterData" for node with null, null,
- * node’s data, « », « », null, and null.
- */
- if (DOMImpl_1.dom.features.mutationObservers) {
- (0, MutationObserverAlgorithm_1.observer_queueMutationRecord)("characterData", node, null, null, node._data, [], [], null, null);
- }
- /**
- * 5. Insert data into node’s data after offset code units.
- * 6. Let delete offset be offset + data’s length.
- * 7. Starting from delete offset code units, remove count code units from
- * node’s data.
- */
- const newData = node._data.substring(0, offset) + data +
- node._data.substring(offset + count);
- node._data = newData;
- /**
- * 8. For each live range whose start node is node and start offset is
- * greater than offset but less than or equal to offset plus count, set its
- * start offset to offset.
- * 9. For each live range whose end node is node and end offset is greater
- * than offset but less than or equal to offset plus count, set its end
- * offset to offset.
- * 10. For each live range whose start node is node and start offset is
- * greater than offset plus count, increase its start offset by data’s
- * length and decrease it by count.
- * 11. For each live range whose end node is node and end offset is greater
- * than offset plus count, increase its end offset by data’s length and
- * decrease it by count.
- */
- for (const range of DOMImpl_1.dom.rangeList) {
- if (range._start[0] === node && range._start[1] > offset && range._start[1] <= offset + count) {
- range._start[1] = offset;
- }
- if (range._end[0] === node && range._end[1] > offset && range._end[1] <= offset + count) {
- range._end[1] = offset;
- }
- if (range._start[0] === node && range._start[1] > offset + count) {
- range._start[1] += data.length - count;
- }
- if (range._end[0] === node && range._end[1] > offset + count) {
- range._end[1] += data.length - count;
- }
- }
- /**
- * 12. If node is a Text node and its parent is not null, run the child
- * text content change steps for node’s parent.
- */
- if (DOMImpl_1.dom.features.steps) {
- if (util_1.Guard.isTextNode(node) && node._parent !== null) {
- (0, DOMAlgorithm_1.dom_runChildTextContentChangeSteps)(node._parent);
- }
- }
-}
-/**
- * Returns `count` number of characters from `node`'s data starting at
- * the given `offset`.
- *
- * @param node - a character data node
- * @param offset - start offset
- * @param count - count of characters to return
- */
-function characterData_substringData(node, offset, count) {
- /**
- * 1. Let length be node’s length.
- * 2. If offset is greater than length, then throw an "IndexSizeError"
- * DOMException.
- * 3. If offset plus count is greater than length, return a string whose
- * value is the code units from the offsetth code unit to the end of node’s
- * data, and then return.
- * 4. Return a string whose value is the code units from the offsetth code
- * unit to the offset+countth code unit in node’s data.
- */
- const length = (0, TreeAlgorithm_1.tree_nodeLength)(node);
- if (offset > length) {
- throw new DOMException_1.IndexSizeError(`Offset exceeds character data length. Offset: ${offset}, Length: ${length}, Node is ${node.nodeName}.`);
- }
- if (offset + count > length) {
- return node._data.substr(offset);
- }
- else {
- return node._data.substr(offset, count);
- }
-}
-//# sourceMappingURL=CharacterDataAlgorithm.js.map
-
-/***/ }),
-
-/***/ 8308:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.create_domImplementation = create_domImplementation;
-exports.create_window = create_window;
-exports.create_xmlDocument = create_xmlDocument;
-exports.create_document = create_document;
-exports.create_abortController = create_abortController;
-exports.create_abortSignal = create_abortSignal;
-exports.create_documentType = create_documentType;
-exports.create_element = create_element;
-exports.create_htmlElement = create_htmlElement;
-exports.create_htmlUnknownElement = create_htmlUnknownElement;
-exports.create_documentFragment = create_documentFragment;
-exports.create_shadowRoot = create_shadowRoot;
-exports.create_attr = create_attr;
-exports.create_text = create_text;
-exports.create_cdataSection = create_cdataSection;
-exports.create_comment = create_comment;
-exports.create_processingInstruction = create_processingInstruction;
-exports.create_htmlCollection = create_htmlCollection;
-exports.create_nodeList = create_nodeList;
-exports.create_nodeListStatic = create_nodeListStatic;
-exports.create_namedNodeMap = create_namedNodeMap;
-exports.create_range = create_range;
-exports.create_nodeIterator = create_nodeIterator;
-exports.create_treeWalker = create_treeWalker;
-exports.create_nodeFilter = create_nodeFilter;
-exports.create_mutationRecord = create_mutationRecord;
-exports.create_domTokenList = create_domTokenList;
-const DOMImplementationImpl_1 = __nccwpck_require__(6348);
-const WindowImpl_1 = __nccwpck_require__(1448);
-const XMLDocumentImpl_1 = __nccwpck_require__(4602);
-const DocumentImpl_1 = __nccwpck_require__(2113);
-const AbortControllerImpl_1 = __nccwpck_require__(7528);
-const AbortSignalImpl_1 = __nccwpck_require__(4560);
-const DocumentTypeImpl_1 = __nccwpck_require__(1401);
-const ElementImpl_1 = __nccwpck_require__(1342);
-const DocumentFragmentImpl_1 = __nccwpck_require__(9793);
-const ShadowRootImpl_1 = __nccwpck_require__(6092);
-const AttrImpl_1 = __nccwpck_require__(2875);
-const TextImpl_1 = __nccwpck_require__(4063);
-const CDATASectionImpl_1 = __nccwpck_require__(4104);
-const CommentImpl_1 = __nccwpck_require__(8223);
-const ProcessingInstructionImpl_1 = __nccwpck_require__(2755);
-const HTMLCollectionImpl_1 = __nccwpck_require__(9065);
-const NodeListImpl_1 = __nccwpck_require__(5788);
-const NodeListStaticImpl_1 = __nccwpck_require__(7654);
-const NamedNodeMapImpl_1 = __nccwpck_require__(3145);
-const RangeImpl_1 = __nccwpck_require__(3691);
-const NodeIteratorImpl_1 = __nccwpck_require__(4142);
-const TreeWalkerImpl_1 = __nccwpck_require__(6254);
-const NodeFilterImpl_1 = __nccwpck_require__(4649);
-const MutationRecordImpl_1 = __nccwpck_require__(33);
-const DOMTokenListImpl_1 = __nccwpck_require__(6629);
-/**
- * Creates a `DOMImplementation`.
- *
- * @param document - associated document
- */
-function create_domImplementation(document) {
- return DOMImplementationImpl_1.DOMImplementationImpl._create(document);
-}
-/**
- * Creates a `Window` node.
- */
-function create_window() {
- return WindowImpl_1.WindowImpl._create();
-}
-/**
- * Creates an `XMLDocument` node.
- */
-function create_xmlDocument() {
- return new XMLDocumentImpl_1.XMLDocumentImpl();
-}
-/**
- * Creates a `Document` node.
- */
-function create_document() {
- return new DocumentImpl_1.DocumentImpl();
-}
-/**
- * Creates an `AbortController`.
- */
-function create_abortController() {
- return new AbortControllerImpl_1.AbortControllerImpl();
-}
-/**
- * Creates an `AbortSignal`.
- */
-function create_abortSignal() {
- return AbortSignalImpl_1.AbortSignalImpl._create();
-}
-/**
- * Creates a `DocumentType` node.
- *
- * @param document - owner document
- * @param name - name of the node
- * @param publicId - `PUBLIC` identifier
- * @param systemId - `SYSTEM` identifier
- */
-function create_documentType(document, name, publicId, systemId) {
- return DocumentTypeImpl_1.DocumentTypeImpl._create(document, name, publicId, systemId);
-}
-/**
- * Creates a new `Element` node.
- *
- * @param document - owner document
- * @param localName - local name
- * @param namespace - namespace
- * @param prefix - namespace prefix
- */
-function create_element(document, localName, namespace, prefix) {
- return ElementImpl_1.ElementImpl._create(document, localName, namespace, prefix);
-}
-/**
- * Creates a new `HTMLElement` node.
- *
- * @param document - owner document
- * @param localName - local name
- * @param namespace - namespace
- * @param prefix - namespace prefix
- */
-function create_htmlElement(document, localName, namespace, prefix) {
- // TODO: Implement in HTML DOM
- return ElementImpl_1.ElementImpl._create(document, localName, namespace, prefix);
-}
-/**
- * Creates a new `HTMLUnknownElement` node.
- *
- * @param document - owner document
- * @param localName - local name
- * @param namespace - namespace
- * @param prefix - namespace prefix
- */
-function create_htmlUnknownElement(document, localName, namespace, prefix) {
- // TODO: Implement in HTML DOM
- return ElementImpl_1.ElementImpl._create(document, localName, namespace, prefix);
-}
-/**
- * Creates a new `DocumentFragment` node.
- *
- * @param document - owner document
- */
-function create_documentFragment(document) {
- return DocumentFragmentImpl_1.DocumentFragmentImpl._create(document);
-}
-/**
- * Creates a new `ShadowRoot` node.
- *
- * @param document - owner document
- * @param host - shadow root's host element node
- */
-function create_shadowRoot(document, host) {
- return ShadowRootImpl_1.ShadowRootImpl._create(document, host);
-}
-/**
- * Creates a new `Attr` node.
- *
- * @param document - owner document
- * @param localName - local name
- */
-function create_attr(document, localName) {
- return AttrImpl_1.AttrImpl._create(document, localName);
-}
-/**
- * Creates a new `Text` node.
- *
- * @param document - owner document
- * @param data - node contents
- */
-function create_text(document, data) {
- return TextImpl_1.TextImpl._create(document, data);
-}
-/**
- * Creates a new `CDATASection` node.
- *
- * @param document - owner document
- * @param data - node contents
- */
-function create_cdataSection(document, data) {
- return CDATASectionImpl_1.CDATASectionImpl._create(document, data);
-}
-/**
- * Creates a new `Comment` node.
- *
- * @param document - owner document
- * @param data - node contents
- */
-function create_comment(document, data) {
- return CommentImpl_1.CommentImpl._create(document, data);
-}
-/**
- * Creates a new `ProcessingInstruction` node.
- *
- * @param document - owner document
- * @param target - instruction target
- * @param data - node contents
- */
-function create_processingInstruction(document, target, data) {
- return ProcessingInstructionImpl_1.ProcessingInstructionImpl._create(document, target, data);
-}
-/**
- * Creates a new `HTMLCollection`.
- *
- * @param root - root node
- * @param filter - node filter
- */
-function create_htmlCollection(root, filter = (() => true)) {
- return HTMLCollectionImpl_1.HTMLCollectionImpl._create(root, filter);
-}
-/**
- * Creates a new live `NodeList`.
- *
- * @param root - root node
- */
-function create_nodeList(root) {
- return NodeListImpl_1.NodeListImpl._create(root);
-}
-/**
- * Creates a new static `NodeList`.
- *
- * @param root - root node
- * @param items - a list of items to initialize the list
- */
-function create_nodeListStatic(root, items) {
- return NodeListStaticImpl_1.NodeListStaticImpl._create(root, items);
-}
-/**
- * Creates a new `NamedNodeMap`.
- *
- * @param element - parent element
- */
-function create_namedNodeMap(element) {
- return NamedNodeMapImpl_1.NamedNodeMapImpl._create(element);
-}
-/**
- * Creates a new `Range`.
- *
- * @param start - start point
- * @param end - end point
- */
-function create_range(start, end) {
- return RangeImpl_1.RangeImpl._create(start, end);
-}
-/**
- * Creates a new `NodeIterator`.
- *
- * @param root - iterator's root node
- * @param reference - reference node
- * @param pointerBeforeReference - whether the iterator is before or after the
- * reference node
- */
-function create_nodeIterator(root, reference, pointerBeforeReference) {
- return NodeIteratorImpl_1.NodeIteratorImpl._create(root, reference, pointerBeforeReference);
-}
-/**
- * Creates a new `TreeWalker`.
- *
- * @param root - iterator's root node
- * @param current - current node
- */
-function create_treeWalker(root, current) {
- return TreeWalkerImpl_1.TreeWalkerImpl._create(root, current);
-}
-/**
- * Creates a new `NodeFilter`.
- */
-function create_nodeFilter() {
- return NodeFilterImpl_1.NodeFilterImpl._create();
-}
-/**
- * Creates a new `MutationRecord`.
- *
- * @param type - type of mutation: `"attributes"` for an attribute
- * mutation, `"characterData"` for a mutation to a CharacterData node
- * and `"childList"` for a mutation to the tree of nodes.
- * @param target - node affected by the mutation.
- * @param addedNodes - list of added nodes.
- * @param removedNodes - list of removed nodes.
- * @param previousSibling - previous sibling of added or removed nodes.
- * @param nextSibling - next sibling of added or removed nodes.
- * @param attributeName - local name of the changed attribute,
- * and `null` otherwise.
- * @param attributeNamespace - namespace of the changed attribute,
- * and `null` otherwise.
- * @param oldValue - value before mutation: attribute value for an attribute
- * mutation, node `data` for a mutation to a CharacterData node and `null`
- * for a mutation to the tree of nodes.
- */
-function create_mutationRecord(type, target, addedNodes, removedNodes, previousSibling, nextSibling, attributeName, attributeNamespace, oldValue) {
- return MutationRecordImpl_1.MutationRecordImpl._create(type, target, addedNodes, removedNodes, previousSibling, nextSibling, attributeName, attributeNamespace, oldValue);
-}
-/**
- * Creates a new `DOMTokenList`.
- *
- * @param element - associated element
- * @param attribute - associated attribute
- */
-function create_domTokenList(element, attribute) {
- return DOMTokenListImpl_1.DOMTokenListImpl._create(element, attribute);
-}
-//# sourceMappingURL=CreateAlgorithm.js.map
-
-/***/ }),
-
-/***/ 5075:
-/***/ ((__unused_webpack_module, exports) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.customElement_isValidCustomElementName = customElement_isValidCustomElementName;
-exports.customElement_isValidElementName = customElement_isValidElementName;
-exports.customElement_isVoidElementName = customElement_isVoidElementName;
-exports.customElement_isValidShadowHostName = customElement_isValidShadowHostName;
-exports.customElement_enqueueACustomElementUpgradeReaction = customElement_enqueueACustomElementUpgradeReaction;
-exports.customElement_enqueueACustomElementCallbackReaction = customElement_enqueueACustomElementCallbackReaction;
-exports.customElement_upgrade = customElement_upgrade;
-exports.customElement_tryToUpgrade = customElement_tryToUpgrade;
-exports.customElement_lookUpACustomElementDefinition = customElement_lookUpACustomElementDefinition;
-const PotentialCustomElementName = /[a-z]([\0-\t\x2D\._a-z\xB7\xC0-\xD6\xD8-\xF6\xF8-\u037D\u037F-\u1FFF\u200C\u200D\u203F\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]|[\uD800-\uDB7F][\uDC00-\uDFFF])*-([\0-\t\x2D\._a-z\xB7\xC0-\xD6\xD8-\xF6\xF8-\u037D\u037F-\u1FFF\u200C\u200D\u203F\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]|[\uD800-\uDB7F][\uDC00-\uDFFF])*/;
-const NamesWithHyphen = new Set(['annotation-xml', 'color-profile',
- 'font-face', 'font-face-src', 'font-face-uri', 'font-face-format',
- 'font-face-name', 'missing-glyph']);
-const ElementNames = new Set(['article', 'aside', 'blockquote',
- 'body', 'div', 'footer', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6',
- 'header', 'main', 'nav', 'p', 'section', 'span']);
-const VoidElementNames = new Set(['area', 'base', 'basefont',
- 'bgsound', 'br', 'col', 'embed', 'frame', 'hr', 'img', 'input', 'keygen',
- 'link', 'menuitem', 'meta', 'param', 'source', 'track', 'wbr']);
-const ShadowHostNames = new Set(['article', 'aside', 'blockquote', 'body',
- 'div', 'footer', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'header', 'main',
- 'nav', 'p', 'section', 'span']);
-/**
- * Determines if the given string is a valid custom element name.
- *
- * @param name - a name string
- */
-function customElement_isValidCustomElementName(name) {
- if (!PotentialCustomElementName.test(name))
- return false;
- if (NamesWithHyphen.has(name))
- return false;
- return true;
-}
-/**
- * Determines if the given string is a valid element name.
- *
- * @param name - a name string
- */
-function customElement_isValidElementName(name) {
- return (ElementNames.has(name));
-}
-/**
- * Determines if the given string is a void element name.
- *
- * @param name - a name string
- */
-function customElement_isVoidElementName(name) {
- return (VoidElementNames.has(name));
-}
-/**
- * Determines if the given string is a valid shadow host element name.
- *
- * @param name - a name string
- */
-function customElement_isValidShadowHostName(name) {
- return (ShadowHostNames.has(name));
-}
-/**
- * Enqueues an upgrade reaction for a custom element.
- *
- * @param element - a custom element
- * @param definition - a custom element definition
- */
-function customElement_enqueueACustomElementUpgradeReaction(element, definition) {
- // TODO: Implement in HTML DOM
-}
-/**
- * Enqueues a callback reaction for a custom element.
- *
- * @param element - a custom element
- * @param callbackName - name of the callback
- * @param args - callback arguments
- */
-function customElement_enqueueACustomElementCallbackReaction(element, callbackName, args) {
- // TODO: Implement in HTML DOM
-}
-/**
- * Upgrade a custom element.
- *
- * @param element - a custom element
- */
-function customElement_upgrade(definition, element) {
- // TODO: Implement in HTML DOM
-}
-/**
- * Tries to upgrade a custom element.
- *
- * @param element - a custom element
- */
-function customElement_tryToUpgrade(element) {
- // TODO: Implement in HTML DOM
-}
-/**
- * Looks up a custom element definition.
- *
- * @param document - a document
- * @param namespace - element namespace
- * @param localName - element local name
- * @param is - an `is` value
- */
-function customElement_lookUpACustomElementDefinition(document, namespace, localName, is) {
- // TODO: Implement in HTML DOM
- return null;
-}
-//# sourceMappingURL=CustomElementAlgorithm.js.map
-
-/***/ }),
-
-/***/ 9484:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.dom_runRemovingSteps = dom_runRemovingSteps;
-exports.dom_runCloningSteps = dom_runCloningSteps;
-exports.dom_runAdoptingSteps = dom_runAdoptingSteps;
-exports.dom_runAttributeChangeSteps = dom_runAttributeChangeSteps;
-exports.dom_runInsertionSteps = dom_runInsertionSteps;
-exports.dom_runNodeIteratorPreRemovingSteps = dom_runNodeIteratorPreRemovingSteps;
-exports.dom_hasSupportedTokens = dom_hasSupportedTokens;
-exports.dom_getSupportedTokens = dom_getSupportedTokens;
-exports.dom_runEventConstructingSteps = dom_runEventConstructingSteps;
-exports.dom_runChildTextContentChangeSteps = dom_runChildTextContentChangeSteps;
-const DOMImpl_1 = __nccwpck_require__(698);
-const TreeAlgorithm_1 = __nccwpck_require__(3532);
-const util_1 = __nccwpck_require__(8247);
-const ShadowTreeAlgorithm_1 = __nccwpck_require__(708);
-const supportedTokens = new Map();
-/**
- * Runs removing steps for node.
- *
- * @param removedNode - removed node
- * @param oldParent - old parent node
- */
-function dom_runRemovingSteps(removedNode, oldParent) {
- // No steps defined
-}
-/**
- * Runs cloning steps for node.
- *
- * @param copy - node clone
- * @param node - node
- * @param document - document to own the cloned node
- * @param cloneChildrenFlag - whether child nodes are cloned
- */
-function dom_runCloningSteps(copy, node, document, cloneChildrenFlag) {
- // No steps defined
-}
-/**
- * Runs adopting steps for node.
- *
- * @param node - node
- * @param oldDocument - old document
- */
-function dom_runAdoptingSteps(node, oldDocument) {
- // No steps defined
-}
-/**
- * Runs attribute change steps for an element node.
- *
- * @param element - element node owning the attribute
- * @param localName - attribute's local name
- * @param oldValue - attribute's old value
- * @param value - attribute's new value
- * @param namespace - attribute's namespace
- */
-function dom_runAttributeChangeSteps(element, localName, oldValue, value, namespace) {
- // run default steps
- if (DOMImpl_1.dom.features.slots) {
- updateASlotablesName.call(element, element, localName, oldValue, value, namespace);
- updateASlotsName.call(element, element, localName, oldValue, value, namespace);
- }
- updateAnElementID.call(element, element, localName, value, namespace);
- // run custom steps
- for (const step of element._attributeChangeSteps) {
- step.call(element, element, localName, oldValue, value, namespace);
- }
-}
-/**
- * Runs insertion steps for a node.
- *
- * @param insertedNode - inserted node
- */
-function dom_runInsertionSteps(insertedNode) {
- // No steps defined
-}
-/**
- * Runs pre-removing steps for a node iterator and node.
- *
- * @param nodeIterator - a node iterator
- * @param toBeRemoved - node to be removed
- */
-function dom_runNodeIteratorPreRemovingSteps(nodeIterator, toBeRemoved) {
- removeNodeIterator.call(nodeIterator, nodeIterator, toBeRemoved);
-}
-/**
- * Determines if there are any supported tokens defined for the given
- * attribute name.
- *
- * @param attributeName - an attribute name
- */
-function dom_hasSupportedTokens(attributeName) {
- return supportedTokens.has(attributeName);
-}
-/**
- * Returns the set of supported tokens defined for the given attribute name.
- *
- * @param attributeName - an attribute name
- */
-function dom_getSupportedTokens(attributeName) {
- return supportedTokens.get(attributeName) || new Set();
-}
-/**
- * Runs event construction steps.
- *
- * @param event - an event
- */
-function dom_runEventConstructingSteps(event) {
- // No steps defined
-}
-/**
- * Runs child text content change steps for a parent node.
- *
- * @param parent - parent node with text node child nodes
- */
-function dom_runChildTextContentChangeSteps(parent) {
- // No steps defined
-}
-/**
- * Defines pre-removing steps for a node iterator.
- */
-function removeNodeIterator(nodeIterator, toBeRemovedNode) {
- /**
- * 1. If toBeRemovedNode is not an inclusive ancestor of nodeIterator’s
- * reference, or toBeRemovedNode is nodeIterator’s root, then return.
- */
- if (toBeRemovedNode === nodeIterator._root ||
- !(0, TreeAlgorithm_1.tree_isAncestorOf)(nodeIterator._reference, toBeRemovedNode, true)) {
- return;
- }
- /**
- * 2. If nodeIterator’s pointer before reference is true, then:
- */
- if (nodeIterator._pointerBeforeReference) {
- /**
- * 2.1. Let next be toBeRemovedNode’s first following node that is an
- * inclusive descendant of nodeIterator’s root and is not an inclusive
- * descendant of toBeRemovedNode, and null if there is no such node.
- */
- while (true) {
- const nextNode = (0, TreeAlgorithm_1.tree_getFollowingNode)(nodeIterator._root, toBeRemovedNode);
- if (nextNode !== null &&
- (0, TreeAlgorithm_1.tree_isDescendantOf)(nodeIterator._root, nextNode, true) &&
- !(0, TreeAlgorithm_1.tree_isDescendantOf)(toBeRemovedNode, nextNode, true)) {
- /**
- * 2.2. If next is non-null, then set nodeIterator’s reference to next
- * and return.
- */
- nodeIterator._reference = nextNode;
- return;
- }
- else if (nextNode === null) {
- /**
- * 2.3. Otherwise, set nodeIterator’s pointer before reference to false.
- */
- nodeIterator._pointerBeforeReference = false;
- return;
- }
- }
- }
- /**
- * 3. Set nodeIterator’s reference to toBeRemovedNode’s parent, if
- * toBeRemovedNode’s previous sibling is null, and to the inclusive
- * descendant of toBeRemovedNode’s previous sibling that appears last in
- * tree order otherwise.
- */
- if (toBeRemovedNode._previousSibling === null) {
- if (toBeRemovedNode._parent !== null) {
- nodeIterator._reference = toBeRemovedNode._parent;
- }
- }
- else {
- let referenceNode = toBeRemovedNode._previousSibling;
- let childNode = (0, TreeAlgorithm_1.tree_getFirstDescendantNode)(toBeRemovedNode._previousSibling, true, false);
- while (childNode !== null) {
- if (childNode !== null) {
- referenceNode = childNode;
- }
- // loop through to get the last descendant node
- childNode = (0, TreeAlgorithm_1.tree_getNextDescendantNode)(toBeRemovedNode._previousSibling, childNode, true, false);
- }
- nodeIterator._reference = referenceNode;
- }
-}
-/**
- * Defines attribute change steps to update a slot’s name.
- */
-function updateASlotsName(element, localName, oldValue, value, namespace) {
- /**
- * 1. If element is a slot, localName is name, and namespace is null, then:
- * 1.1. If value is oldValue, then return.
- * 1.2. If value is null and oldValue is the empty string, then return.
- * 1.3. If value is the empty string and oldValue is null, then return.
- * 1.4. If value is null or the empty string, then set element’s name to the
- * empty string.
- * 1.5. Otherwise, set element’s name to value.
- * 1.6. Run assign slotables for a tree with element’s root.
- */
- if (util_1.Guard.isSlot(element) && localName === "name" && namespace === null) {
- if (value === oldValue)
- return;
- if (value === null && oldValue === '')
- return;
- if (value === '' && oldValue === null)
- return;
- if ((value === null || value === '')) {
- element._name = '';
- }
- else {
- element._name = value;
- }
- (0, ShadowTreeAlgorithm_1.shadowTree_assignSlotablesForATree)((0, TreeAlgorithm_1.tree_rootNode)(element));
- }
-}
-/**
- * Defines attribute change steps to update a slotable’s name.
- */
-function updateASlotablesName(element, localName, oldValue, value, namespace) {
- /**
- * 1. If localName is slot and namespace is null, then:
- * 1.1. If value is oldValue, then return.
- * 1.2. If value is null and oldValue is the empty string, then return.
- * 1.3. If value is the empty string and oldValue is null, then return.
- * 1.4. If value is null or the empty string, then set element’s name to
- * the empty string.
- * 1.5. Otherwise, set element’s name to value.
- * 1.6. If element is assigned, then run assign slotables for element’s
- * assigned slot.
- * 1.7. Run assign a slot for element.
- */
- if (util_1.Guard.isSlotable(element) && localName === "slot" && namespace === null) {
- if (value === oldValue)
- return;
- if (value === null && oldValue === '')
- return;
- if (value === '' && oldValue === null)
- return;
- if ((value === null || value === '')) {
- element._name = '';
- }
- else {
- element._name = value;
- }
- if ((0, ShadowTreeAlgorithm_1.shadowTree_isAssigned)(element)) {
- (0, ShadowTreeAlgorithm_1.shadowTree_assignSlotables)(element._assignedSlot);
- }
- (0, ShadowTreeAlgorithm_1.shadowTree_assignASlot)(element);
- }
-}
-/**
- * Defines attribute change steps to update an element's ID.
- */
-function updateAnElementID(element, localName, value, namespace) {
- /**
- * 1. If localName is id, namespace is null, and value is null or the empty
- * string, then unset element’s ID.
- * 2. Otherwise, if localName is id, namespace is null, then set element’s
- * ID to value.
- */
- if (localName === "id" && namespace === null) {
- if (!value)
- element._uniqueIdentifier = undefined;
- else
- element._uniqueIdentifier = value;
- }
-}
-//# sourceMappingURL=DOMAlgorithm.js.map
-
-/***/ }),
-
-/***/ 6827:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.tokenList_validationSteps = tokenList_validationSteps;
-exports.tokenList_updateSteps = tokenList_updateSteps;
-exports.tokenList_serializeSteps = tokenList_serializeSteps;
-const OrderedSetAlgorithm_1 = __nccwpck_require__(8421);
-const DOMAlgorithm_1 = __nccwpck_require__(9484);
-const ElementAlgorithm_1 = __nccwpck_require__(2720);
-/**
- * Validates a given token against the supported tokens defined for the given
- * token lists' associated attribute.
- *
- * @param tokenList - a token list
- * @param token - a token
- */
-function tokenList_validationSteps(tokenList, token) {
- /**
- * 1. If the associated attribute’s local name does not define supported
- * tokens, throw a TypeError.
- * 2. Let lowercase token be a copy of token, in ASCII lowercase.
- * 3. If lowercase token is present in supported tokens, return true.
- * 4. Return false.
- */
- if (!(0, DOMAlgorithm_1.dom_hasSupportedTokens)(tokenList._attribute._localName)) {
- throw new TypeError(`There are no supported tokens defined for attribute name: '${tokenList._attribute._localName}'.`);
- }
- return (0, DOMAlgorithm_1.dom_getSupportedTokens)(tokenList._attribute._localName).has(token.toLowerCase());
-}
-/**
- * Updates the value of the token lists' associated attribute.
- *
- * @param tokenList - a token list
- */
-function tokenList_updateSteps(tokenList) {
- /**
- * 1. If the associated element does not have an associated attribute and
- * token set is empty, then return.
- * 2. Set an attribute value for the associated element using associated
- * attribute’s local name and the result of running the ordered set
- * serializer for token set.
- */
- if (!tokenList._element.hasAttribute(tokenList._attribute._localName) &&
- tokenList._tokenSet.size === 0) {
- return;
- }
- (0, ElementAlgorithm_1.element_setAnAttributeValue)(tokenList._element, tokenList._attribute._localName, (0, OrderedSetAlgorithm_1.orderedSet_serialize)(tokenList._tokenSet));
-}
-/**
- * Gets the value of the token lists' associated attribute.
- *
- * @param tokenList - a token list
- */
-function tokenList_serializeSteps(tokenList) {
- /**
- * A DOMTokenList object’s serialize steps are to return the result of
- * running get an attribute value given the associated element and the
- * associated attribute’s local name.
- */
- return (0, ElementAlgorithm_1.element_getAnAttributeValue)(tokenList._element, tokenList._attribute._localName);
-}
-//# sourceMappingURL=DOMTokenListAlgorithm.js.map
-
-/***/ }),
-
-/***/ 1327:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.document_elementInterface = document_elementInterface;
-exports.document_internalCreateElementNS = document_internalCreateElementNS;
-exports.document_adopt = document_adopt;
-const DOMImpl_1 = __nccwpck_require__(698);
-const util_1 = __nccwpck_require__(8247);
-const util_2 = __nccwpck_require__(7061);
-const ElementImpl_1 = __nccwpck_require__(1342);
-const CustomElementAlgorithm_1 = __nccwpck_require__(5075);
-const TreeAlgorithm_1 = __nccwpck_require__(3532);
-const NamespaceAlgorithm_1 = __nccwpck_require__(9733);
-const DOMAlgorithm_1 = __nccwpck_require__(9484);
-const ElementAlgorithm_1 = __nccwpck_require__(2720);
-const MutationAlgorithm_1 = __nccwpck_require__(45);
-/**
- * Returns an element interface for the given name and namespace.
- *
- * @param name - element name
- * @param namespace - namespace
- */
-function document_elementInterface(name, namespace) {
- return ElementImpl_1.ElementImpl;
-}
-/**
- * Creates a new element node.
- * See: https://dom.spec.whatwg.org/#internal-createelementns-steps
- *
- * @param document - owner document
- * @param namespace - element namespace
- * @param qualifiedName - qualified name
- * @param options - element options
- */
-function document_internalCreateElementNS(document, namespace, qualifiedName, options) {
- /**
- * 1. Let namespace, prefix, and localName be the result of passing
- * namespace and qualifiedName to validate and extract.
- * 2. Let is be null.
- * 3. If options is a dictionary and options’s is is present, then set
- * is to it.
- * 4. Return the result of creating an element given document, localName,
- * namespace, prefix, is, and with the synchronous custom elements flag set.
- */
- const [ns, prefix, localName] = (0, NamespaceAlgorithm_1.namespace_validateAndExtract)(namespace, qualifiedName);
- let is = null;
- if (options !== undefined) {
- if ((0, util_2.isString)(options)) {
- is = options;
- }
- else {
- is = options.is;
- }
- }
- return (0, ElementAlgorithm_1.element_createAnElement)(document, localName, ns, prefix, is, true);
-}
-/**
- * Removes `node` and its subtree from its document and changes
- * its owner document to `document` so that it can be inserted
- * into `document`.
- *
- * @param node - the node to move
- * @param document - document to receive the node and its subtree
- */
-function document_adopt(node, document) {
- // Optimize for common case of inserting a fresh node
- if (node._nodeDocument === document && node._parent === null) {
- return;
- }
- /**
- * 1. Let oldDocument be node’s node document.
- * 2. If node’s parent is not null, remove node from its parent.
- */
- const oldDocument = node._nodeDocument;
- if (node._parent)
- (0, MutationAlgorithm_1.mutation_remove)(node, node._parent);
- /**
- * 3. If document is not oldDocument, then:
- */
- if (document !== oldDocument) {
- /**
- * 3.1. For each inclusiveDescendant in node’s shadow-including inclusive
- * descendants:
- */
- let inclusiveDescendant = (0, TreeAlgorithm_1.tree_getFirstDescendantNode)(node, true, true);
- while (inclusiveDescendant !== null) {
- /**
- * 3.1.1. Set inclusiveDescendant’s node document to document.
- * 3.1.2. If inclusiveDescendant is an element, then set the node
- * document of each attribute in inclusiveDescendant’s attribute list
- * to document.
- */
- inclusiveDescendant._nodeDocument = document;
- if (util_1.Guard.isElementNode(inclusiveDescendant)) {
- for (const attr of inclusiveDescendant._attributeList._asArray()) {
- attr._nodeDocument = document;
- }
- }
- /**
- * 3.2. For each inclusiveDescendant in node's shadow-including
- * inclusive descendants that is custom, enqueue a custom
- * element callback reaction with inclusiveDescendant,
- * callback name "adoptedCallback", and an argument list
- * containing oldDocument and document.
- */
- if (DOMImpl_1.dom.features.customElements) {
- if (util_1.Guard.isElementNode(inclusiveDescendant) &&
- inclusiveDescendant._customElementState === "custom") {
- (0, CustomElementAlgorithm_1.customElement_enqueueACustomElementCallbackReaction)(inclusiveDescendant, "adoptedCallback", [oldDocument, document]);
- }
- }
- /**
- * 3.3. For each inclusiveDescendant in node’s shadow-including
- * inclusive descendants, in shadow-including tree order, run the
- * adopting steps with inclusiveDescendant and oldDocument.
- */
- if (DOMImpl_1.dom.features.steps) {
- (0, DOMAlgorithm_1.dom_runAdoptingSteps)(inclusiveDescendant, oldDocument);
- }
- inclusiveDescendant = (0, TreeAlgorithm_1.tree_getNextDescendantNode)(node, inclusiveDescendant, true, true);
- }
- }
-}
-//# sourceMappingURL=DocumentAlgorithm.js.map
-
-/***/ }),
-
-/***/ 2720:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.element_has = element_has;
-exports.element_change = element_change;
-exports.element_append = element_append;
-exports.element_remove = element_remove;
-exports.element_replace = element_replace;
-exports.element_getAnAttributeByName = element_getAnAttributeByName;
-exports.element_getAnAttributeByNamespaceAndLocalName = element_getAnAttributeByNamespaceAndLocalName;
-exports.element_getAnAttributeValue = element_getAnAttributeValue;
-exports.element_setAnAttribute = element_setAnAttribute;
-exports.element_setAnAttributeValue = element_setAnAttributeValue;
-exports.element_removeAnAttributeByName = element_removeAnAttributeByName;
-exports.element_removeAnAttributeByNamespaceAndLocalName = element_removeAnAttributeByNamespaceAndLocalName;
-exports.element_createAnElement = element_createAnElement;
-exports.element_insertAdjacent = element_insertAdjacent;
-const DOMImpl_1 = __nccwpck_require__(698);
-const infra_1 = __nccwpck_require__(4737);
-const util_1 = __nccwpck_require__(8247);
-const DOMException_1 = __nccwpck_require__(7175);
-const CreateAlgorithm_1 = __nccwpck_require__(8308);
-const CustomElementAlgorithm_1 = __nccwpck_require__(5075);
-const MutationObserverAlgorithm_1 = __nccwpck_require__(3243);
-const DOMAlgorithm_1 = __nccwpck_require__(9484);
-const MutationAlgorithm_1 = __nccwpck_require__(45);
-const DocumentAlgorithm_1 = __nccwpck_require__(1327);
-/**
- * Determines whether the element's attribute list contains the given
- * attribute.
- *
- * @param attribute - an attribute node
- * @param element - an element node
- */
-function element_has(attribute, element) {
- /**
- * An element has an attribute A if its attribute list contains A.
- */
- return element._attributeList._asArray().indexOf(attribute) !== -1;
-}
-/**
- * Changes the value of an attribute node.
- *
- * @param attribute - an attribute node
- * @param element - an element node
- * @param value - attribute value
- */
-function element_change(attribute, element, value) {
- /**
- * 1. Queue an attribute mutation record for element with attribute’s
- * local name, attribute’s namespace, and attribute’s value.
- */
- if (DOMImpl_1.dom.features.mutationObservers) {
- (0, MutationObserverAlgorithm_1.observer_queueAttributeMutationRecord)(element, attribute._localName, attribute._namespace, attribute._value);
- }
- /**
- * 2. If element is custom, then enqueue a custom element callback reaction
- * with element, callback name "attributeChangedCallback", and an argument
- * list containing attribute’s local name, attribute’s value, value, and
- * attribute’s namespace.
- */
- if (DOMImpl_1.dom.features.customElements) {
- if (util_1.Guard.isCustomElementNode(element)) {
- (0, CustomElementAlgorithm_1.customElement_enqueueACustomElementCallbackReaction)(element, "attributeChangedCallback", [attribute._localName, attribute._value, value, attribute._namespace]);
- }
- }
- /**
- * 3. Run the attribute change steps with element, attribute’s local name,
- * attribute’s value, value, and attribute’s namespace.
- * 4. Set attribute’s value to value.
- */
- if (DOMImpl_1.dom.features.steps) {
- (0, DOMAlgorithm_1.dom_runAttributeChangeSteps)(element, attribute._localName, attribute._value, value, attribute._namespace);
- }
- attribute._value = value;
-}
-/**
- * Appends an attribute to an element node.
- *
- * @param attribute - an attribute
- * @param element - an element to receive the attribute
- */
-function element_append(attribute, element) {
- /**
- * 1. Queue an attribute mutation record for element with attribute’s
- * local name, attribute’s namespace, and null.
- */
- if (DOMImpl_1.dom.features.mutationObservers) {
- (0, MutationObserverAlgorithm_1.observer_queueAttributeMutationRecord)(element, attribute._localName, attribute._namespace, null);
- }
- /**
- * 2. If element is custom, then enqueue a custom element callback reaction
- * with element, callback name "attributeChangedCallback", and an argument
- * list containing attribute’s local name, null, attribute’s value, and
- * attribute’s namespace.
- */
- if (DOMImpl_1.dom.features.customElements) {
- if (util_1.Guard.isCustomElementNode(element)) {
- (0, CustomElementAlgorithm_1.customElement_enqueueACustomElementCallbackReaction)(element, "attributeChangedCallback", [attribute._localName, null, attribute._value, attribute._namespace]);
- }
- }
- /**
- * 3. Run the attribute change steps with element, attribute’s local name,
- * null, attribute’s value, and attribute’s namespace.
- */
- if (DOMImpl_1.dom.features.steps) {
- (0, DOMAlgorithm_1.dom_runAttributeChangeSteps)(element, attribute._localName, null, attribute._value, attribute._namespace);
- }
- /**
- * 4. Append attribute to element’s attribute list.
- * 5. Set attribute’s element to element.
- */
- element._attributeList._asArray().push(attribute);
- attribute._element = element;
- // mark that the document has namespaces
- if (!element._nodeDocument._hasNamespaces && (attribute._namespace !== null ||
- attribute._namespacePrefix !== null || attribute._localName === "xmlns")) {
- element._nodeDocument._hasNamespaces = true;
- }
-}
-/**
- * Removes an attribute from an element node.
- *
- * @param attribute - an attribute
- * @param element - an element to receive the attribute
- */
-function element_remove(attribute, element) {
- /**
- * 1. Queue an attribute mutation record for element with attribute’s
- * local name, attribute’s namespace, and attribute’s value.
- */
- if (DOMImpl_1.dom.features.mutationObservers) {
- (0, MutationObserverAlgorithm_1.observer_queueAttributeMutationRecord)(element, attribute._localName, attribute._namespace, attribute._value);
- }
- /**
- * 2. If element is custom, then enqueue a custom element callback reaction
- * with element, callback name "attributeChangedCallback", and an argument
- * list containing attribute’s local name, attribute’s value, null,
- * and attribute’s namespace.
- */
- if (DOMImpl_1.dom.features.customElements) {
- if (util_1.Guard.isCustomElementNode(element)) {
- (0, CustomElementAlgorithm_1.customElement_enqueueACustomElementCallbackReaction)(element, "attributeChangedCallback", [attribute._localName, attribute._value, null, attribute._namespace]);
- }
- }
- /**
- * 3. Run the attribute change steps with element, attribute’s local name,
- * attribute’s value, null, and attribute’s namespace.
- */
- if (DOMImpl_1.dom.features.steps) {
- (0, DOMAlgorithm_1.dom_runAttributeChangeSteps)(element, attribute._localName, attribute._value, null, attribute._namespace);
- }
- /**
- * 3. Remove attribute from element’s attribute list.
- * 5. Set attribute’s element to null.
- */
- const index = element._attributeList._asArray().indexOf(attribute);
- element._attributeList._asArray().splice(index, 1);
- attribute._element = null;
-}
-/**
- * Replaces an attribute with another of an element node.
- *
- * @param oldAttr - old attribute
- * @param newAttr - new attribute
- * @param element - an element to receive the attribute
- */
-function element_replace(oldAttr, newAttr, element) {
- /**
- * 1. Queue an attribute mutation record for element with oldAttr’s
- * local name, oldAttr’s namespace, and oldAttr’s value.
- */
- if (DOMImpl_1.dom.features.mutationObservers) {
- (0, MutationObserverAlgorithm_1.observer_queueAttributeMutationRecord)(element, oldAttr._localName, oldAttr._namespace, oldAttr._value);
- }
- /**
- * 2. If element is custom, then enqueue a custom element callback reaction
- * with element, callback name "attributeChangedCallback", and an argument
- * list containing oldAttr’s local name, oldAttr’s value, newAttr’s value,
- * and oldAttr’s namespace.
- */
- if (DOMImpl_1.dom.features.customElements) {
- if (util_1.Guard.isCustomElementNode(element)) {
- (0, CustomElementAlgorithm_1.customElement_enqueueACustomElementCallbackReaction)(element, "attributeChangedCallback", [oldAttr._localName, oldAttr._value, newAttr._value, oldAttr._namespace]);
- }
- }
- /**
- * 3. Run the attribute change steps with element, oldAttr’s local name,
- * oldAttr’s value, newAttr’s value, and oldAttr’s namespace.
- */
- if (DOMImpl_1.dom.features.steps) {
- (0, DOMAlgorithm_1.dom_runAttributeChangeSteps)(element, oldAttr._localName, oldAttr._value, newAttr._value, oldAttr._namespace);
- }
- /**
- * 4. Replace oldAttr by newAttr in element’s attribute list.
- * 5. Set oldAttr’s element to null.
- * 6. Set newAttr’s element to element.
- */
- const index = element._attributeList._asArray().indexOf(oldAttr);
- if (index !== -1) {
- element._attributeList._asArray()[index] = newAttr;
- }
- oldAttr._element = null;
- newAttr._element = element;
- // mark that the document has namespaces
- if (!element._nodeDocument._hasNamespaces && (newAttr._namespace !== null ||
- newAttr._namespacePrefix !== null || newAttr._localName === "xmlns")) {
- element._nodeDocument._hasNamespaces = true;
- }
-}
-/**
- * Retrieves an attribute with the given name from an element node.
- *
- * @param qualifiedName - an attribute name
- * @param element - an element to receive the attribute
- */
-function element_getAnAttributeByName(qualifiedName, element) {
- /**
- * 1. If element is in the HTML namespace and its node document is an HTML
- * document, then set qualifiedName to qualifiedName in ASCII lowercase.
- * 2. Return the first attribute in element’s attribute list whose qualified
- * name is qualifiedName, and null otherwise.
- */
- if (element._namespace === infra_1.namespace.HTML && element._nodeDocument._type === "html") {
- qualifiedName = qualifiedName.toLowerCase();
- }
- return element._attributeList._asArray().find(attr => attr._qualifiedName === qualifiedName) || null;
-}
-/**
- * Retrieves an attribute with the given namespace and local name from an
- * element node.
- *
- * @param namespace - an attribute namespace
- * @param localName - an attribute local name
- * @param element - an element to receive the attribute
- */
-function element_getAnAttributeByNamespaceAndLocalName(namespace, localName, element) {
- /**
- * 1. If namespace is the empty string, set it to null.
- * 2. Return the attribute in element’s attribute list whose namespace is
- * namespace and local name is localName, if any, and null otherwise.
- */
- const ns = namespace || null;
- return element._attributeList._asArray().find(attr => attr._namespace === ns && attr._localName === localName) || null;
-}
-/**
- * Retrieves an attribute's value with the given name namespace and local
- * name from an element node.
- *
- * @param element - an element to receive the attribute
- * @param localName - an attribute local name
- * @param namespace - an attribute namespace
- */
-function element_getAnAttributeValue(element, localName, namespace = '') {
- /**
- * 1. Let attr be the result of getting an attribute given namespace,
- * localName, and element.
- * 2. If attr is null, then return the empty string.
- * 3. Return attr’s value.
- */
- const attr = element_getAnAttributeByNamespaceAndLocalName(namespace, localName, element);
- if (attr === null)
- return '';
- else
- return attr._value;
-}
-/**
- * Sets an attribute of an element node.
- *
- * @param attr - an attribute
- * @param element - an element to receive the attribute
- */
-function element_setAnAttribute(attr, element) {
- /**
- * 1. If attr’s element is neither null nor element, throw an
- * "InUseAttributeError" DOMException.
- * 2. Let oldAttr be the result of getting an attribute given attr’s
- * namespace, attr’s local name, and element.
- * 3. If oldAttr is attr, return attr.
- * 4. If oldAttr is non-null, replace it by attr in element.
- * 5. Otherwise, append attr to element.
- * 6. Return oldAttr.
- */
- if (attr._element !== null && attr._element !== element)
- throw new DOMException_1.InUseAttributeError(`This attribute already exists in the document: ${attr._qualifiedName} as a child of ${attr._element._qualifiedName}.`);
- const oldAttr = element_getAnAttributeByNamespaceAndLocalName(attr._namespace || '', attr._localName, element);
- if (oldAttr === attr)
- return attr;
- if (oldAttr !== null) {
- element_replace(oldAttr, attr, element);
- }
- else {
- element_append(attr, element);
- }
- return oldAttr;
-}
-/**
- * Sets an attribute's value of an element node.
- *
- * @param element - an element to receive the attribute
- * @param localName - an attribute local name
- * @param value - an attribute value
- * @param prefix - an attribute prefix
- * @param namespace - an attribute namespace
- */
-function element_setAnAttributeValue(element, localName, value, prefix = null, namespace = null) {
- /**
- * 1. If prefix is not given, set it to null.
- * 2. If namespace is not given, set it to null.
- * 3. Let attribute be the result of getting an attribute given namespace,
- * localName, and element.
- * 4. If attribute is null, create an attribute whose namespace is
- * namespace, namespace prefix is prefix, local name is localName, value
- * is value, and node document is element’s node document, then append this
- * attribute to element, and then return.
- * 5. Change attribute from element to value.
- */
- const attribute = element_getAnAttributeByNamespaceAndLocalName(namespace || '', localName, element);
- if (attribute === null) {
- const newAttr = (0, CreateAlgorithm_1.create_attr)(element._nodeDocument, localName);
- newAttr._namespace = namespace;
- newAttr._namespacePrefix = prefix;
- newAttr._value = value;
- element_append(newAttr, element);
- return;
- }
- element_change(attribute, element, value);
-}
-/**
- * Removes an attribute with the given name from an element node.
- *
- * @param qualifiedName - an attribute name
- * @param element - an element to receive the attribute
- */
-function element_removeAnAttributeByName(qualifiedName, element) {
- /**
- * 1. Let attr be the result of getting an attribute given qualifiedName
- * and element.
- * 2. If attr is non-null, remove it from element.
- * 3. Return attr.
- */
- const attr = element_getAnAttributeByName(qualifiedName, element);
- if (attr !== null) {
- element_remove(attr, element);
- }
- return attr;
-}
-/**
- * Removes an attribute with the given namespace and local name from an
- * element node.
- *
- * @param namespace - an attribute namespace
- * @param localName - an attribute local name
- * @param element - an element to receive the attribute
- */
-function element_removeAnAttributeByNamespaceAndLocalName(namespace, localName, element) {
- /**
- * 1. Let attr be the result of getting an attribute given namespace, localName, and element.
- * 2. If attr is non-null, remove it from element.
- * 3. Return attr.
- */
- const attr = element_getAnAttributeByNamespaceAndLocalName(namespace, localName, element);
- if (attr !== null) {
- element_remove(attr, element);
- }
- return attr;
-}
-/**
- * Creates an element node.
- * See: https://dom.spec.whatwg.org/#concept-create-element.
- *
- * @param document - the document owning the element
- * @param localName - local name
- * @param namespace - element namespace
- * @param prefix - namespace prefix
- * @param is - the "is" value
- * @param synchronousCustomElementsFlag - synchronous custom elements flag
- */
-function element_createAnElement(document, localName, namespace, prefix = null, is = null, synchronousCustomElementsFlag = false) {
- /**
- * 1. If prefix was not given, let prefix be null.
- * 2. If is was not given, let is be null.
- * 3. Let result be null.
- */
- let result = null;
- if (!DOMImpl_1.dom.features.customElements) {
- result = (0, CreateAlgorithm_1.create_element)(document, localName, namespace, prefix);
- result._customElementState = "uncustomized";
- result._customElementDefinition = null;
- result._is = is;
- return result;
- }
- /**
- * 4. Let definition be the result of looking up a custom element definition
- * given document, namespace, localName, and is.
- */
- const definition = (0, CustomElementAlgorithm_1.customElement_lookUpACustomElementDefinition)(document, namespace, localName, is);
- if (definition !== null && definition.name !== definition.localName) {
- /**
- * 5. If definition is non-null, and definition’s name is not equal to
- * its local name (i.e., definition represents a customized built-in
- * element), then:
- * 5.1. Let interface be the element interface for localName and the HTML
- * namespace.
- * 5.2. Set result to a new element that implements interface, with no
- * attributes, namespace set to the HTML namespace, namespace prefix
- * set to prefix, local name set to localName, custom element state set
- * to "undefined", custom element definition set to null, is value set
- * to is, and node document set to document.
- * 5.3. If the synchronous custom elements flag is set, upgrade element
- * using definition.
- * 5.4. Otherwise, enqueue a custom element upgrade reaction given result
- * and definition.
- */
- const elemenInterface = (0, DocumentAlgorithm_1.document_elementInterface)(localName, infra_1.namespace.HTML);
- result = new elemenInterface();
- result._localName = localName;
- result._namespace = infra_1.namespace.HTML;
- result._namespacePrefix = prefix;
- result._customElementState = "undefined";
- result._customElementDefinition = null;
- result._is = is;
- result._nodeDocument = document;
- if (synchronousCustomElementsFlag) {
- (0, CustomElementAlgorithm_1.customElement_upgrade)(definition, result);
- }
- else {
- (0, CustomElementAlgorithm_1.customElement_enqueueACustomElementUpgradeReaction)(result, definition);
- }
- }
- else if (definition !== null) {
- /**
- * 6. Otherwise, if definition is non-null, then:
- */
- if (synchronousCustomElementsFlag) {
- /**
- * 6.1. If the synchronous custom elements flag is set, then run these
- * steps while catching any exceptions:
- */
- try {
- /**
- * 6.1.1. Let C be definition’s constructor.
- * 6.1.2. Set result to the result of constructing C, with no arguments.
- * 6.1.3. Assert: result’s custom element state and custom element definition
- * are initialized.
- * 6.1.4. Assert: result’s namespace is the HTML namespace.
- * _Note:_ IDL enforces that result is an HTMLElement object, which all
- * use the HTML namespace.
- */
- const C = definition.constructor;
- const result = new C();
- console.assert(result._customElementState !== undefined);
- console.assert(result._customElementDefinition !== undefined);
- console.assert(result._namespace === infra_1.namespace.HTML);
- /**
- * 6.1.5. If result’s attribute list is not empty, then throw a
- * "NotSupportedError" DOMException.
- * 6.1.6. If result has children, then throw a "NotSupportedError"
- * DOMException.
- * 6.1.7. If result’s parent is not null, then throw a
- * "NotSupportedError" DOMException.
- * 6.1.8. If result’s node document is not document, then throw a
- * "NotSupportedError" DOMException.
- * 6.1.9. If result’s local name is not equal to localName, then throw
- * a "NotSupportedError" DOMException.
- */
- if (result._attributeList.length !== 0)
- throw new DOMException_1.NotSupportedError("Custom element already has attributes.");
- if (result._children.size !== 0)
- throw new DOMException_1.NotSupportedError("Custom element already has child nodes.");
- if (result._parent !== null)
- throw new DOMException_1.NotSupportedError("Custom element already has a parent node.");
- if (result._nodeDocument !== document)
- throw new DOMException_1.NotSupportedError("Custom element is already in a document.");
- if (result._localName !== localName)
- throw new DOMException_1.NotSupportedError("Custom element has a different local name.");
- /**
- * 6.1.10. Set result’s namespace prefix to prefix.
- * 6.1.11. Set result’s is value to null.
- */
- result._namespacePrefix = prefix;
- result._is = null;
- }
- catch (e) {
- /**
- * If any of these steps threw an exception, then:
- * - Report the exception.
- * - Set result to a new element that implements the HTMLUnknownElement
- * interface, with no attributes, namespace set to the HTML namespace,
- * namespace prefix set to prefix, local name set to localName, custom
- * element state set to "failed", custom element definition set to null,
- * is value set to null, and node document set to document.
- */
- // TODO: Report the exception
- result = (0, CreateAlgorithm_1.create_htmlUnknownElement)(document, localName, infra_1.namespace.HTML, prefix);
- result._customElementState = "failed";
- result._customElementDefinition = null;
- result._is = null;
- }
- }
- else {
- /**
- * 6.2. Otherwise:
- * 6.2.1. Set result to a new element that implements the HTMLElement
- * interface, with no attributes, namespace set to the HTML namespace,
- * namespace prefix set to prefix, local name set to localName, custom
- * element state set to "undefined", custom element definition set to
- * null, is value set to null, and node document set to document.
- * 6.2.2. Enqueue a custom element upgrade reaction given result and
- * definition.
- */
- result = (0, CreateAlgorithm_1.create_htmlElement)(document, localName, infra_1.namespace.HTML, prefix);
- result._customElementState = "undefined";
- result._customElementDefinition = null;
- result._is = null;
- (0, CustomElementAlgorithm_1.customElement_enqueueACustomElementUpgradeReaction)(result, definition);
- }
- }
- else {
- /**
- * 7. Otherwise:
- * 7.1. Let interface be the element interface for localName and
- * namespace.
- * 7.2. Set result to a new element that implements interface, with no
- * attributes, namespace set to namespace, namespace prefix set to prefix,
- * local name set to localName, custom element state set to
- * "uncustomized", custom element definition set to null, is value set to
- * is, and node document set to document.
- */
- const elementInterface = (0, DocumentAlgorithm_1.document_elementInterface)(localName, namespace);
- result = new elementInterface();
- result._localName = localName;
- result._namespace = namespace;
- result._namespacePrefix = prefix;
- result._customElementState = "uncustomized";
- result._customElementDefinition = null;
- result._is = is;
- result._nodeDocument = document;
- /**
- * 7.3. If namespace is the HTML namespace, and either localName is a
- * valid custom element name or is is non-null, then set result’s
- * custom element state to "undefined".
- */
- if (namespace === infra_1.namespace.HTML && (is !== null ||
- (0, CustomElementAlgorithm_1.customElement_isValidCustomElementName)(localName))) {
- result._customElementState = "undefined";
- }
- }
- /* istanbul ignore next */
- if (result === null) {
- throw new Error("Unable to create element.");
- }
- /**
- * 8. Returns result
- */
- return result;
-}
-/**
- * Inserts a new node adjacent to this element.
- *
- * @param element - a reference element
- * @param where - a string defining where to insert the element node.
- * - `beforebegin` before this element itself.
- * - `afterbegin` before the first child.
- * - `beforeend` after the last child.
- * - `afterend` after this element itself.
- * @param node - node to insert
- */
-function element_insertAdjacent(element, where, node) {
- /**
- * - "beforebegin"
- * If element’s parent is null, return null.
- * Return the result of pre-inserting node into element’s parent before
- * element.
- * - "afterbegin"
- * Return the result of pre-inserting node into element before element’s
- * first child.
- * - "beforeend"
- * Return the result of pre-inserting node into element before null.
- * - "afterend"
- * If element’s parent is null, return null.
- * Return the result of pre-inserting node into element’s parent before element’s next sibling.
- * - Otherwise
- * Throw a "SyntaxError" DOMException.
- */
- switch (where.toLowerCase()) {
- case 'beforebegin':
- if (element._parent === null)
- return null;
- return (0, MutationAlgorithm_1.mutation_preInsert)(node, element._parent, element);
- case 'afterbegin':
- return (0, MutationAlgorithm_1.mutation_preInsert)(node, element, element._firstChild);
- case 'beforeend':
- return (0, MutationAlgorithm_1.mutation_preInsert)(node, element, null);
- case 'afterend':
- if (element._parent === null)
- return null;
- return (0, MutationAlgorithm_1.mutation_preInsert)(node, element._parent, element._nextSibling);
- default:
- throw new DOMException_1.SyntaxError(`Invalid 'where' argument. "beforebegin", "afterbegin", "beforeend" or "afterend" expected`);
- }
-}
-//# sourceMappingURL=ElementAlgorithm.js.map
-
-/***/ }),
-
-/***/ 8012:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.event_setTheCanceledFlag = event_setTheCanceledFlag;
-exports.event_initialize = event_initialize;
-exports.event_createAnEvent = event_createAnEvent;
-exports.event_innerEventCreationSteps = event_innerEventCreationSteps;
-exports.event_dispatch = event_dispatch;
-exports.event_appendToAnEventPath = event_appendToAnEventPath;
-exports.event_invoke = event_invoke;
-exports.event_innerInvoke = event_innerInvoke;
-exports.event_fireAnEvent = event_fireAnEvent;
-exports.event_createLegacyEvent = event_createLegacyEvent;
-exports.event_getterEventHandlerIDLAttribute = event_getterEventHandlerIDLAttribute;
-exports.event_setterEventHandlerIDLAttribute = event_setterEventHandlerIDLAttribute;
-exports.event_determineTheTargetOfAnEventHandler = event_determineTheTargetOfAnEventHandler;
-exports.event_getTheCurrentValueOfAnEventHandler = event_getTheCurrentValueOfAnEventHandler;
-exports.event_activateAnEventHandler = event_activateAnEventHandler;
-exports.event_deactivateAnEventHandler = event_deactivateAnEventHandler;
-const DOMImpl_1 = __nccwpck_require__(698);
-const interfaces_1 = __nccwpck_require__(9454);
-const util_1 = __nccwpck_require__(8247);
-const CustomEventImpl_1 = __nccwpck_require__(3171);
-const EventImpl_1 = __nccwpck_require__(2390);
-const DOMException_1 = __nccwpck_require__(7175);
-const TreeAlgorithm_1 = __nccwpck_require__(3532);
-const ShadowTreeAlgorithm_1 = __nccwpck_require__(708);
-const DOMAlgorithm_1 = __nccwpck_require__(9484);
-/**
- * Sets the canceled flag of an event.
- *
- * @param event - an event
- */
-function event_setTheCanceledFlag(event) {
- if (event._cancelable && !event._inPassiveListenerFlag) {
- event._canceledFlag = true;
- }
-}
-/**
- * Initializes the value of an event.
- *
- * @param event - an event to initialize
- * @param type - the type of event
- * @param bubbles - whether the event propagates in reverse
- * @param cancelable - whether the event can be cancelled
- */
-function event_initialize(event, type, bubbles, cancelable) {
- event._initializedFlag = true;
- event._stopPropagationFlag = false;
- event._stopImmediatePropagationFlag = false;
- event._canceledFlag = false;
- event._isTrusted = false;
- event._target = null;
- event._type = type;
- event._bubbles = bubbles;
- event._cancelable = cancelable;
-}
-/**
- * Creates a new event.
- *
- * @param eventInterface - event interface
- * @param realm - realm
- */
-function event_createAnEvent(eventInterface, realm = undefined) {
- /**
- * 1. If realm is not given, then set it to null.
- * 2. Let dictionary be the result of converting the JavaScript value
- * undefined to the dictionary type accepted by eventInterface’s
- * constructor. (This dictionary type will either be EventInit or a
- * dictionary that inherits from it.)
- * 3. Let event be the result of running the inner event creation steps with
- * eventInterface, realm, the time of the occurrence that the event is
- * signaling, and dictionary.
- * 4. Initialize event’s isTrusted attribute to true.
- * 5. Return event.
- */
- if (realm === undefined)
- realm = null;
- const dictionary = {};
- const event = event_innerEventCreationSteps(eventInterface, realm, new Date(), dictionary);
- event._isTrusted = true;
- return event;
-}
-/**
- * Performs event creation steps.
- *
- * @param eventInterface - event interface
- * @param realm - realm
- * @param time - time of occurrance
- * @param dictionary - event attributes
- *
- */
-function event_innerEventCreationSteps(eventInterface, realm, time, dictionary) {
- /**
- * 1. Let event be the result of creating a new object using eventInterface.
- * TODO: Implement realms
- * If realm is non-null, then use that Realm; otherwise, use the default
- * behavior defined in Web IDL.
- */
- const event = new eventInterface("");
- /**
- * 2. Set event’s initialized flag.
- * 3. Initialize event’s timeStamp attribute to a DOMHighResTimeStamp
- * representing the high resolution time from the time origin to time.
- * 4. For each member → value in dictionary, if event has an attribute
- * whose identifier is member, then initialize that attribute to value.
- * 5. Run the event constructing steps with event.
- * 6. Return event.
- */
- event._initializedFlag = true;
- event._timeStamp = time.getTime();
- Object.assign(event, dictionary);
- if (DOMImpl_1.dom.features.steps) {
- (0, DOMAlgorithm_1.dom_runEventConstructingSteps)(event);
- }
- return event;
-}
-/**
- * Dispatches an event to an event target.
- *
- * @param event - the event to dispatch
- * @param target - event target
- * @param legacyTargetOverrideFlag - legacy target override flag
- * @param legacyOutputDidListenersThrowFlag - legacy output flag that returns
- * whether the event listener's callback threw an exception
- */
-function event_dispatch(event, target, legacyTargetOverrideFlag = false, legacyOutputDidListenersThrowFlag = { value: false }) {
- let clearTargets = false;
- /**
- * 1. Set event's dispatch flag.
- */
- event._dispatchFlag = true;
- /**
- * 2. Let targetOverride be target, if legacy target override flag is not
- * given, and target's associated Document otherwise.
- *
- * _Note:_ legacy target override flag is only used by HTML and only when
- * target is a Window object.
- */
- let targetOverride = target;
- if (legacyTargetOverrideFlag) {
- const doc = target._associatedDocument;
- if (util_1.Guard.isDocumentNode(doc)) {
- targetOverride = doc;
- }
- }
- /**
- * 3. Let activationTarget be null.
- * 4. Let relatedTarget be the result of retargeting event's relatedTarget
- * against target.
- * 5. If target is not relatedTarget or target is event's relatedTarget,
- * then:
- */
- let activationTarget = null;
- let relatedTarget = (0, TreeAlgorithm_1.tree_retarget)(event._relatedTarget, target);
- if (target !== relatedTarget || target === event._relatedTarget) {
- /**
- * 5.1. Let touchTargets be a new list.
- * 5.2. For each touchTarget of event's touch target list, append the
- * result of retargeting touchTarget against target to touchTargets.
- * 5.3. Append to an event path with event, target, targetOverride,
- * relatedTarget, touchTargets, and false.
- * 5.4. Let isActivationEvent be true, if event is a MouseEvent object
- * and event's type attribute is "click", and false otherwise.
- * 5.5. If isActivationEvent is true and target has activation behavior,
- * then set activationTarget to target.
- * 5.6. Let slotable be target, if target is a slotable and is assigned,
- * and null otherwise.
- * 5.7. Let slot-in-closed-tree be false.
- * 5.8. Let parent be the result of invoking target's get the parent with
- * event.
- */
- let touchTargets = [];
- for (const touchTarget of event._touchTargetList) {
- touchTargets.push((0, TreeAlgorithm_1.tree_retarget)(touchTarget, target));
- }
- event_appendToAnEventPath(event, target, targetOverride, relatedTarget, touchTargets, false);
- const isActivationEvent = (util_1.Guard.isMouseEvent(event) && event._type === "click");
- if (isActivationEvent && target._activationBehavior !== undefined) {
- activationTarget = target;
- }
- let slotable = (util_1.Guard.isSlotable(target) && (0, ShadowTreeAlgorithm_1.shadowTree_isAssigned)(target)) ?
- target : null;
- let slotInClosedTree = false;
- let parent = target._getTheParent(event);
- /**
- * 5.9. While parent is non-null:
- */
- while (parent !== null && util_1.Guard.isNode(parent)) {
- /**
- * 5.9.1 If slotable is non-null:
- * 5.9.1.1. Assert: parent is a slot.
- * 5.9.1.2. Set slotable to null.
- * 5.9.1.3. If parent's root is a shadow root whose mode is "closed",
- * then set slot-in-closed-tree to true.
- */
- if (slotable !== null) {
- if (!util_1.Guard.isSlot(parent)) {
- throw new Error("Parent node of a slotable should be a slot.");
- }
- slotable = null;
- const root = (0, TreeAlgorithm_1.tree_rootNode)(parent, true);
- if (util_1.Guard.isShadowRoot(root) && root._mode === "closed") {
- slotInClosedTree = true;
- }
- }
- /**
- * 5.9.2 If parent is a slotable and is assigned, then set slotable to
- * parent.
- * 5.9.3. Let relatedTarget be the result of retargeting event's
- * relatedTarget against parent.
- * 5.9.4. Let touchTargets be a new list.
- * 5.9.4. For each touchTarget of event's touch target list, append the
- * result of retargeting touchTarget against parent to touchTargets.
- */
- if (util_1.Guard.isSlotable(parent) && (0, ShadowTreeAlgorithm_1.shadowTree_isAssigned)(parent)) {
- slotable = parent;
- }
- relatedTarget = (0, TreeAlgorithm_1.tree_retarget)(event._relatedTarget, parent);
- touchTargets = [];
- for (const touchTarget of event._touchTargetList) {
- touchTargets.push((0, TreeAlgorithm_1.tree_retarget)(touchTarget, parent));
- }
- /**
- * 5.9.6. If parent is a Window object, or parent is a node and target's
- * root is a shadow-including inclusive ancestor of parent, then:
- */
- if (util_1.Guard.isWindow(parent) || (util_1.Guard.isNode(parent) && util_1.Guard.isNode(target) &&
- (0, TreeAlgorithm_1.tree_isAncestorOf)((0, TreeAlgorithm_1.tree_rootNode)(target, true), parent, true, true))) {
- /**
- * 5.9.6.1. If isActivationEvent is true, event's bubbles attribute
- * is true, activationTarget is null, and parent has activation
- * behavior, then set activationTarget to parent.
- * 5.9.6.2. Append to an event path with event, parent, null,
- * relatedTarget, touchTargets, and slot-in-closed-tree.
- */
- if (isActivationEvent && event._bubbles && activationTarget === null &&
- parent._activationBehavior) {
- activationTarget = parent;
- }
- event_appendToAnEventPath(event, parent, null, relatedTarget, touchTargets, slotInClosedTree);
- }
- else if (parent === relatedTarget) {
- /**
- * 5.9.7. Otherwise, if parent is relatedTarget,
- * then set parent to null.
- */
- parent = null;
- }
- else {
- /**
- * 5.9.8. Otherwise, set target to parent and then:
- * 5.9.8.1. If isActivationEvent is true, activationTarget is null,
- * and target has activation behavior, then set activationTarget
- * to target.
- * 5.9.8.2. Append to an event path with event, parent, target,
- * relatedTarget, touchTargets, and slot-in-closed-tree.
- */
- target = parent;
- if (isActivationEvent && activationTarget === null &&
- target._activationBehavior) {
- activationTarget = target;
- }
- event_appendToAnEventPath(event, parent, target, relatedTarget, touchTargets, slotInClosedTree);
- }
- /**
- * 5.9.9. If parent is non-null, then set parent to the result of
- * invoking parent's get the parent with event.
- * 5.9.10. Set slot-in-closed-tree to false.
- */
- if (parent !== null) {
- parent = parent._getTheParent(event);
- }
- slotInClosedTree = false;
- }
- /**
- * 5.10. Let clearTargetsStruct be the last struct in event's path whose
- * shadow-adjusted target is non-null.
- */
- let clearTargetsStruct = null;
- const path = event._path;
- for (let i = path.length - 1; i >= 0; i--) {
- const struct = path[i];
- if (struct.shadowAdjustedTarget !== null) {
- clearTargetsStruct = struct;
- break;
- }
- }
- /**
- * 5.11. Let clearTargets be true if clearTargetsStruct's shadow-adjusted
- * target, clearTargetsStruct's relatedTarget, or an EventTarget object
- * in clearTargetsStruct's touch target list is a node and its root is
- * a shadow root, and false otherwise.
- */
- if (clearTargetsStruct !== null) {
- if (util_1.Guard.isNode(clearTargetsStruct.shadowAdjustedTarget) &&
- util_1.Guard.isShadowRoot((0, TreeAlgorithm_1.tree_rootNode)(clearTargetsStruct.shadowAdjustedTarget, true))) {
- clearTargets = true;
- }
- else if (util_1.Guard.isNode(clearTargetsStruct.relatedTarget) &&
- util_1.Guard.isShadowRoot((0, TreeAlgorithm_1.tree_rootNode)(clearTargetsStruct.relatedTarget, true))) {
- clearTargets = true;
- }
- else {
- for (let j = 0; j < clearTargetsStruct.touchTargetList.length; j++) {
- const struct = clearTargetsStruct.touchTargetList[j];
- if (util_1.Guard.isNode(struct) &&
- util_1.Guard.isShadowRoot((0, TreeAlgorithm_1.tree_rootNode)(struct, true))) {
- clearTargets = true;
- break;
- }
- }
- }
- }
- /**
- * 5.12. If activationTarget is non-null and activationTarget has
- * legacy-pre-activation behavior, then run activationTarget's
- * legacy-pre-activation behavior.
- */
- if (activationTarget !== null &&
- activationTarget._legacyPreActivationBehavior !== undefined) {
- activationTarget._legacyPreActivationBehavior(event);
- }
- /**
- * 5.13. For each struct in event's path, in reverse order:
- */
- for (let i = path.length - 1; i >= 0; i--) {
- const struct = path[i];
- /**
- * 5.13.1. If struct's shadow-adjusted target is non-null, then set
- * event's eventPhase attribute to AT_TARGET.
- * 5.13.2. Otherwise, set event's eventPhase attribute to
- * CAPTURING_PHASE.
- * 5.13.3. Invoke with struct, event, "capturing", and
- * legacyOutputDidListenersThrowFlag if given.
- */
- if (struct.shadowAdjustedTarget !== null) {
- event._eventPhase = interfaces_1.EventPhase.AtTarget;
- }
- else {
- event._eventPhase = interfaces_1.EventPhase.Capturing;
- }
- event_invoke(struct, event, "capturing", legacyOutputDidListenersThrowFlag);
- }
- /**
- * 5.14. For each struct in event's path
- */
- for (let i = 0; i < path.length; i++) {
- const struct = path[i];
- /**
- * 5.14.1. If struct's shadow-adjusted target is non-null, then set
- * event's eventPhase attribute to AT_TARGET.
- * 5.14.2. Otherwise:
- * 5.14.2.1. If event's bubbles attribute is false, then continue.
- * 5.14.2.2. Set event's eventPhase attribute to BUBBLING_PHASE.
- * 5.14.3. Invoke with struct, event, "bubbling", and
- * legacyOutputDidListenersThrowFlag if given.
- */
- if (struct.shadowAdjustedTarget !== null) {
- event._eventPhase = interfaces_1.EventPhase.AtTarget;
- }
- else {
- if (!event._bubbles)
- continue;
- event._eventPhase = interfaces_1.EventPhase.Bubbling;
- }
- event_invoke(struct, event, "bubbling", legacyOutputDidListenersThrowFlag);
- }
- }
- /**
- * 6. Set event's eventPhase attribute to NONE.
- * 7. Set event's currentTarget attribute to null.
- * 8. Set event's path to the empty list.
- * 9. Unset event's dispatch flag, stop propagation flag, and stop
- * immediate propagation flag.
- */
- event._eventPhase = interfaces_1.EventPhase.None;
- event._currentTarget = null;
- event._path = [];
- event._dispatchFlag = false;
- event._stopPropagationFlag = false;
- event._stopImmediatePropagationFlag = false;
- /**
- * 10. If clearTargets, then:
- * 10.1. Set event's target to null.
- * 10.2. Set event's relatedTarget to null.
- * 10.3. Set event's touch target list to the empty list.
- */
- if (clearTargets) {
- event._target = null;
- event._relatedTarget = null;
- event._touchTargetList = [];
- }
- /**
- * 11. If activationTarget is non-null, then:
- * 11.1. If event's canceled flag is unset, then run activationTarget's
- * activation behavior with event.
- * 11.2. Otherwise, if activationTarget has legacy-canceled-activation
- * behavior, then run activationTarget's legacy-canceled-activation
- * behavior.
- */
- if (activationTarget !== null) {
- if (!event._canceledFlag && activationTarget._activationBehavior !== undefined) {
- activationTarget._activationBehavior(event);
- }
- else if (activationTarget._legacyCanceledActivationBehavior !== undefined) {
- activationTarget._legacyCanceledActivationBehavior(event);
- }
- }
- /**
- * 12. Return false if event's canceled flag is set, and true otherwise.
- */
- return !event._canceledFlag;
-}
-/**
- * Appends a new struct to an event's path.
- *
- * @param event - an event
- * @param invocationTarget - the target of the invocation
- * @param shadowAdjustedTarget - shadow-root adjusted event target
- * @param relatedTarget - related event target
- * @param touchTargets - a list of touch targets
- * @param slotInClosedTree - if the target's parent is a closed shadow root
- */
-function event_appendToAnEventPath(event, invocationTarget, shadowAdjustedTarget, relatedTarget, touchTargets, slotInClosedTree) {
- /**
- * 1. Let invocationTargetInShadowTree be false.
- * 2. If invocationTarget is a node and its root is a shadow root, then
- * set invocationTargetInShadowTree to true.
- */
- let invocationTargetInShadowTree = false;
- if (util_1.Guard.isNode(invocationTarget) &&
- util_1.Guard.isShadowRoot((0, TreeAlgorithm_1.tree_rootNode)(invocationTarget))) {
- invocationTargetInShadowTree = true;
- }
- /**
- * 3. Let root-of-closed-tree be false.
- * 4. If invocationTarget is a shadow root whose mode is "closed", then
- * set root-of-closed-tree to true.
- */
- let rootOfClosedTree = false;
- if (util_1.Guard.isShadowRoot(invocationTarget) &&
- invocationTarget._mode === "closed") {
- rootOfClosedTree = true;
- }
- /**
- * 5. Append a new struct to event's path whose invocation target is
- * invocationTarget, invocation-target-in-shadow-tree is
- * invocationTargetInShadowTree, shadow-adjusted target is
- * shadowAdjustedTarget, relatedTarget is relatedTarget,
- * touch target list is touchTargets, root-of-closed-tree is
- * root-of-closed-tree, and slot-in-closed-tree is slot-in-closed-tree.
- */
- event._path.push({
- invocationTarget: invocationTarget,
- invocationTargetInShadowTree: invocationTargetInShadowTree,
- shadowAdjustedTarget: shadowAdjustedTarget,
- relatedTarget: relatedTarget,
- touchTargetList: touchTargets,
- rootOfClosedTree: rootOfClosedTree,
- slotInClosedTree: slotInClosedTree
- });
-}
-/**
- * Invokes an event.
- *
- * @param struct - a struct defining event's path
- * @param event - the event to invoke
- * @param phase - event phase
- * @param legacyOutputDidListenersThrowFlag - legacy output flag that returns
- * whether the event listener's callback threw an exception
- */
-function event_invoke(struct, event, phase, legacyOutputDidListenersThrowFlag = { value: false }) {
- /**
- * 1. Set event's target to the shadow-adjusted target of the last struct
- * in event's path, that is either struct or preceding struct, whose
- * shadow-adjusted target is non-null.
- */
- const path = event._path;
- let index = -1;
- for (let i = 0; i < path.length; i++) {
- if (path[i] === struct) {
- index = i;
- break;
- }
- }
- if (index !== -1) {
- let item = path[index];
- if (item.shadowAdjustedTarget !== null) {
- event._target = item.shadowAdjustedTarget;
- }
- else if (index > 0) {
- item = path[index - 1];
- if (item.shadowAdjustedTarget !== null) {
- event._target = item.shadowAdjustedTarget;
- }
- }
- }
- /**
- * 2. Set event's relatedTarget to struct's relatedTarget.
- * 3. Set event's touch target list to struct's touch target list.
- * 4. If event's stop propagation flag is set, then return.
- * 5. Initialize event's currentTarget attribute to struct's invocation
- * target.
- * 6. Let listeners be a clone of event's currentTarget attribute value's
- * event listener list.
- *
- * _Note:_ This avoids event listeners added after this point from being
- * run. Note that removal still has an effect due to the removed field.
- */
- event._relatedTarget = struct.relatedTarget;
- event._touchTargetList = struct.touchTargetList;
- if (event._stopPropagationFlag)
- return;
- event._currentTarget = struct.invocationTarget;
- const currentTarget = event._currentTarget;
- const targetListeners = currentTarget._eventListenerList;
- let listeners = new Array(...targetListeners);
- /**
- * 7. Let found be the result of running inner invoke with event, listeners,
- * phase, and legacyOutputDidListenersThrowFlag if given.
- */
- const found = event_innerInvoke(event, listeners, phase, struct, legacyOutputDidListenersThrowFlag);
- /**
- * 8. If found is false and event's isTrusted attribute is true, then:
- */
- if (!found && event._isTrusted) {
- /**
- * 8.1. Let originalEventType be event's type attribute value.
- * 8.2. If event's type attribute value is a match for any of the strings
- * in the first column in the following table, set event's type attribute
- * value to the string in the second column on the same row as the matching
- * string, and return otherwise.
- *
- * Event type | Legacy event type
- * -------------------------------------------------
- * "animationend" | "webkitAnimationEnd"
- * "animationiteration" | "webkitAnimationIteration"
- * "animationstart" | "webkitAnimationStart"
- * "transitionend" | "webkitTransitionEnd"
- */
- const originalEventType = event._type;
- if (originalEventType === "animationend") {
- event._type = "webkitAnimationEnd";
- }
- else if (originalEventType === "animationiteration") {
- event._type = "webkitAnimationIteration";
- }
- else if (originalEventType === "animationstart") {
- event._type = "webkitAnimationStart";
- }
- else if (originalEventType === "transitionend") {
- event._type = "webkitTransitionEnd";
- }
- /**
- * 8.3. Inner invoke with event, listeners, phase, and
- * legacyOutputDidListenersThrowFlag if given.
- * 8.4. Set event's type attribute value to originalEventType.
- */
- event_innerInvoke(event, listeners, phase, struct, legacyOutputDidListenersThrowFlag);
- event._type = originalEventType;
- }
-}
-/**
- * Invokes an event.
- *
- * @param event - the event to invoke
- * @param listeners - event listeners
- * @param phase - event phase
- * @param struct - a struct defining event's path
- * @param legacyOutputDidListenersThrowFlag - legacy output flag that returns
- * whether the event listener's callback threw an exception
- */
-function event_innerInvoke(event, listeners, phase, struct, legacyOutputDidListenersThrowFlag = { value: false }) {
- /**
- * 1. Let found be false.
- * 2. For each listener in listeners, whose removed is false:
- */
- let found = false;
- for (let i = 0; i < listeners.length; i++) {
- const listener = listeners[i];
- if (!listener.removed) {
- /**
- * 2.1. If event's type attribute value is not listener's type, then
- * continue.
- * 2.2. Set found to true.
- * 2.3. If phase is "capturing" and listener's capture is false, then
- * continue.
- * 2.4. If phase is "bubbling" and listener's capture is true, then
- * continue.
- */
- if (event._type !== listener.type)
- continue;
- found = true;
- if (phase === "capturing" && !listener.capture)
- continue;
- if (phase === "bubbling" && listener.capture)
- continue;
- /**
- * 2.5. If listener's once is true, then remove listener from event's
- * currentTarget attribute value's event listener list.
- */
- if (listener.once && event._currentTarget !== null) {
- const impl = event._currentTarget;
- let index = -1;
- for (let i = 0; i < impl._eventListenerList.length; i++) {
- if (impl._eventListenerList[i] === listener) {
- index = i;
- break;
- }
- }
- if (index !== -1) {
- impl._eventListenerList.splice(index, 1);
- }
- }
- /**
- * TODO: Implement realms
- *
- * 2.6. Let global be listener callback's associated Realm's global
- * object.
- */
- const globalObject = undefined;
- /**
- * 2.7. Let currentEvent be undefined.
- * 2.8. If global is a Window object, then:
- * 2.8.1. Set currentEvent to global's current event.
- * 2.8.2. If struct's invocation-target-in-shadow-tree is false, then
- * set global's current event to event.
- */
- let currentEvent = undefined;
- if (util_1.Guard.isWindow(globalObject)) {
- currentEvent = globalObject._currentEvent;
- if (struct.invocationTargetInShadowTree === false) {
- globalObject._currentEvent = event;
- }
- }
- /**
- * 2.9. If listener's passive is true, then set event's in passive
- * listener flag.
- * 2.10. Call a user object's operation with listener's callback,
- * "handleEvent", « event », and event's currentTarget attribute value.
- */
- if (listener.passive)
- event._inPassiveListenerFlag = true;
- try {
- listener.callback.handleEvent.call(event._currentTarget, event);
- }
- catch (err) {
- /**
- * If this throws an exception, then:
- * 2.10.1. Report the exception.
- * 2.10.2. Set legacyOutputDidListenersThrowFlag if given.
- *
- * _Note:_ The legacyOutputDidListenersThrowFlag is only used by
- * Indexed Database API.
- * TODO: Report the exception
- * See: https://html.spec.whatwg.org/multipage/webappapis.html#runtime-script-errors-in-documents
- */
- legacyOutputDidListenersThrowFlag.value = true;
- }
- /**
- * 2.11. Unset event's in passive listener flag.
- */
- if (listener.passive)
- event._inPassiveListenerFlag = false;
- /**
- * 2.12. If global is a Window object, then set global's current event
- * to currentEvent.
- */
- if (util_1.Guard.isWindow(globalObject)) {
- globalObject._currentEvent = currentEvent;
- }
- /**
- * 2.13. If event's stop immediate propagation flag is set, then return
- * found.
- */
- if (event._stopImmediatePropagationFlag)
- return found;
- }
- }
- /**
- * 3. Return found.
- */
- return found;
-}
-/**
- * Fires an event at target.
- * @param e - event name
- * @param target - event target
- * @param eventConstructor - an event constructor, with a description of how
- * IDL attributes are to be initialized
- * @param idlAttributes - a dictionary describing how IDL attributes are
- * to be initialized
- * @param legacyTargetOverrideFlag - legacy target override flag
- */
-function event_fireAnEvent(e, target, eventConstructor, idlAttributes, legacyTargetOverrideFlag) {
- /**
- * 1. If eventConstructor is not given, then let eventConstructor be Event.
- */
- if (eventConstructor === undefined) {
- eventConstructor = EventImpl_1.EventImpl;
- }
- /**
- * 2. Let event be the result of creating an event given eventConstructor,
- * in the relevant Realm of target.
- */
- const event = event_createAnEvent(eventConstructor);
- /**
- * 3. Initialize event’s type attribute to e.
- */
- event._type = e;
- /**
- * 4. Initialize any other IDL attributes of event as described in the
- * invocation of this algorithm.
- * _Note:_ This also allows for the isTrusted attribute to be set to false.
- */
- if (idlAttributes) {
- for (const key in idlAttributes) {
- const idlObj = event;
- idlObj[key] = idlAttributes[key];
- }
- }
- /**
- * 5. Return the result of dispatching event at target, with legacy target
- * override flag set if set.
- */
- return event_dispatch(event, target, legacyTargetOverrideFlag);
-}
-/**
- * Creates an event.
- *
- * @param eventInterface - the name of the event interface
- */
-function event_createLegacyEvent(eventInterface) {
- /**
- * 1. Let constructor be null.
- */
- let constructor = null;
- /**
- * TODO: Implement in HTML DOM
- * 2. If interface is an ASCII case-insensitive match for any of the strings
- * in the first column in the following table, then set constructor to the
- * interface in the second column on the same row as the matching string:
- *
- * String | Interface
- * -------|----------
- * "beforeunloadevent" | BeforeUnloadEvent
- * "compositionevent" | CompositionEvent
- * "customevent" | CustomEvent
- * "devicemotionevent" | DeviceMotionEvent
- * "deviceorientationevent" | DeviceOrientationEvent
- * "dragevent" | DragEvent
- * "event" | Event
- * "events" | Event
- * "focusevent" | FocusEvent
- * "hashchangeevent" | HashChangeEvent
- * "htmlevents" | Event
- * "keyboardevent" | KeyboardEvent
- * "messageevent" | MessageEvent
- * "mouseevent" | MouseEvent
- * "mouseevents" |
- * "storageevent" | StorageEvent
- * "svgevents" | Event
- * "textevent" | CompositionEvent
- * "touchevent" | TouchEvent
- * "uievent" | UIEvent
- * "uievents" | UIEvent
- */
- switch (eventInterface.toLowerCase()) {
- case "beforeunloadevent":
- break;
- case "compositionevent":
- break;
- case "customevent":
- constructor = CustomEventImpl_1.CustomEventImpl;
- break;
- case "devicemotionevent":
- break;
- case "deviceorientationevent":
- break;
- case "dragevent":
- break;
- case "event":
- case "events":
- constructor = EventImpl_1.EventImpl;
- break;
- case "focusevent":
- break;
- case "hashchangeevent":
- break;
- case "htmlevents":
- break;
- case "keyboardevent":
- break;
- case "messageevent":
- break;
- case "mouseevent":
- break;
- case "mouseevents":
- break;
- case "storageevent":
- break;
- case "svgevents":
- break;
- case "textevent":
- break;
- case "touchevent":
- break;
- case "uievent":
- break;
- case "uievents":
- break;
- }
- /**
- * 3. If constructor is null, then throw a "NotSupportedError" DOMException.
- */
- if (constructor === null) {
- throw new DOMException_1.NotSupportedError(`Event constructor not found for interface ${eventInterface}.`);
- }
- /**
- * 4. If the interface indicated by constructor is not exposed on the
- * relevant global object of the context object, then throw a
- * "NotSupportedError" DOMException.
- * _Note:_ Typically user agents disable support for touch events in some
- * configurations, in which case this clause would be triggered for the
- * interface TouchEvent.
- */
- // TODO: Implement realms
- /**
- * 5. Let event be the result of creating an event given constructor.
- * 6. Initialize event’s type attribute to the empty string.
- * 7. Initialize event’s timeStamp attribute to a DOMHighResTimeStamp
- * representing the high resolution time from the time origin to now.
- * 8. Initialize event’s isTrusted attribute to false.
- * 9. Unset event’s initialized flag.
- */
- const event = new constructor("");
- event._type = "";
- event._timeStamp = new Date().getTime();
- event._isTrusted = false;
- event._initializedFlag = false;
- /**
- * 10. Return event.
- */
- return event;
-}
-/**
- * Getter of an event handler IDL attribute.
- *
- * @param eventTarget - event target
- * @param name - event name
- */
-function event_getterEventHandlerIDLAttribute(thisObj, name) {
- /**
- * 1. Let eventTarget be the result of determining the target of an event
- * handler given this object and name.
- * 2. If eventTarget is null, then return null.
- * 3. Return the result of getting the current value of the event handler
- * given eventTarget and name.
- */
- const eventTarget = event_determineTheTargetOfAnEventHandler(thisObj, name);
- if (eventTarget === null)
- return null;
- return event_getTheCurrentValueOfAnEventHandler(eventTarget, name);
-}
-/**
- * Setter of an event handler IDL attribute.
- *
- * @param eventTarget - event target
- * @param name - event name
- * @param value - event handler
- */
-function event_setterEventHandlerIDLAttribute(thisObj, name, value) {
- /**
- * 1. Let eventTarget be the result of determining the target of an event
- * handler given this object and name.
- * 2. If eventTarget is null, then return.
- * 3. If the given value is null, then deactivate an event handler given
- * eventTarget and name.
- * 4. Otherwise:
- * 4.1. Let handlerMap be eventTarget's event handler map.
- * 4.2. Let eventHandler be handlerMap[name].
- * 4.3. Set eventHandler's value to the given value.
- * 4.4. Activate an event handler given eventTarget and name.
- */
- const eventTarget = event_determineTheTargetOfAnEventHandler(thisObj, name);
- if (eventTarget === null)
- return;
- if (value === null) {
- event_deactivateAnEventHandler(eventTarget, name);
- }
- else {
- const handlerMap = eventTarget._eventHandlerMap;
- const eventHandler = handlerMap["onabort"];
- if (eventHandler !== undefined) {
- eventHandler.value = value;
- }
- event_activateAnEventHandler(eventTarget, name);
- }
-}
-/**
- * Determines the target of an event handler.
- *
- * @param eventTarget - event target
- * @param name - event name
- */
-function event_determineTheTargetOfAnEventHandler(eventTarget, name) {
- // TODO: Implement in HTML DOM
- return null;
-}
-/**
- * Gets the current value of an event handler.
- *
- * @param eventTarget - event target
- * @param name - event name
- */
-function event_getTheCurrentValueOfAnEventHandler(eventTarget, name) {
- // TODO: Implement in HTML DOM
- return null;
-}
-/**
- * Activates an event handler.
- *
- * @param eventTarget - event target
- * @param name - event name
- */
-function event_activateAnEventHandler(eventTarget, name) {
- // TODO: Implement in HTML DOM
-}
-/**
- * Deactivates an event handler.
- *
- * @param eventTarget - event target
- * @param name - event name
- */
-function event_deactivateAnEventHandler(eventTarget, name) {
- // TODO: Implement in HTML DOM
-}
-//# sourceMappingURL=EventAlgorithm.js.map
-
-/***/ }),
-
-/***/ 9807:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.eventTarget_flatten = eventTarget_flatten;
-exports.eventTarget_flattenMore = eventTarget_flattenMore;
-exports.eventTarget_addEventListener = eventTarget_addEventListener;
-exports.eventTarget_removeEventListener = eventTarget_removeEventListener;
-exports.eventTarget_removeAllEventListeners = eventTarget_removeAllEventListeners;
-const util_1 = __nccwpck_require__(7061);
-/**
- * Flattens the given options argument.
- *
- * @param options - options argument
- */
-function eventTarget_flatten(options) {
- /**
- * 1. If options is a boolean, then return options.
- * 2. Return options’s capture.
- */
- if ((0, util_1.isBoolean)(options)) {
- return options;
- }
- else {
- return options.capture || false;
- }
-}
-/**
- * Flattens the given options argument.
- *
- * @param options - options argument
- */
-function eventTarget_flattenMore(options) {
- /**
- * 1. Let capture be the result of flattening options.
- * 2. Let once and passive be false.
- * 3. If options is a dictionary, then set passive to options’s passive and
- * once to options’s once.
- * 4. Return capture, passive, and once.
- */
- const capture = eventTarget_flatten(options);
- let once = false;
- let passive = false;
- if (!(0, util_1.isBoolean)(options)) {
- once = options.once || false;
- passive = options.passive || false;
- }
- return [capture, passive, once];
-}
-/**
- * Adds a new event listener.
- *
- * @param eventTarget - event target
- * @param listener - event listener
- */
-function eventTarget_addEventListener(eventTarget, listener) {
- /**
- * 1. If eventTarget is a ServiceWorkerGlobalScope object, its service
- * worker’s script resource’s has ever been evaluated flag is set, and
- * listener’s type matches the type attribute value of any of the service
- * worker events, then report a warning to the console that this might not
- * give the expected results. [SERVICE-WORKERS]
- */
- // TODO: service worker
- /**
- * 2. If listener’s callback is null, then return.
- */
- if (listener.callback === null)
- return;
- /**
- * 3. If eventTarget’s event listener list does not contain an event listener
- * whose type is listener’s type, callback is listener’s callback, and capture
- * is listener’s capture, then append listener to eventTarget’s event listener
- * list.
- */
- for (let i = 0; i < eventTarget._eventListenerList.length; i++) {
- const entry = eventTarget._eventListenerList[i];
- if (entry.type === listener.type && entry.callback.handleEvent === listener.callback.handleEvent
- && entry.capture === listener.capture) {
- return;
- }
- }
- eventTarget._eventListenerList.push(listener);
-}
-/**
- * Removes an event listener.
- *
- * @param eventTarget - event target
- * @param listener - event listener
- */
-function eventTarget_removeEventListener(eventTarget, listener, index) {
- /**
- * 1. If eventTarget is a ServiceWorkerGlobalScope object and its service
- * worker’s set of event types to handle contains type, then report a
- * warning to the console that this might not give the expected results.
- * [SERVICE-WORKERS]
- */
- // TODO: service worker
- /**
- * 2. Set listener’s removed to true and remove listener from eventTarget’s
- * event listener list.
- */
- listener.removed = true;
- eventTarget._eventListenerList.splice(index, 1);
-}
-/**
- * Removes all event listeners.
- *
- * @param eventTarget - event target
- */
-function eventTarget_removeAllEventListeners(eventTarget) {
- /**
- * To remove all event listeners, given an EventTarget object eventTarget,
- * for each listener of eventTarget’s event listener list, remove an event
- * listener with eventTarget and listener.
- */
- for (const e of eventTarget._eventListenerList) {
- e.removed = true;
- }
- eventTarget._eventListenerList.length = 0;
-}
-//# sourceMappingURL=EventTargetAlgorithm.js.map
-
-/***/ }),
-
-/***/ 45:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.mutation_ensurePreInsertionValidity = mutation_ensurePreInsertionValidity;
-exports.mutation_preInsert = mutation_preInsert;
-exports.mutation_insert = mutation_insert;
-exports.mutation_append = mutation_append;
-exports.mutation_replace = mutation_replace;
-exports.mutation_replaceAll = mutation_replaceAll;
-exports.mutation_preRemove = mutation_preRemove;
-exports.mutation_remove = mutation_remove;
-const DOMImpl_1 = __nccwpck_require__(698);
-const DOMException_1 = __nccwpck_require__(7175);
-const interfaces_1 = __nccwpck_require__(9454);
-const util_1 = __nccwpck_require__(8247);
-const util_2 = __nccwpck_require__(7061);
-const infra_1 = __nccwpck_require__(4737);
-const CustomElementAlgorithm_1 = __nccwpck_require__(5075);
-const TreeAlgorithm_1 = __nccwpck_require__(3532);
-const NodeIteratorAlgorithm_1 = __nccwpck_require__(9670);
-const ShadowTreeAlgorithm_1 = __nccwpck_require__(708);
-const MutationObserverAlgorithm_1 = __nccwpck_require__(3243);
-const DOMAlgorithm_1 = __nccwpck_require__(9484);
-const DocumentAlgorithm_1 = __nccwpck_require__(1327);
-/**
- * Ensures pre-insertion validity of a node into a parent before a
- * child.
- *
- * @param node - node to insert
- * @param parent - parent node to receive node
- * @param child - child node to insert node before
- */
-function mutation_ensurePreInsertionValidity(node, parent, child) {
- const parentNodeType = parent._nodeType;
- const nodeNodeType = node._nodeType;
- const childNodeType = child ? child._nodeType : null;
- /**
- * 1. If parent is not a Document, DocumentFragment, or Element node,
- * throw a "HierarchyRequestError" DOMException.
- */
- if (parentNodeType !== interfaces_1.NodeType.Document &&
- parentNodeType !== interfaces_1.NodeType.DocumentFragment &&
- parentNodeType !== interfaces_1.NodeType.Element)
- throw new DOMException_1.HierarchyRequestError(`Only document, document fragment and element nodes can contain child nodes. Parent node is ${parent.nodeName}.`);
- /**
- * 2. If node is a host-including inclusive ancestor of parent, throw a
- * "HierarchyRequestError" DOMException.
- */
- if ((0, TreeAlgorithm_1.tree_isHostIncludingAncestorOf)(parent, node, true))
- throw new DOMException_1.HierarchyRequestError(`The node to be inserted cannot be an inclusive ancestor of parent node. Node is ${node.nodeName}, parent node is ${parent.nodeName}.`);
- /**
- * 3. If child is not null and its parent is not parent, then throw a
- * "NotFoundError" DOMException.
- */
- if (child !== null && child._parent !== parent)
- throw new DOMException_1.NotFoundError(`The reference child node cannot be found under parent node. Child node is ${child.nodeName}, parent node is ${parent.nodeName}.`);
- /**
- * 4. If node is not a DocumentFragment, DocumentType, Element, Text,
- * ProcessingInstruction, or Comment node, throw a "HierarchyRequestError"
- * DOMException.
- */
- if (nodeNodeType !== interfaces_1.NodeType.DocumentFragment &&
- nodeNodeType !== interfaces_1.NodeType.DocumentType &&
- nodeNodeType !== interfaces_1.NodeType.Element &&
- nodeNodeType !== interfaces_1.NodeType.Text &&
- nodeNodeType !== interfaces_1.NodeType.ProcessingInstruction &&
- nodeNodeType !== interfaces_1.NodeType.CData &&
- nodeNodeType !== interfaces_1.NodeType.Comment)
- throw new DOMException_1.HierarchyRequestError(`Only document fragment, document type, element, text, processing instruction, cdata section or comment nodes can be inserted. Node is ${node.nodeName}.`);
- /**
- * 5. If either node is a Text node and parent is a document, or node is a
- * doctype and parent is not a document, throw a "HierarchyRequestError"
- * DOMException.
- */
- if (nodeNodeType === interfaces_1.NodeType.Text &&
- parentNodeType === interfaces_1.NodeType.Document)
- throw new DOMException_1.HierarchyRequestError(`Cannot insert a text node as a child of a document node. Node is ${node.nodeName}.`);
- if (nodeNodeType === interfaces_1.NodeType.DocumentType &&
- parentNodeType !== interfaces_1.NodeType.Document)
- throw new DOMException_1.HierarchyRequestError(`A document type node can only be inserted under a document node. Parent node is ${parent.nodeName}.`);
- /**
- * 6. If parent is a document, and any of the statements below, switched on
- * node, are true, throw a "HierarchyRequestError" DOMException.
- * - DocumentFragment node
- * If node has more than one element child or has a Text node child.
- * Otherwise, if node has one element child and either parent has an element
- * child, child is a doctype, or child is not null and a doctype is
- * following child.
- * - element
- * parent has an element child, child is a doctype, or child is not null and
- * a doctype is following child.
- * - doctype
- * parent has a doctype child, child is non-null and an element is preceding
- * child, or child is null and parent has an element child.
- */
- if (parentNodeType === interfaces_1.NodeType.Document) {
- if (nodeNodeType === interfaces_1.NodeType.DocumentFragment) {
- let eleCount = 0;
- for (const childNode of node._children) {
- if (childNode._nodeType === interfaces_1.NodeType.Element)
- eleCount++;
- else if (childNode._nodeType === interfaces_1.NodeType.Text)
- throw new DOMException_1.HierarchyRequestError(`Cannot insert text a node as a child of a document node. Node is ${childNode.nodeName}.`);
- }
- if (eleCount > 1) {
- throw new DOMException_1.HierarchyRequestError(`A document node can only have one document element node. Document fragment to be inserted has ${eleCount} element nodes.`);
- }
- else if (eleCount === 1) {
- for (const ele of parent._children) {
- if (ele._nodeType === interfaces_1.NodeType.Element)
- throw new DOMException_1.HierarchyRequestError(`The document node already has a document element node.`);
- }
- if (child) {
- if (childNodeType === interfaces_1.NodeType.DocumentType)
- throw new DOMException_1.HierarchyRequestError(`Cannot insert an element node before a document type node.`);
- let doctypeChild = child._nextSibling;
- while (doctypeChild) {
- if (doctypeChild._nodeType === interfaces_1.NodeType.DocumentType)
- throw new DOMException_1.HierarchyRequestError(`Cannot insert an element node before a document type node.`);
- doctypeChild = doctypeChild._nextSibling;
- }
- }
- }
- }
- else if (nodeNodeType === interfaces_1.NodeType.Element) {
- for (const ele of parent._children) {
- if (ele._nodeType === interfaces_1.NodeType.Element)
- throw new DOMException_1.HierarchyRequestError(`Document already has a document element node. Node is ${node.nodeName}.`);
- }
- if (child) {
- if (childNodeType === interfaces_1.NodeType.DocumentType)
- throw new DOMException_1.HierarchyRequestError(`Cannot insert an element node before a document type node. Node is ${node.nodeName}.`);
- let doctypeChild = child._nextSibling;
- while (doctypeChild) {
- if (doctypeChild._nodeType === interfaces_1.NodeType.DocumentType)
- throw new DOMException_1.HierarchyRequestError(`Cannot insert an element node before a document type node. Node is ${node.nodeName}.`);
- doctypeChild = doctypeChild._nextSibling;
- }
- }
- }
- else if (nodeNodeType === interfaces_1.NodeType.DocumentType) {
- for (const ele of parent._children) {
- if (ele._nodeType === interfaces_1.NodeType.DocumentType)
- throw new DOMException_1.HierarchyRequestError(`Document already has a document type node. Node is ${node.nodeName}.`);
- }
- if (child) {
- let elementChild = child._previousSibling;
- while (elementChild) {
- if (elementChild._nodeType === interfaces_1.NodeType.Element)
- throw new DOMException_1.HierarchyRequestError(`Cannot insert a document type node before an element node. Node is ${node.nodeName}.`);
- elementChild = elementChild._previousSibling;
- }
- }
- else {
- let elementChild = parent._firstChild;
- while (elementChild) {
- if (elementChild._nodeType === interfaces_1.NodeType.Element)
- throw new DOMException_1.HierarchyRequestError(`Cannot insert a document type node before an element node. Node is ${node.nodeName}.`);
- elementChild = elementChild._nextSibling;
- }
- }
- }
- }
-}
-/**
- * Ensures pre-insertion validity of a node into a parent before a
- * child, then adopts the node to the tree and inserts it.
- *
- * @param node - node to insert
- * @param parent - parent node to receive node
- * @param child - child node to insert node before
- */
-function mutation_preInsert(node, parent, child) {
- /**
- * 1. Ensure pre-insertion validity of node into parent before child.
- * 2. Let reference child be child.
- * 3. If reference child is node, set it to node’s next sibling.
- * 4. Adopt node into parent’s node document.
- * 5. Insert node into parent before reference child.
- * 6. Return node.
- */
- mutation_ensurePreInsertionValidity(node, parent, child);
- let referenceChild = child;
- if (referenceChild === node)
- referenceChild = node._nextSibling;
- (0, DocumentAlgorithm_1.document_adopt)(node, parent._nodeDocument);
- mutation_insert(node, parent, referenceChild);
- return node;
-}
-/**
- * Inserts a node into a parent node before the given child node.
- *
- * @param node - node to insert
- * @param parent - parent node to receive node
- * @param child - child node to insert node before
- * @param suppressObservers - whether to notify observers
- */
-function mutation_insert(node, parent, child, suppressObservers) {
- // Optimized common case
- if (child === null && node._nodeType !== interfaces_1.NodeType.DocumentFragment) {
- mutation_insert_single(node, parent, suppressObservers);
- return;
- }
- /**
- * 1. Let count be the number of children of node if it is a
- * DocumentFragment node, and one otherwise.
- */
- const count = (node._nodeType === interfaces_1.NodeType.DocumentFragment ?
- node._children.size : 1);
- /**
- * 2. If child is non-null, then:
- */
- if (child !== null) {
- /**
- * 2.1. For each live range whose start node is parent and start
- * offset is greater than child's index, increase its start
- * offset by count.
- * 2.2. For each live range whose end node is parent and end
- * offset is greater than child's index, increase its end
- * offset by count.
- */
- if (DOMImpl_1.dom.rangeList.size !== 0) {
- const index = (0, TreeAlgorithm_1.tree_index)(child);
- for (const range of DOMImpl_1.dom.rangeList) {
- if (range._start[0] === parent && range._start[1] > index) {
- range._start[1] += count;
- }
- if (range._end[0] === parent && range._end[1] > index) {
- range._end[1] += count;
- }
- }
- }
- }
- /**
- * 3. Let nodes be node’s children, if node is a DocumentFragment node;
- * otherwise « node ».
- */
- const nodes = node._nodeType === interfaces_1.NodeType.DocumentFragment ?
- new Array(...node._children) : [node];
- /**
- * 4. If node is a DocumentFragment node, remove its children with the
- * suppress observers flag set.
- */
- if (node._nodeType === interfaces_1.NodeType.DocumentFragment) {
- while (node._firstChild) {
- mutation_remove(node._firstChild, node, true);
- }
- }
- /**
- * 5. If node is a DocumentFragment node, then queue a tree mutation record
- * for node with « », nodes, null, and null.
- */
- if (DOMImpl_1.dom.features.mutationObservers) {
- if (node._nodeType === interfaces_1.NodeType.DocumentFragment) {
- (0, MutationObserverAlgorithm_1.observer_queueTreeMutationRecord)(node, [], nodes, null, null);
- }
- }
- /**
- * 6. Let previousSibling be child’s previous sibling or parent’s last
- * child if child is null.
- */
- const previousSibling = (child ? child._previousSibling : parent._lastChild);
- let index = child === null ? -1 : (0, TreeAlgorithm_1.tree_index)(child);
- /**
- * 7. For each node in nodes, in tree order:
- */
- for (let i = 0; i < nodes.length; i++) {
- const node = nodes[i];
- if (util_1.Guard.isElementNode(node)) {
- // set document element node
- if (util_1.Guard.isDocumentNode(parent)) {
- parent._documentElement = node;
- }
- // mark that the document has namespaces
- if (!node._nodeDocument._hasNamespaces && (node._namespace !== null ||
- node._namespacePrefix !== null)) {
- node._nodeDocument._hasNamespaces = true;
- }
- }
- /**
- * 7.1. If child is null, then append node to parent’s children.
- * 7.2. Otherwise, insert node into parent’s children before child’s
- * index.
- */
- node._parent = parent;
- if (child === null) {
- infra_1.set.append(parent._children, node);
- }
- else {
- infra_1.set.insert(parent._children, node, index);
- index++;
- }
- // assign siblings and children for quick lookups
- if (parent._firstChild === null) {
- node._previousSibling = null;
- node._nextSibling = null;
- parent._firstChild = node;
- parent._lastChild = node;
- }
- else {
- const prev = (child ? child._previousSibling : parent._lastChild);
- const next = (child ? child : null);
- node._previousSibling = prev;
- node._nextSibling = next;
- if (prev)
- prev._nextSibling = node;
- if (next)
- next._previousSibling = node;
- if (!prev)
- parent._firstChild = node;
- if (!next)
- parent._lastChild = node;
- }
- /**
- * 7.3. If parent is a shadow host and node is a slotable, then
- * assign a slot for node.
- */
- if (DOMImpl_1.dom.features.slots) {
- if (parent._shadowRoot !== null && util_1.Guard.isSlotable(node)) {
- (0, ShadowTreeAlgorithm_1.shadowTree_assignASlot)(node);
- }
- }
- /**
- * 7.4. If node is a Text node, run the child text content change
- * steps for parent.
- */
- if (DOMImpl_1.dom.features.steps) {
- if (util_1.Guard.isTextNode(node)) {
- (0, DOMAlgorithm_1.dom_runChildTextContentChangeSteps)(parent);
- }
- }
- /**
- * 7.5. If parent's root is a shadow root, and parent is a slot
- * whose assigned nodes is the empty list, then run signal
- * a slot change for parent.
- */
- if (DOMImpl_1.dom.features.slots) {
- if (util_1.Guard.isShadowRoot((0, TreeAlgorithm_1.tree_rootNode)(parent)) &&
- util_1.Guard.isSlot(parent) && (0, util_2.isEmpty)(parent._assignedNodes)) {
- (0, ShadowTreeAlgorithm_1.shadowTree_signalASlotChange)(parent);
- }
- }
- /**
- * 7.6. Run assign slotables for a tree with node's root.
- */
- if (DOMImpl_1.dom.features.slots) {
- (0, ShadowTreeAlgorithm_1.shadowTree_assignSlotablesForATree)((0, TreeAlgorithm_1.tree_rootNode)(node));
- }
- /**
- * 7.7. For each shadow-including inclusive descendant
- * inclusiveDescendant of node, in shadow-including tree
- * order:
- */
- let inclusiveDescendant = (0, TreeAlgorithm_1.tree_getFirstDescendantNode)(node, true, true);
- while (inclusiveDescendant !== null) {
- /**
- * 7.7.1. Run the insertion steps with inclusiveDescendant.
- */
- if (DOMImpl_1.dom.features.steps) {
- (0, DOMAlgorithm_1.dom_runInsertionSteps)(inclusiveDescendant);
- }
- if (DOMImpl_1.dom.features.customElements) {
- /**
- * 7.7.2. If inclusiveDescendant is connected, then:
- */
- if (util_1.Guard.isElementNode(inclusiveDescendant) &&
- (0, ShadowTreeAlgorithm_1.shadowTree_isConnected)(inclusiveDescendant)) {
- if (util_1.Guard.isCustomElementNode(inclusiveDescendant)) {
- /**
- * 7.7.2.1. If inclusiveDescendant is custom, then enqueue a custom
- * element callback reaction with inclusiveDescendant, callback name
- * "connectedCallback", and an empty argument list.
- */
- (0, CustomElementAlgorithm_1.customElement_enqueueACustomElementCallbackReaction)(inclusiveDescendant, "connectedCallback", []);
- }
- else {
- /**
- * 7.7.2.2. Otherwise, try to upgrade inclusiveDescendant.
- */
- (0, CustomElementAlgorithm_1.customElement_tryToUpgrade)(inclusiveDescendant);
- }
- }
- }
- inclusiveDescendant = (0, TreeAlgorithm_1.tree_getNextDescendantNode)(node, inclusiveDescendant, true, true);
- }
- }
- /**
- * 8. If suppress observers flag is unset, then queue a tree mutation record
- * for parent with nodes, « », previousSibling, and child.
- */
- if (DOMImpl_1.dom.features.mutationObservers) {
- if (!suppressObservers) {
- (0, MutationObserverAlgorithm_1.observer_queueTreeMutationRecord)(parent, nodes, [], previousSibling, child);
- }
- }
-}
-/**
- * Inserts a node into a parent node. Optimized routine for the common case where
- * node is not a document fragment node and it has no child nodes.
- *
- * @param node - node to insert
- * @param parent - parent node to receive node
- * @param suppressObservers - whether to notify observers
- */
-function mutation_insert_single(node, parent, suppressObservers) {
- /**
- * 1. Let count be the number of children of node if it is a
- * DocumentFragment node, and one otherwise.
- * 2. If child is non-null, then:
- * 2.1. For each live range whose start node is parent and start
- * offset is greater than child's index, increase its start
- * offset by count.
- * 2.2. For each live range whose end node is parent and end
- * offset is greater than child's index, increase its end
- * offset by count.
- * 3. Let nodes be node’s children, if node is a DocumentFragment node;
- * otherwise « node ».
- * 4. If node is a DocumentFragment node, remove its children with the
- * suppress observers flag set.
- * 5. If node is a DocumentFragment node, then queue a tree mutation record
- * for node with « », nodes, null, and null.
- */
- /**
- * 6. Let previousSibling be child’s previous sibling or parent’s last
- * child if child is null.
- */
- const previousSibling = parent._lastChild;
- // set document element node
- if (util_1.Guard.isElementNode(node)) {
- // set document element node
- if (util_1.Guard.isDocumentNode(parent)) {
- parent._documentElement = node;
- }
- // mark that the document has namespaces
- if (!node._nodeDocument._hasNamespaces && (node._namespace !== null ||
- node._namespacePrefix !== null)) {
- node._nodeDocument._hasNamespaces = true;
- }
- }
- /**
- * 7. For each node in nodes, in tree order:
- * 7.1. If child is null, then append node to parent’s children.
- * 7.2. Otherwise, insert node into parent’s children before child’s
- * index.
- */
- node._parent = parent;
- parent._children.add(node);
- // assign siblings and children for quick lookups
- if (parent._firstChild === null) {
- node._previousSibling = null;
- node._nextSibling = null;
- parent._firstChild = node;
- parent._lastChild = node;
- }
- else {
- const prev = parent._lastChild;
- node._previousSibling = prev;
- node._nextSibling = null;
- if (prev)
- prev._nextSibling = node;
- if (!prev)
- parent._firstChild = node;
- parent._lastChild = node;
- }
- /**
- * 7.3. If parent is a shadow host and node is a slotable, then
- * assign a slot for node.
- */
- if (DOMImpl_1.dom.features.slots) {
- if (parent._shadowRoot !== null && util_1.Guard.isSlotable(node)) {
- (0, ShadowTreeAlgorithm_1.shadowTree_assignASlot)(node);
- }
- }
- /**
- * 7.4. If node is a Text node, run the child text content change
- * steps for parent.
- */
- if (DOMImpl_1.dom.features.steps) {
- if (util_1.Guard.isTextNode(node)) {
- (0, DOMAlgorithm_1.dom_runChildTextContentChangeSteps)(parent);
- }
- }
- /**
- * 7.5. If parent's root is a shadow root, and parent is a slot
- * whose assigned nodes is the empty list, then run signal
- * a slot change for parent.
- */
- if (DOMImpl_1.dom.features.slots) {
- if (util_1.Guard.isShadowRoot((0, TreeAlgorithm_1.tree_rootNode)(parent)) &&
- util_1.Guard.isSlot(parent) && (0, util_2.isEmpty)(parent._assignedNodes)) {
- (0, ShadowTreeAlgorithm_1.shadowTree_signalASlotChange)(parent);
- }
- }
- /**
- * 7.6. Run assign slotables for a tree with node's root.
- */
- if (DOMImpl_1.dom.features.slots) {
- (0, ShadowTreeAlgorithm_1.shadowTree_assignSlotablesForATree)((0, TreeAlgorithm_1.tree_rootNode)(node));
- }
- /**
- * 7.7. For each shadow-including inclusive descendant
- * inclusiveDescendant of node, in shadow-including tree
- * order:
- * 7.7.1. Run the insertion steps with inclusiveDescendant.
- */
- if (DOMImpl_1.dom.features.steps) {
- (0, DOMAlgorithm_1.dom_runInsertionSteps)(node);
- }
- if (DOMImpl_1.dom.features.customElements) {
- /**
- * 7.7.2. If inclusiveDescendant is connected, then:
- */
- if (util_1.Guard.isElementNode(node) &&
- (0, ShadowTreeAlgorithm_1.shadowTree_isConnected)(node)) {
- if (util_1.Guard.isCustomElementNode(node)) {
- /**
- * 7.7.2.1. If inclusiveDescendant is custom, then enqueue a custom
- * element callback reaction with inclusiveDescendant, callback name
- * "connectedCallback", and an empty argument list.
- */
- (0, CustomElementAlgorithm_1.customElement_enqueueACustomElementCallbackReaction)(node, "connectedCallback", []);
- }
- else {
- /**
- * 7.7.2.2. Otherwise, try to upgrade inclusiveDescendant.
- */
- (0, CustomElementAlgorithm_1.customElement_tryToUpgrade)(node);
- }
- }
- }
- /**
- * 8. If suppress observers flag is unset, then queue a tree mutation record
- * for parent with nodes, « », previousSibling, and child.
- */
- if (DOMImpl_1.dom.features.mutationObservers) {
- if (!suppressObservers) {
- (0, MutationObserverAlgorithm_1.observer_queueTreeMutationRecord)(parent, [node], [], previousSibling, null);
- }
- }
-}
-/**
- * Appends a node to the children of a parent node.
- *
- * @param node - a node
- * @param parent - the parent to receive node
- */
-function mutation_append(node, parent) {
- /**
- * To append a node to a parent, pre-insert node into parent before null.
- */
- return mutation_preInsert(node, parent, null);
-}
-/**
- * Replaces a node with another node.
- *
- * @param child - child node to remove
- * @param node - node to insert
- * @param parent - parent node to receive node
- */
-function mutation_replace(child, node, parent) {
- /**
- * 1. If parent is not a Document, DocumentFragment, or Element node,
- * throw a "HierarchyRequestError" DOMException.
- */
- if (parent._nodeType !== interfaces_1.NodeType.Document &&
- parent._nodeType !== interfaces_1.NodeType.DocumentFragment &&
- parent._nodeType !== interfaces_1.NodeType.Element)
- throw new DOMException_1.HierarchyRequestError(`Only document, document fragment and element nodes can contain child nodes. Parent node is ${parent.nodeName}.`);
- /**
- * 2. If node is a host-including inclusive ancestor of parent, throw a
- * "HierarchyRequestError" DOMException.
- */
- if ((0, TreeAlgorithm_1.tree_isHostIncludingAncestorOf)(parent, node, true))
- throw new DOMException_1.HierarchyRequestError(`The node to be inserted cannot be an ancestor of parent node. Node is ${node.nodeName}, parent node is ${parent.nodeName}.`);
- /**
- * 3. If child’s parent is not parent, then throw a "NotFoundError"
- * DOMException.
- */
- if (child._parent !== parent)
- throw new DOMException_1.NotFoundError(`The reference child node cannot be found under parent node. Child node is ${child.nodeName}, parent node is ${parent.nodeName}.`);
- /**
- * 4. If node is not a DocumentFragment, DocumentType, Element, Text,
- * ProcessingInstruction, or Comment node, throw a "HierarchyRequestError"
- * DOMException.
- */
- if (node._nodeType !== interfaces_1.NodeType.DocumentFragment &&
- node._nodeType !== interfaces_1.NodeType.DocumentType &&
- node._nodeType !== interfaces_1.NodeType.Element &&
- node._nodeType !== interfaces_1.NodeType.Text &&
- node._nodeType !== interfaces_1.NodeType.ProcessingInstruction &&
- node._nodeType !== interfaces_1.NodeType.CData &&
- node._nodeType !== interfaces_1.NodeType.Comment)
- throw new DOMException_1.HierarchyRequestError(`Only document fragment, document type, element, text, processing instruction, cdata section or comment nodes can be inserted. Node is ${node.nodeName}.`);
- /**
- * 5. If either node is a Text node and parent is a document, or node is a
- * doctype and parent is not a document, throw a "HierarchyRequestError"
- * DOMException.
- */
- if (node._nodeType === interfaces_1.NodeType.Text &&
- parent._nodeType === interfaces_1.NodeType.Document)
- throw new DOMException_1.HierarchyRequestError(`Cannot insert a text node as a child of a document node. Node is ${node.nodeName}.`);
- if (node._nodeType === interfaces_1.NodeType.DocumentType &&
- parent._nodeType !== interfaces_1.NodeType.Document)
- throw new DOMException_1.HierarchyRequestError(`A document type node can only be inserted under a document node. Parent node is ${parent.nodeName}.`);
- /**
- * 6. If parent is a document, and any of the statements below, switched on
- * node, are true, throw a "HierarchyRequestError" DOMException.
- * - DocumentFragment node
- * If node has more than one element child or has a Text node child.
- * Otherwise, if node has one element child and either parent has an element
- * child that is not child or a doctype is following child.
- * - element
- * parent has an element child that is not child or a doctype is
- * following child.
- * - doctype
- * parent has a doctype child that is not child, or an element is
- * preceding child.
- */
- if (parent._nodeType === interfaces_1.NodeType.Document) {
- if (node._nodeType === interfaces_1.NodeType.DocumentFragment) {
- let eleCount = 0;
- for (const childNode of node._children) {
- if (childNode._nodeType === interfaces_1.NodeType.Element)
- eleCount++;
- else if (childNode._nodeType === interfaces_1.NodeType.Text)
- throw new DOMException_1.HierarchyRequestError(`Cannot insert text a node as a child of a document node. Node is ${childNode.nodeName}.`);
- }
- if (eleCount > 1) {
- throw new DOMException_1.HierarchyRequestError(`A document node can only have one document element node. Document fragment to be inserted has ${eleCount} element nodes.`);
- }
- else if (eleCount === 1) {
- for (const ele of parent._children) {
- if (ele._nodeType === interfaces_1.NodeType.Element && ele !== child)
- throw new DOMException_1.HierarchyRequestError(`The document node already has a document element node.`);
- }
- let doctypeChild = child._nextSibling;
- while (doctypeChild) {
- if (doctypeChild._nodeType === interfaces_1.NodeType.DocumentType)
- throw new DOMException_1.HierarchyRequestError(`Cannot insert an element node before a document type node.`);
- doctypeChild = doctypeChild._nextSibling;
- }
- }
- }
- else if (node._nodeType === interfaces_1.NodeType.Element) {
- for (const ele of parent._children) {
- if (ele._nodeType === interfaces_1.NodeType.Element && ele !== child)
- throw new DOMException_1.HierarchyRequestError(`Document already has a document element node. Node is ${node.nodeName}.`);
- }
- let doctypeChild = child._nextSibling;
- while (doctypeChild) {
- if (doctypeChild._nodeType === interfaces_1.NodeType.DocumentType)
- throw new DOMException_1.HierarchyRequestError(`Cannot insert an element node before a document type node. Node is ${node.nodeName}.`);
- doctypeChild = doctypeChild._nextSibling;
- }
- }
- else if (node._nodeType === interfaces_1.NodeType.DocumentType) {
- for (const ele of parent._children) {
- if (ele._nodeType === interfaces_1.NodeType.DocumentType && ele !== child)
- throw new DOMException_1.HierarchyRequestError(`Document already has a document type node. Node is ${node.nodeName}.`);
- }
- let elementChild = child._previousSibling;
- while (elementChild) {
- if (elementChild._nodeType === interfaces_1.NodeType.Element)
- throw new DOMException_1.HierarchyRequestError(`Cannot insert a document type node before an element node. Node is ${node.nodeName}.`);
- elementChild = elementChild._previousSibling;
- }
- }
- }
- /**
- * 7. Let reference child be child’s next sibling.
- * 8. If reference child is node, set it to node’s next sibling.
- * 8. Let previousSibling be child’s previous sibling.
- */
- let referenceChild = child._nextSibling;
- if (referenceChild === node)
- referenceChild = node._nextSibling;
- let previousSibling = child._previousSibling;
- /**
- * 10. Adopt node into parent’s node document.
- * 11. Let removedNodes be the empty list.
- */
- (0, DocumentAlgorithm_1.document_adopt)(node, parent._nodeDocument);
- const removedNodes = [];
- /**
- * 12. If child’s parent is not null, then:
- */
- if (child._parent !== null) {
- /**
- * 12.1. Set removedNodes to [child].
- * 12.2. Remove child from its parent with the suppress observers flag
- * set.
- */
- removedNodes.push(child);
- mutation_remove(child, child._parent, true);
- }
- /**
- * 13. Let nodes be node’s children if node is a DocumentFragment node;
- * otherwise [node].
- */
- let nodes = [];
- if (node._nodeType === interfaces_1.NodeType.DocumentFragment) {
- nodes = Array.from(node._children);
- }
- else {
- nodes.push(node);
- }
- /**
- * 14. Insert node into parent before reference child with the suppress
- * observers flag set.
- */
- mutation_insert(node, parent, referenceChild, true);
- /**
- * 15. Queue a tree mutation record for parent with nodes, removedNodes,
- * previousSibling, and reference child.
- */
- if (DOMImpl_1.dom.features.mutationObservers) {
- (0, MutationObserverAlgorithm_1.observer_queueTreeMutationRecord)(parent, nodes, removedNodes, previousSibling, referenceChild);
- }
- /**
- * 16. Return child.
- */
- return child;
-}
-/**
- * Replaces all nodes of a parent with the given node.
- *
- * @param node - node to insert
- * @param parent - parent node to receive node
- */
-function mutation_replaceAll(node, parent) {
- /**
- * 1. If node is not null, adopt node into parent’s node document.
- */
- if (node !== null) {
- (0, DocumentAlgorithm_1.document_adopt)(node, parent._nodeDocument);
- }
- /**
- * 2. Let removedNodes be parent’s children.
- */
- const removedNodes = Array.from(parent._children);
- /**
- * 3. Let addedNodes be the empty list.
- * 4. If node is DocumentFragment node, then set addedNodes to node’s
- * children.
- * 5. Otherwise, if node is non-null, set addedNodes to [node].
- */
- let addedNodes = [];
- if (node && node._nodeType === interfaces_1.NodeType.DocumentFragment) {
- addedNodes = Array.from(node._children);
- }
- else if (node !== null) {
- addedNodes.push(node);
- }
- /**
- * 6. Remove all parent’s children, in tree order, with the suppress
- * observers flag set.
- */
- for (const childNode of removedNodes) {
- mutation_remove(childNode, parent, true);
- }
- /**
- * 7. If node is not null, then insert node into parent before null with the
- * suppress observers flag set.
- */
- if (node !== null) {
- mutation_insert(node, parent, null, true);
- }
- /**
- * 8. Queue a tree mutation record for parent with addedNodes, removedNodes,
- * null, and null.
- */
- if (DOMImpl_1.dom.features.mutationObservers) {
- (0, MutationObserverAlgorithm_1.observer_queueTreeMutationRecord)(parent, addedNodes, removedNodes, null, null);
- }
-}
-/**
- * Ensures pre-removal validity of a child node from a parent, then
- * removes it.
- *
- * @param child - child node to remove
- * @param parent - parent node
- */
-function mutation_preRemove(child, parent) {
- /**
- * 1. If child’s parent is not parent, then throw a "NotFoundError"
- * DOMException.
- * 2. Remove child from parent.
- * 3. Return child.
- */
- if (child._parent !== parent)
- throw new DOMException_1.NotFoundError(`The child node cannot be found under parent node. Child node is ${child.nodeName}, parent node is ${parent.nodeName}.`);
- mutation_remove(child, parent);
- return child;
-}
-/**
- * Removes a child node from its parent.
- *
- * @param node - node to remove
- * @param parent - parent node
- * @param suppressObservers - whether to notify observers
- */
-function mutation_remove(node, parent, suppressObservers) {
- if (DOMImpl_1.dom.rangeList.size !== 0) {
- /**
- * 1. Let index be node’s index.
- */
- const index = (0, TreeAlgorithm_1.tree_index)(node);
- /**
- * 2. For each live range whose start node is an inclusive descendant of
- * node, set its start to (parent, index).
- * 3. For each live range whose end node is an inclusive descendant of
- * node, set its end to (parent, index).
- */
- for (const range of DOMImpl_1.dom.rangeList) {
- if ((0, TreeAlgorithm_1.tree_isDescendantOf)(node, range._start[0], true)) {
- range._start = [parent, index];
- }
- if ((0, TreeAlgorithm_1.tree_isDescendantOf)(node, range._end[0], true)) {
- range._end = [parent, index];
- }
- if (range._start[0] === parent && range._start[1] > index) {
- range._start[1]--;
- }
- if (range._end[0] === parent && range._end[1] > index) {
- range._end[1]--;
- }
- }
- /**
- * 4. For each live range whose start node is parent and start offset is
- * greater than index, decrease its start offset by 1.
- * 5. For each live range whose end node is parent and end offset is greater
- * than index, decrease its end offset by 1.
- */
- for (const range of DOMImpl_1.dom.rangeList) {
- if (range._start[0] === parent && range._start[1] > index) {
- range._start[1] -= 1;
- }
- if (range._end[0] === parent && range._end[1] > index) {
- range._end[1] -= 1;
- }
- }
- }
- /**
- * 6. For each NodeIterator object iterator whose root’s node document is
- * node’s node document, run the NodeIterator pre-removing steps given node
- * and iterator.
- */
- if (DOMImpl_1.dom.features.steps) {
- for (const iterator of (0, NodeIteratorAlgorithm_1.nodeIterator_iteratorList)()) {
- if (iterator._root._nodeDocument === node._nodeDocument) {
- (0, DOMAlgorithm_1.dom_runNodeIteratorPreRemovingSteps)(iterator, node);
- }
- }
- }
- /**
- * 7. Let oldPreviousSibling be node’s previous sibling.
- * 8. Let oldNextSibling be node’s next sibling.
- */
- const oldPreviousSibling = node._previousSibling;
- const oldNextSibling = node._nextSibling;
- // set document element node
- if (util_1.Guard.isDocumentNode(parent) && util_1.Guard.isElementNode(node)) {
- parent._documentElement = null;
- }
- /**
- * 9. Remove node from its parent’s children.
- */
- node._parent = null;
- parent._children.delete(node);
- // assign siblings and children for quick lookups
- const prev = node._previousSibling;
- const next = node._nextSibling;
- node._previousSibling = null;
- node._nextSibling = null;
- if (prev)
- prev._nextSibling = next;
- if (next)
- next._previousSibling = prev;
- if (!prev)
- parent._firstChild = next;
- if (!next)
- parent._lastChild = prev;
- /**
- * 10. If node is assigned, then run assign slotables for node’s assigned
- * slot.
- */
- if (DOMImpl_1.dom.features.slots) {
- if (util_1.Guard.isSlotable(node) && node._assignedSlot !== null && (0, ShadowTreeAlgorithm_1.shadowTree_isAssigned)(node)) {
- (0, ShadowTreeAlgorithm_1.shadowTree_assignSlotables)(node._assignedSlot);
- }
- }
- /**
- * 11. If parent’s root is a shadow root, and parent is a slot whose
- * assigned nodes is the empty list, then run signal a slot change for
- * parent.
- */
- if (DOMImpl_1.dom.features.slots) {
- if (util_1.Guard.isShadowRoot((0, TreeAlgorithm_1.tree_rootNode)(parent)) &&
- util_1.Guard.isSlot(parent) && (0, util_2.isEmpty)(parent._assignedNodes)) {
- (0, ShadowTreeAlgorithm_1.shadowTree_signalASlotChange)(parent);
- }
- }
- /**
- * 12. If node has an inclusive descendant that is a slot, then:
- * 12.1. Run assign slotables for a tree with parent's root.
- * 12.2. Run assign slotables for a tree with node.
- */
- if (DOMImpl_1.dom.features.slots) {
- const descendant = (0, TreeAlgorithm_1.tree_getFirstDescendantNode)(node, true, false, (e) => util_1.Guard.isSlot(e));
- if (descendant !== null) {
- (0, ShadowTreeAlgorithm_1.shadowTree_assignSlotablesForATree)((0, TreeAlgorithm_1.tree_rootNode)(parent));
- (0, ShadowTreeAlgorithm_1.shadowTree_assignSlotablesForATree)(node);
- }
- }
- /**
- * 13. Run the removing steps with node and parent.
- */
- if (DOMImpl_1.dom.features.steps) {
- (0, DOMAlgorithm_1.dom_runRemovingSteps)(node, parent);
- }
- /**
- * 14. If node is custom, then enqueue a custom element callback
- * reaction with node, callback name "disconnectedCallback",
- * and an empty argument list.
- */
- if (DOMImpl_1.dom.features.customElements) {
- if (util_1.Guard.isCustomElementNode(node)) {
- (0, CustomElementAlgorithm_1.customElement_enqueueACustomElementCallbackReaction)(node, "disconnectedCallback", []);
- }
- }
- /**
- * 15. For each shadow-including descendant descendant of node,
- * in shadow-including tree order, then:
- */
- let descendant = (0, TreeAlgorithm_1.tree_getFirstDescendantNode)(node, false, true);
- while (descendant !== null) {
- /**
- * 15.1. Run the removing steps with descendant.
- */
- if (DOMImpl_1.dom.features.steps) {
- (0, DOMAlgorithm_1.dom_runRemovingSteps)(descendant, node);
- }
- /**
- * 15.2. If descendant is custom, then enqueue a custom element
- * callback reaction with descendant, callback name
- * "disconnectedCallback", and an empty argument list.
- */
- if (DOMImpl_1.dom.features.customElements) {
- if (util_1.Guard.isCustomElementNode(descendant)) {
- (0, CustomElementAlgorithm_1.customElement_enqueueACustomElementCallbackReaction)(descendant, "disconnectedCallback", []);
- }
- }
- descendant = (0, TreeAlgorithm_1.tree_getNextDescendantNode)(node, descendant, false, true);
- }
- /**
- * 16. For each inclusive ancestor inclusiveAncestor of parent, and
- * then for each registered of inclusiveAncestor's registered
- * observer list, if registered's options's subtree is true,
- * then append a new transient registered observer whose
- * observer is registered's observer, options is registered's
- * options, and source is registered to node's registered
- * observer list.
- */
- if (DOMImpl_1.dom.features.mutationObservers) {
- let inclusiveAncestor = (0, TreeAlgorithm_1.tree_getFirstAncestorNode)(parent, true);
- while (inclusiveAncestor !== null) {
- for (const registered of inclusiveAncestor._registeredObserverList) {
- if (registered.options.subtree) {
- node._registeredObserverList.push({
- observer: registered.observer,
- options: registered.options,
- source: registered
- });
- }
- }
- inclusiveAncestor = (0, TreeAlgorithm_1.tree_getNextAncestorNode)(parent, inclusiveAncestor, true);
- }
- }
- /**
- * 17. If suppress observers flag is unset, then queue a tree mutation
- * record for parent with « », « node », oldPreviousSibling, and
- * oldNextSibling.
- */
- if (DOMImpl_1.dom.features.mutationObservers) {
- if (!suppressObservers) {
- (0, MutationObserverAlgorithm_1.observer_queueTreeMutationRecord)(parent, [], [node], oldPreviousSibling, oldNextSibling);
- }
- }
- /**
- * 18. If node is a Text node, then run the child text content change steps
- * for parent.
- */
- if (DOMImpl_1.dom.features.steps) {
- if (util_1.Guard.isTextNode(node)) {
- (0, DOMAlgorithm_1.dom_runChildTextContentChangeSteps)(parent);
- }
- }
-}
-//# sourceMappingURL=MutationAlgorithm.js.map
-
-/***/ }),
-
-/***/ 3243:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.observer_queueAMutationObserverMicrotask = observer_queueAMutationObserverMicrotask;
-exports.observer_notifyMutationObservers = observer_notifyMutationObservers;
-exports.observer_queueMutationRecord = observer_queueMutationRecord;
-exports.observer_queueTreeMutationRecord = observer_queueTreeMutationRecord;
-exports.observer_queueAttributeMutationRecord = observer_queueAttributeMutationRecord;
-const DOMImpl_1 = __nccwpck_require__(698);
-const util_1 = __nccwpck_require__(8247);
-const infra_1 = __nccwpck_require__(4737);
-const CreateAlgorithm_1 = __nccwpck_require__(8308);
-const TreeAlgorithm_1 = __nccwpck_require__(3532);
-const EventAlgorithm_1 = __nccwpck_require__(8012);
-/**
- * Queues a mutation observer microtask to the surrounding agent’s mutation
- * observers.
- */
-function observer_queueAMutationObserverMicrotask() {
- /**
- * 1. If the surrounding agent’s mutation observer microtask queued is true,
- * then return.
- * 2. Set the surrounding agent’s mutation observer microtask queued to true.
- * 3. Queue a microtask to notify mutation observers.
- */
- const window = DOMImpl_1.dom.window;
- if (window._mutationObserverMicrotaskQueued)
- return;
- window._mutationObserverMicrotaskQueued = true;
- Promise.resolve().then(() => { observer_notifyMutationObservers(); });
-}
-/**
- * Notifies the surrounding agent’s mutation observers.
- */
-function observer_notifyMutationObservers() {
- /**
- * 1. Set the surrounding agent’s mutation observer microtask queued to false.
- * 2. Let notifySet be a clone of the surrounding agent’s mutation observers.
- * 3. Let signalSet be a clone of the surrounding agent’s signal slots.
- * 4. Empty the surrounding agent’s signal slots.
- */
- const window = DOMImpl_1.dom.window;
- window._mutationObserverMicrotaskQueued = false;
- const notifySet = infra_1.set.clone(window._mutationObservers);
- const signalSet = infra_1.set.clone(window._signalSlots);
- infra_1.set.empty(window._signalSlots);
- /**
- * 5. For each mo of notifySet:
- */
- for (const mo of notifySet) {
- /**
- * 5.1. Let records be a clone of mo’s record queue.
- * 5.2. Empty mo’s record queue.
- */
- const records = infra_1.list.clone(mo._recordQueue);
- infra_1.list.empty(mo._recordQueue);
- /**
- * 5.3. For each node of mo’s node list, remove all transient registered
- * observers whose observer is mo from node’s registered observer list.
- */
- for (let i = 0; i < mo._nodeList.length; i++) {
- const node = mo._nodeList[i];
- infra_1.list.remove(node._registeredObserverList, (observer) => {
- return util_1.Guard.isTransientRegisteredObserver(observer) && observer.observer === mo;
- });
- }
- /**
- * 5.4. If records is not empty, then invoke mo’s callback with « records,
- * mo », and mo. If this throws an exception, then report the exception.
- */
- if (!infra_1.list.isEmpty(records)) {
- try {
- mo._callback.call(mo, records, mo);
- }
- catch (err) {
- // TODO: Report the exception
- }
- }
- }
- /**
- * 6. For each slot of signalSet, fire an event named slotchange, with its
- * bubbles attribute set to true, at slot.
- */
- if (DOMImpl_1.dom.features.slots) {
- for (const slot of signalSet) {
- (0, EventAlgorithm_1.event_fireAnEvent)("slotchange", slot, undefined, { bubbles: true });
- }
- }
-}
-/**
- * Queues a mutation record of the given type for target.
- *
- * @param type - mutation record type
- * @param target - target node
- * @param name - name before mutation
- * @param namespace - namespace before mutation
- * @param oldValue - attribute value before mutation
- * @param addedNodes - a list od added nodes
- * @param removedNodes - a list of removed nodes
- * @param previousSibling - previous sibling of target before mutation
- * @param nextSibling - next sibling of target before mutation
- */
-function observer_queueMutationRecord(type, target, name, namespace, oldValue, addedNodes, removedNodes, previousSibling, nextSibling) {
- /**
- * 1. Let interestedObservers be an empty map.
- * 2. Let nodes be the inclusive ancestors of target.
- * 3. For each node in nodes, and then for each registered of node’s
- * registered observer list:
- */
- const interestedObservers = new Map();
- let node = (0, TreeAlgorithm_1.tree_getFirstAncestorNode)(target, true);
- while (node !== null) {
- for (let i = 0; i < node._registeredObserverList.length; i++) {
- const registered = node._registeredObserverList[i];
- /**
- * 3.1. Let options be registered’s options.
- * 3.2. If none of the following are true
- * - node is not target and options’s subtree is false
- * - type is "attributes" and options’s attributes is not true
- * - type is "attributes", options’s attributeFilter is present, and
- * options’s attributeFilter does not contain name or namespace is
- * non-null
- * - type is "characterData" and options’s characterData is not true
- * - type is "childList" and options’s childList is false
- */
- const options = registered.options;
- if (node !== target && !options.subtree)
- continue;
- if (type === "attributes" && !options.attributes)
- continue;
- if (type === "attributes" && options.attributeFilter &&
- (!options.attributeFilter.indexOf(name || '') || namespace !== null))
- continue;
- if (type === "characterData" && !options.characterData)
- continue;
- if (type === "childList" && !options.childList)
- continue;
- /**
- * then:
- * 3.2.1. Let mo be registered’s observer.
- * 3.2.2. If interestedObservers[mo] does not exist, then set
- * interestedObservers[mo] to null.
- * 3.2.3. If either type is "attributes" and options’s attributeOldValue
- * is true, or type is "characterData" and options’s
- * characterDataOldValue is true, then set interestedObservers[mo]
- * to oldValue.
- */
- const mo = registered.observer;
- if (!interestedObservers.has(mo)) {
- interestedObservers.set(mo, null);
- }
- if ((type === "attributes" && options.attributeOldValue) ||
- (type === "characterData" && options.characterDataOldValue)) {
- interestedObservers.set(mo, oldValue);
- }
- }
- node = (0, TreeAlgorithm_1.tree_getNextAncestorNode)(target, node, true);
- }
- /**
- * 4. For each observer → mappedOldValue of interestedObservers:
- */
- for (const [observer, mappedOldValue] of interestedObservers) {
- /**
- * 4.1. Let record be a new MutationRecord object with its type set to
- * type, target set to target, attributeName set to name,
- * attributeNamespace set to namespace, oldValue set to mappedOldValue,
- * addedNodes set to addedNodes, removedNodes set to removedNodes,
- * previousSibling set to previousSibling, and nextSibling set to
- * nextSibling.
- * 4.2. Enqueue record to observer’s record queue.
- */
- const record = (0, CreateAlgorithm_1.create_mutationRecord)(type, target, (0, CreateAlgorithm_1.create_nodeListStatic)(target, addedNodes), (0, CreateAlgorithm_1.create_nodeListStatic)(target, removedNodes), previousSibling, nextSibling, name, namespace, mappedOldValue);
- const queue = observer._recordQueue;
- queue.push(record);
- }
- /**
- * 5. Queue a mutation observer microtask.
- */
- observer_queueAMutationObserverMicrotask();
-}
-/**
- * Queues a tree mutation record for target.
- *
- * @param target - target node
- * @param addedNodes - a list od added nodes
- * @param removedNodes - a list of removed nodes
- * @param previousSibling - previous sibling of target before mutation
- * @param nextSibling - next sibling of target before mutation
- */
-function observer_queueTreeMutationRecord(target, addedNodes, removedNodes, previousSibling, nextSibling) {
- /**
- * To queue a tree mutation record for target with addedNodes, removedNodes,
- * previousSibling, and nextSibling, queue a mutation record of "childList"
- * for target with null, null, null, addedNodes, removedNodes,
- * previousSibling, and nextSibling.
- */
- observer_queueMutationRecord("childList", target, null, null, null, addedNodes, removedNodes, previousSibling, nextSibling);
-}
-/**
- * Queues an attribute mutation record for target.
- *
- * @param target - target node
- * @param name - name before mutation
- * @param namespace - namespace before mutation
- * @param oldValue - attribute value before mutation
- */
-function observer_queueAttributeMutationRecord(target, name, namespace, oldValue) {
- /**
- * To queue an attribute mutation record for target with name, namespace,
- * and oldValue, queue a mutation record of "attributes" for target with
- * name, namespace, oldValue, « », « », null, and null.
- */
- observer_queueMutationRecord("attributes", target, name, namespace, oldValue, [], [], null, null);
-}
-//# sourceMappingURL=MutationObserverAlgorithm.js.map
-
-/***/ }),
-
-/***/ 9733:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.namespace_validate = namespace_validate;
-exports.namespace_validateAndExtract = namespace_validateAndExtract;
-exports.namespace_extractQName = namespace_extractQName;
-const DOMException_1 = __nccwpck_require__(7175);
-const infra_1 = __nccwpck_require__(4737);
-const XMLAlgorithm_1 = __nccwpck_require__(6879);
-/**
- * Validates the given qualified name.
- *
- * @param qualifiedName - qualified name
- */
-function namespace_validate(qualifiedName) {
- /**
- * To validate a qualifiedName, throw an "InvalidCharacterError"
- * DOMException if qualifiedName does not match the Name or QName
- * production.
- */
- if (!(0, XMLAlgorithm_1.xml_isName)(qualifiedName))
- throw new DOMException_1.InvalidCharacterError(`Invalid XML name: ${qualifiedName}`);
- if (!(0, XMLAlgorithm_1.xml_isQName)(qualifiedName))
- throw new DOMException_1.InvalidCharacterError(`Invalid XML qualified name: ${qualifiedName}.`);
-}
-/**
- * Validates and extracts a namespace, prefix and localName from the
- * given namespace and qualified name.
- * See: https://dom.spec.whatwg.org/#validate-and-extract.
- *
- * @param namespace - namespace
- * @param qualifiedName - qualified name
- *
- * @returns a tuple with `namespace`, `prefix` and `localName`.
- */
-function namespace_validateAndExtract(namespace, qualifiedName) {
- /**
- * 1. If namespace is the empty string, set it to null.
- * 2. Validate qualifiedName.
- * 3. Let prefix be null.
- * 4. Let localName be qualifiedName.
- * 5. If qualifiedName contains a ":" (U+003E), then split the string on it
- * and set prefix to the part before and localName to the part after.
- * 6. If prefix is non-null and namespace is null, then throw a
- * "NamespaceError" DOMException.
- * 7. If prefix is "xml" and namespace is not the XML namespace, then throw
- * a "NamespaceError" DOMException.
- * 8. If either qualifiedName or prefix is "xmlns" and namespace is not the
- * XMLNS namespace, then throw a "NamespaceError" DOMException.
- * 9. If namespace is the XMLNS namespace and neither qualifiedName nor
- * prefix is "xmlns", then throw a "NamespaceError" DOMException.
- * 10. Return namespace, prefix, and localName.
- */
- if (!namespace)
- namespace = null;
- namespace_validate(qualifiedName);
- const parts = qualifiedName.split(':');
- const prefix = (parts.length === 2 ? parts[0] : null);
- const localName = (parts.length === 2 ? parts[1] : qualifiedName);
- if (prefix && namespace === null)
- throw new DOMException_1.NamespaceError("Qualified name includes a prefix but the namespace is null.");
- if (prefix === "xml" && namespace !== infra_1.namespace.XML)
- throw new DOMException_1.NamespaceError(`Qualified name includes the "xml" prefix but the namespace is not the XML namespace.`);
- if (namespace !== infra_1.namespace.XMLNS &&
- (prefix === "xmlns" || qualifiedName === "xmlns"))
- throw new DOMException_1.NamespaceError(`Qualified name includes the "xmlns" prefix but the namespace is not the XMLNS namespace.`);
- if (namespace === infra_1.namespace.XMLNS &&
- (prefix !== "xmlns" && qualifiedName !== "xmlns"))
- throw new DOMException_1.NamespaceError(`Qualified name does not include the "xmlns" prefix but the namespace is the XMLNS namespace.`);
- return [namespace, prefix, localName];
-}
-/**
- * Extracts a prefix and localName from the given qualified name.
- *
- * @param qualifiedName - qualified name
- *
- * @returns an tuple with `prefix` and `localName`.
- */
-function namespace_extractQName(qualifiedName) {
- namespace_validate(qualifiedName);
- const parts = qualifiedName.split(':');
- const prefix = (parts.length === 2 ? parts[0] : null);
- const localName = (parts.length === 2 ? parts[1] : qualifiedName);
- return [prefix, localName];
-}
-//# sourceMappingURL=NamespaceAlgorithm.js.map
-
-/***/ }),
-
-/***/ 1228:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.node_stringReplaceAll = node_stringReplaceAll;
-exports.node_clone = node_clone;
-exports.node_equals = node_equals;
-exports.node_listOfElementsWithQualifiedName = node_listOfElementsWithQualifiedName;
-exports.node_listOfElementsWithNamespace = node_listOfElementsWithNamespace;
-exports.node_listOfElementsWithClassNames = node_listOfElementsWithClassNames;
-exports.node_locateANamespacePrefix = node_locateANamespacePrefix;
-exports.node_locateANamespace = node_locateANamespace;
-const DOMImpl_1 = __nccwpck_require__(698);
-const util_1 = __nccwpck_require__(8247);
-const infra_1 = __nccwpck_require__(4737);
-const CreateAlgorithm_1 = __nccwpck_require__(8308);
-const OrderedSetAlgorithm_1 = __nccwpck_require__(8421);
-const DOMAlgorithm_1 = __nccwpck_require__(9484);
-const MutationAlgorithm_1 = __nccwpck_require__(45);
-const ElementAlgorithm_1 = __nccwpck_require__(2720);
-/**
- * Replaces the contents of the given node with a single text node.
- *
- * @param string - node contents
- * @param parent - a node
- */
-function node_stringReplaceAll(str, parent) {
- /**
- * 1. Let node be null.
- * 2. If string is not the empty string, then set node to a new Text node
- * whose data is string and node document is parent’s node document.
- * 3. Replace all with node within parent.
- */
- let node = null;
- if (str !== '') {
- node = (0, CreateAlgorithm_1.create_text)(parent._nodeDocument, str);
- }
- (0, MutationAlgorithm_1.mutation_replaceAll)(node, parent);
-}
-/**
- * Clones a node.
- *
- * @param node - a node to clone
- * @param document - the document to own the cloned node
- * @param cloneChildrenFlag - whether to clone node's children
- */
-function node_clone(node, document = null, cloneChildrenFlag = false) {
- /**
- * 1. If document is not given, let document be node’s node document.
- */
- if (document === null)
- document = node._nodeDocument;
- let copy;
- if (util_1.Guard.isElementNode(node)) {
- /**
- * 2. If node is an element, then:
- * 2.1. Let copy be the result of creating an element, given document,
- * node’s local name, node’s namespace, node’s namespace prefix,
- * and node’s is value, with the synchronous custom elements flag unset.
- * 2.2. For each attribute in node’s attribute list:
- * 2.2.1. Let copyAttribute be a clone of attribute.
- * 2.2.2. Append copyAttribute to copy.
- */
- copy = (0, ElementAlgorithm_1.element_createAnElement)(document, node._localName, node._namespace, node._namespacePrefix, node._is, false);
- for (const attribute of node._attributeList) {
- const copyAttribute = node_clone(attribute, document);
- (0, ElementAlgorithm_1.element_append)(copyAttribute, copy);
- }
- }
- else {
- /**
- * 3. Otherwise, let copy be a node that implements the same interfaces as
- * node, and fulfills these additional requirements, switching on node:
- * - Document
- * Set copy’s encoding, content type, URL, origin, type, and mode, to those
- * of node.
- * - DocumentType
- * Set copy’s name, public ID, and system ID, to those of node.
- * - Attr
- * Set copy’s namespace, namespace prefix, local name, and value, to
- * those of node.
- * - Text
- * - Comment
- * Set copy’s data, to that of node.
- * - ProcessingInstruction
- * Set copy’s target and data to those of node.
- * - Any other node
- */
- if (util_1.Guard.isDocumentNode(node)) {
- const doc = (0, CreateAlgorithm_1.create_document)();
- doc._encoding = node._encoding;
- doc._contentType = node._contentType;
- doc._URL = node._URL;
- doc._origin = node._origin;
- doc._type = node._type;
- doc._mode = node._mode;
- copy = doc;
- }
- else if (util_1.Guard.isDocumentTypeNode(node)) {
- const doctype = (0, CreateAlgorithm_1.create_documentType)(document, node._name, node._publicId, node._systemId);
- copy = doctype;
- }
- else if (util_1.Guard.isAttrNode(node)) {
- const attr = (0, CreateAlgorithm_1.create_attr)(document, node.localName);
- attr._namespace = node._namespace;
- attr._namespacePrefix = node._namespacePrefix;
- attr._value = node._value;
- copy = attr;
- }
- else if (util_1.Guard.isExclusiveTextNode(node)) {
- copy = (0, CreateAlgorithm_1.create_text)(document, node._data);
- }
- else if (util_1.Guard.isCDATASectionNode(node)) {
- copy = (0, CreateAlgorithm_1.create_cdataSection)(document, node._data);
- }
- else if (util_1.Guard.isCommentNode(node)) {
- copy = (0, CreateAlgorithm_1.create_comment)(document, node._data);
- }
- else if (util_1.Guard.isProcessingInstructionNode(node)) {
- copy = (0, CreateAlgorithm_1.create_processingInstruction)(document, node._target, node._data);
- }
- else if (util_1.Guard.isDocumentFragmentNode(node)) {
- copy = (0, CreateAlgorithm_1.create_documentFragment)(document);
- }
- else {
- copy = Object.create(node);
- }
- }
- /**
- * 4. Set copy’s node document and document to copy, if copy is a document,
- * and set copy’s node document to document otherwise.
- */
- if (util_1.Guard.isDocumentNode(copy)) {
- copy._nodeDocument = copy;
- document = copy;
- }
- else {
- copy._nodeDocument = document;
- }
- /**
- * 5. Run any cloning steps defined for node in other applicable
- * specifications and pass copy, node, document and the clone children flag
- * if set, as parameters.
- */
- if (DOMImpl_1.dom.features.steps) {
- (0, DOMAlgorithm_1.dom_runCloningSteps)(copy, node, document, cloneChildrenFlag);
- }
- /**
- * 6. If the clone children flag is set, clone all the children of node and
- * append them to copy, with document as specified and the clone children
- * flag being set.
- */
- if (cloneChildrenFlag) {
- for (const child of node._children) {
- const childCopy = node_clone(child, document, true);
- (0, MutationAlgorithm_1.mutation_append)(childCopy, copy);
- }
- }
- /**
- * 7. Return copy.
- */
- return copy;
-}
-/**
- * Determines if two nodes can be considered equal.
- *
- * @param a - node to compare
- * @param b - node to compare
- */
-function node_equals(a, b) {
- /**
- * 1. A and B’s nodeType attribute value is identical.
- */
- if (a._nodeType !== b._nodeType)
- return false;
- /**
- * 2. The following are also equal, depending on A:
- * - DocumentType
- * Its name, public ID, and system ID.
- * - Element
- * Its namespace, namespace prefix, local name, and its attribute list’s size.
- * - Attr
- * Its namespace, local name, and value.
- * - ProcessingInstruction
- * Its target and data.
- * - Text
- * - Comment
- * Its data.
- */
- if (util_1.Guard.isDocumentTypeNode(a) && util_1.Guard.isDocumentTypeNode(b)) {
- if (a._name !== b._name || a._publicId !== b._publicId ||
- a._systemId !== b._systemId)
- return false;
- }
- else if (util_1.Guard.isElementNode(a) && util_1.Guard.isElementNode(b)) {
- if (a._namespace !== b._namespace || a._namespacePrefix !== b._namespacePrefix ||
- a._localName !== b._localName ||
- a._attributeList.length !== b._attributeList.length)
- return false;
- }
- else if (util_1.Guard.isAttrNode(a) && util_1.Guard.isAttrNode(b)) {
- if (a._namespace !== b._namespace || a._localName !== b._localName ||
- a._value !== b._value)
- return false;
- }
- else if (util_1.Guard.isProcessingInstructionNode(a) && util_1.Guard.isProcessingInstructionNode(b)) {
- if (a._target !== b._target || a._data !== b._data)
- return false;
- }
- else if (util_1.Guard.isCharacterDataNode(a) && util_1.Guard.isCharacterDataNode(b)) {
- if (a._data !== b._data)
- return false;
- }
- /**
- * 3. If A is an element, each attribute in its attribute list has an attribute
- * that equals an attribute in B’s attribute list.
- */
- if (util_1.Guard.isElementNode(a) && util_1.Guard.isElementNode(b)) {
- const attrMap = {};
- for (const attrA of a._attributeList) {
- attrMap[attrA._localName] = attrA;
- }
- for (const attrB of b._attributeList) {
- const attrA = attrMap[attrB._localName];
- if (!attrA)
- return false;
- if (!node_equals(attrA, attrB))
- return false;
- }
- }
- /**
- * 4. A and B have the same number of children.
- * 5. Each child of A equals the child of B at the identical index.
- */
- if (a._children.size !== b._children.size)
- return false;
- const itA = a._children[Symbol.iterator]();
- const itB = b._children[Symbol.iterator]();
- let resultA = itA.next();
- let resultB = itB.next();
- while (!resultA.done && !resultB.done) {
- const child1 = resultA.value;
- const child2 = resultB.value;
- if (!node_equals(child1, child2))
- return false;
- resultA = itA.next();
- resultB = itB.next();
- }
- return true;
-}
-/**
- * Returns a collection of elements with the given qualified name which are
- * descendants of the given root node.
- * See: https://dom.spec.whatwg.org/#concept-getelementsbytagname
- *
- * @param qualifiedName - qualified name
- * @param root - root node
- */
-function node_listOfElementsWithQualifiedName(qualifiedName, root) {
- /**
- * 1. If qualifiedName is "*" (U+002A), return a HTMLCollection rooted at
- * root, whose filter matches only descendant elements.
- * 2. Otherwise, if root’s node document is an HTML document, return a
- * HTMLCollection rooted at root, whose filter matches the following
- * descendant elements:
- * 2.1. Whose namespace is the HTML namespace and whose qualified name is
- * qualifiedName, in ASCII lowercase.
- * 2.2. Whose namespace is not the HTML namespace and whose qualified name
- * is qualifiedName.
- * 3. Otherwise, return a HTMLCollection rooted at root, whose filter
- * matches descendant elements whose qualified name is qualifiedName.
- */
- if (qualifiedName === "*") {
- return (0, CreateAlgorithm_1.create_htmlCollection)(root);
- }
- else if (root._nodeDocument._type === "html") {
- return (0, CreateAlgorithm_1.create_htmlCollection)(root, function (ele) {
- if (ele._namespace === infra_1.namespace.HTML &&
- ele._qualifiedName === qualifiedName.toLowerCase()) {
- return true;
- }
- else if (ele._namespace !== infra_1.namespace.HTML &&
- ele._qualifiedName === qualifiedName) {
- return true;
- }
- else {
- return false;
- }
- });
- }
- else {
- return (0, CreateAlgorithm_1.create_htmlCollection)(root, function (ele) {
- return (ele._qualifiedName === qualifiedName);
- });
- }
-}
-/**
- * Returns a collection of elements with the given namespace which are
- * descendants of the given root node.
- * See: https://dom.spec.whatwg.org/#concept-getelementsbytagnamens
- *
- * @param namespace - element namespace
- * @param localName - local name
- * @param root - root node
- */
-function node_listOfElementsWithNamespace(namespace, localName, root) {
- /**
- * 1. If namespace is the empty string, set it to null.
- * 2. If both namespace and localName are "*" (U+002A), return a
- * HTMLCollection rooted at root, whose filter matches descendant elements.
- * 3. Otherwise, if namespace is "*" (U+002A), return a HTMLCollection
- * rooted at root, whose filter matches descendant elements whose local
- * name is localName.
- * 4. Otherwise, if localName is "*" (U+002A), return a HTMLCollection
- * rooted at root, whose filter matches descendant elements whose
- * namespace is namespace.
- * 5. Otherwise, return a HTMLCollection rooted at root, whose filter
- * matches descendant elements whose namespace is namespace and local
- * name is localName.
- */
- if (namespace === '')
- namespace = null;
- if (namespace === "*" && localName === "*") {
- return (0, CreateAlgorithm_1.create_htmlCollection)(root);
- }
- else if (namespace === "*") {
- return (0, CreateAlgorithm_1.create_htmlCollection)(root, function (ele) {
- return (ele._localName === localName);
- });
- }
- else if (localName === "*") {
- return (0, CreateAlgorithm_1.create_htmlCollection)(root, function (ele) {
- return (ele._namespace === namespace);
- });
- }
- else {
- return (0, CreateAlgorithm_1.create_htmlCollection)(root, function (ele) {
- return (ele._localName === localName && ele._namespace === namespace);
- });
- }
-}
-/**
- * Returns a collection of elements with the given class names which are
- * descendants of the given root node.
- * See: https://dom.spec.whatwg.org/#concept-getelementsbyclassname
- *
- * @param namespace - element namespace
- * @param localName - local name
- * @param root - root node
- */
-function node_listOfElementsWithClassNames(classNames, root) {
- /**
- * 1. Let classes be the result of running the ordered set parser
- * on classNames.
- * 2. If classes is the empty set, return an empty HTMLCollection.
- * 3. Return a HTMLCollection rooted at root, whose filter matches
- * descendant elements that have all their classes in classes.
- * The comparisons for the classes must be done in an ASCII case-insensitive
- * manner if root’s node document’s mode is "quirks", and in a
- * case-sensitive manner otherwise.
- */
- const classes = (0, OrderedSetAlgorithm_1.orderedSet_parse)(classNames);
- if (classes.size === 0) {
- return (0, CreateAlgorithm_1.create_htmlCollection)(root, () => false);
- }
- const caseSensitive = (root._nodeDocument._mode !== "quirks");
- return (0, CreateAlgorithm_1.create_htmlCollection)(root, function (ele) {
- const eleClasses = ele.classList;
- return (0, OrderedSetAlgorithm_1.orderedSet_contains)(eleClasses._tokenSet, classes, caseSensitive);
- });
-}
-/**
- * Searches for a namespace prefix associated with the given namespace
- * starting from the given element through its ancestors.
- *
- * @param element - an element node to start searching at
- * @param namespace - namespace to search for
- */
-function node_locateANamespacePrefix(element, namespace) {
- /**
- * 1. If element’s namespace is namespace and its namespace prefix is not
- * null, then return its namespace prefix.
- */
- if (element._namespace === namespace && element._namespacePrefix !== null) {
- return element._namespacePrefix;
- }
- /**
- * 2. If element has an attribute whose namespace prefix is "xmlns" and
- * value is namespace, then return element’s first such attribute’s
- * local name.
- */
- for (let i = 0; i < element._attributeList.length; i++) {
- const attr = element._attributeList[i];
- if (attr._namespacePrefix === "xmlns" && attr._value === namespace) {
- return attr._localName;
- }
- }
- /**
- * 3. If element’s parent element is not null, then return the result of
- * running locate a namespace prefix on that element using namespace.
- */
- if (element._parent && util_1.Guard.isElementNode(element._parent)) {
- return node_locateANamespacePrefix(element._parent, namespace);
- }
- /**
- * 4. Return null.
- */
- return null;
-}
-/**
- * Searches for a namespace associated with the given namespace prefix
- * starting from the given node through its ancestors.
- *
- * @param node - a node to start searching at
- * @param prefix - namespace prefix to search for
- */
-function node_locateANamespace(node, prefix) {
- if (util_1.Guard.isElementNode(node)) {
- /**
- * 1. If its namespace is not null and its namespace prefix is prefix,
- * then return namespace.
- */
- if (node._namespace !== null && node._namespacePrefix === prefix) {
- return node._namespace;
- }
- /**
- * 2. If it has an attribute whose namespace is the XMLNS namespace,
- * namespace prefix is "xmlns", and local name is prefix, or if prefix
- * is null and it has an attribute whose namespace is the XMLNS namespace,
- * namespace prefix is null, and local name is "xmlns", then return its
- * value if it is not the empty string, and null otherwise.
- */
- for (let i = 0; i < node._attributeList.length; i++) {
- const attr = node._attributeList[i];
- if (attr._namespace === infra_1.namespace.XMLNS &&
- attr._namespacePrefix === "xmlns" &&
- attr._localName === prefix) {
- return attr._value || null;
- }
- if (prefix === null && attr._namespace === infra_1.namespace.XMLNS &&
- attr._namespacePrefix === null && attr._localName === "xmlns") {
- return attr._value || null;
- }
- }
- /**
- * 3. If its parent element is null, then return null.
- */
- if (node.parentElement === null)
- return null;
- /**
- * 4. Return the result of running locate a namespace on its parent
- * element using prefix.
- */
- return node_locateANamespace(node.parentElement, prefix);
- }
- else if (util_1.Guard.isDocumentNode(node)) {
- /**
- * 1. If its document element is null, then return null.
- * 2. Return the result of running locate a namespace on its document
- * element using prefix.
- */
- if (node.documentElement === null)
- return null;
- return node_locateANamespace(node.documentElement, prefix);
- }
- else if (util_1.Guard.isDocumentTypeNode(node) || util_1.Guard.isDocumentFragmentNode(node)) {
- return null;
- }
- else if (util_1.Guard.isAttrNode(node)) {
- /**
- * 1. If its element is null, then return null.
- * 2. Return the result of running locate a namespace on its element
- * using prefix.
- */
- if (node._element === null)
- return null;
- return node_locateANamespace(node._element, prefix);
- }
- else {
- /**
- * 1. If its parent element is null, then return null.
- * 2. Return the result of running locate a namespace on its parent
- * element using prefix.
- */
- if (!node._parent || !util_1.Guard.isElementNode(node._parent))
- return null;
- return node_locateANamespace(node._parent, prefix);
- }
-}
-//# sourceMappingURL=NodeAlgorithm.js.map
-
-/***/ }),
-
-/***/ 9670:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.nodeIterator_traverse = nodeIterator_traverse;
-exports.nodeIterator_iteratorList = nodeIterator_iteratorList;
-const DOMImpl_1 = __nccwpck_require__(698);
-const interfaces_1 = __nccwpck_require__(9454);
-const TraversalAlgorithm_1 = __nccwpck_require__(6746);
-const TreeAlgorithm_1 = __nccwpck_require__(3532);
-/**
- * Returns the next or previous node in the subtree, or `null` if
- * there are none.
- *
- * @param iterator - the `NodeIterator` instance
- * @param forward- `true` to return the next node, or `false` to
- * return the previous node.
- */
-function nodeIterator_traverse(iterator, forward) {
- /**
- * 1. Let node be iterator’s reference.
- * 2. Let beforeNode be iterator’s pointer before reference.
- */
- let node = iterator._reference;
- let beforeNode = iterator._pointerBeforeReference;
- /**
- * 3. While true:
- */
- while (true) {
- /**
- * 3.1. Branch on direction:
- */
- if (forward) {
- /**
- * - next
- */
- if (!beforeNode) {
- /**
- * If beforeNode is false, then set node to the first node following
- * node in iterator’s iterator collection. If there is no such node,
- * then return null.
- */
- const nextNode = (0, TreeAlgorithm_1.tree_getFollowingNode)(iterator._root, node);
- if (nextNode) {
- node = nextNode;
- }
- else {
- return null;
- }
- }
- else {
- /**
- * If beforeNode is true, then set it to false.
- */
- beforeNode = false;
- }
- }
- else {
- /**
- * - previous
- */
- if (beforeNode) {
- /**
- * If beforeNode is true, then set node to the first node preceding
- * node in iterator’s iterator collection. If there is no such node,
- * then return null.
- */
- const prevNode = (0, TreeAlgorithm_1.tree_getPrecedingNode)(iterator.root, node);
- if (prevNode) {
- node = prevNode;
- }
- else {
- return null;
- }
- }
- else {
- /**
- * If beforeNode is false, then set it to true.
- */
- beforeNode = true;
- }
- }
- /**
- * 3.2. Let result be the result of filtering node within iterator.
- * 3.3. If result is FILTER_ACCEPT, then break.
- */
- const result = (0, TraversalAlgorithm_1.traversal_filter)(iterator, node);
- if (result === interfaces_1.FilterResult.Accept) {
- break;
- }
- }
- /**
- * 4. Set iterator’s reference to node.
- * 5. Set iterator’s pointer before reference to beforeNode.
- * 6. Return node.
- */
- iterator._reference = node;
- iterator._pointerBeforeReference = beforeNode;
- return node;
-}
-/**
- * Gets the global iterator list.
- */
-function nodeIterator_iteratorList() {
- return DOMImpl_1.dom.window._iteratorList;
-}
-//# sourceMappingURL=NodeIteratorAlgorithm.js.map
-
-/***/ }),
-
-/***/ 8421:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.orderedSet_parse = orderedSet_parse;
-exports.orderedSet_serialize = orderedSet_serialize;
-exports.orderedSet_sanitize = orderedSet_sanitize;
-exports.orderedSet_contains = orderedSet_contains;
-const infra_1 = __nccwpck_require__(4737);
-/**
- * Converts a whitespace separated string into an array of tokens.
- *
- * @param value - a string of whitespace separated tokens
- */
-function orderedSet_parse(value) {
- /**
- * 1. Let inputTokens be the result of splitting input on ASCII whitespace.
- * 2. Let tokens be a new ordered set.
- * 3. For each token in inputTokens, append token to tokens.
- * 4. Return tokens.
- */
- const inputTokens = infra_1.string.splitAStringOnASCIIWhitespace(value);
- return new Set(inputTokens);
-}
-/**
- * Converts an array of tokens into a space separated string.
- *
- * @param tokens - an array of token strings
- */
-function orderedSet_serialize(tokens) {
- /**
- * The ordered set serializer takes a set and returns the concatenation of
- * set using U+0020 SPACE.
- */
- return [...tokens].join(' ');
-}
-/**
- * Removes duplicate tokens and convert all whitespace characters
- * to space.
- *
- * @param value - a string of whitespace separated tokens
- */
-function orderedSet_sanitize(value) {
- return orderedSet_serialize(orderedSet_parse(value));
-}
-/**
- * Determines whether a set contains the other.
- *
- * @param set1 - a set
- * @param set1 - a set that is contained in set1
- * @param caseSensitive - whether matches are case-sensitive
- */
-function orderedSet_contains(set1, set2, caseSensitive) {
- for (const val2 of set2) {
- let found = false;
- for (const val1 of set1) {
- if (caseSensitive) {
- if (val1 === val2) {
- found = true;
- break;
- }
- }
- else {
- if (val1.toUpperCase() === val2.toUpperCase()) {
- found = true;
- break;
- }
- }
- }
- if (!found)
- return false;
- }
- return true;
-}
-//# sourceMappingURL=OrderedSetAlgorithm.js.map
-
-/***/ }),
-
-/***/ 9892:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.parentNode_convertNodesIntoANode = parentNode_convertNodesIntoANode;
-const util_1 = __nccwpck_require__(7061);
-const CreateAlgorithm_1 = __nccwpck_require__(8308);
-/**
- * Converts the given nodes or strings into a node (if `nodes` has
- * only one element) or a document fragment.
- *
- * @param nodes - the array of nodes or strings,
- * @param document - owner document
- */
-function parentNode_convertNodesIntoANode(nodes, document) {
- /**
- * 1. Let node be null.
- * 2. Replace each string in nodes with a new Text node whose data is the
- * string and node document is document.
- */
- let node = null;
- for (let i = 0; i < nodes.length; i++) {
- const item = nodes[i];
- if ((0, util_1.isString)(item)) {
- const text = (0, CreateAlgorithm_1.create_text)(document, item);
- nodes[i] = text;
- }
- }
- /**
- * 3. If nodes contains one node, set node to that node.
- * 4. Otherwise, set node to a new DocumentFragment whose node document is
- * document, and then append each node in nodes, if any, to it.
- */
- if (nodes.length === 1) {
- node = nodes[0];
- }
- else {
- node = (0, CreateAlgorithm_1.create_documentFragment)(document);
- const ns = node;
- for (const item of nodes) {
- ns.appendChild(item);
- }
- }
- /**
- * 5. Return node.
- */
- return node;
-}
-//# sourceMappingURL=ParentNodeAlgorithm.js.map
-
-/***/ }),
-
-/***/ 6687:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.range_collapsed = range_collapsed;
-exports.range_root = range_root;
-exports.range_isContained = range_isContained;
-exports.range_isPartiallyContained = range_isPartiallyContained;
-exports.range_setTheStart = range_setTheStart;
-exports.range_setTheEnd = range_setTheEnd;
-exports.range_select = range_select;
-exports.range_extract = range_extract;
-exports.range_cloneTheContents = range_cloneTheContents;
-exports.range_insert = range_insert;
-exports.range_getContainedNodes = range_getContainedNodes;
-exports.range_getPartiallyContainedNodes = range_getPartiallyContainedNodes;
-const interfaces_1 = __nccwpck_require__(9454);
-const DOMException_1 = __nccwpck_require__(7175);
-const util_1 = __nccwpck_require__(8247);
-const CreateAlgorithm_1 = __nccwpck_require__(8308);
-const TreeAlgorithm_1 = __nccwpck_require__(3532);
-const BoundaryPointAlgorithm_1 = __nccwpck_require__(8652);
-const CharacterDataAlgorithm_1 = __nccwpck_require__(7785);
-const NodeAlgorithm_1 = __nccwpck_require__(1228);
-const MutationAlgorithm_1 = __nccwpck_require__(45);
-const TextAlgorithm_1 = __nccwpck_require__(3813);
-/**
- * Determines if the node's start boundary point is at its end boundary
- * point.
- *
- * @param range - a range
- */
-function range_collapsed(range) {
- /**
- * A range is collapsed if its start node is its end node and its start offset is its end offset.
- */
- return (range._startNode === range._endNode && range._startOffset === range._endOffset);
-}
-/**
- * Gets the root node of a range.
- *
- * @param range - a range
- */
-function range_root(range) {
- /**
- * The root of a live range is the root of its start node.
- */
- return (0, TreeAlgorithm_1.tree_rootNode)(range._startNode);
-}
-/**
- * Determines if a node is fully contained in a range.
- *
- * @param node - a node
- * @param range - a range
- */
-function range_isContained(node, range) {
- /**
- * A node node is contained in a live range range if node’s root is range’s
- * root, and (node, 0) is after range’s start, and (node, node’s length) is
- * before range’s end.
- */
- return ((0, TreeAlgorithm_1.tree_rootNode)(node) === range_root(range) &&
- (0, BoundaryPointAlgorithm_1.boundaryPoint_position)([node, 0], range._start) === interfaces_1.BoundaryPosition.After &&
- (0, BoundaryPointAlgorithm_1.boundaryPoint_position)([node, (0, TreeAlgorithm_1.tree_nodeLength)(node)], range._end) === interfaces_1.BoundaryPosition.Before);
-}
-/**
- * Determines if a node is partially contained in a range.
- *
- * @param node - a node
- * @param range - a range
- */
-function range_isPartiallyContained(node, range) {
- /**
- * A node is partially contained in a live range if it’s an inclusive
- * ancestor of the live range’s start node but not its end node,
- * or vice versa.
- */
- const startCheck = (0, TreeAlgorithm_1.tree_isAncestorOf)(range._startNode, node, true);
- const endCheck = (0, TreeAlgorithm_1.tree_isAncestorOf)(range._endNode, node, true);
- return (startCheck && !endCheck) || (!startCheck && endCheck);
-}
-/**
- * Sets the start boundary point of a range.
- *
- * @param range - a range
- * @param node - a node
- * @param offset - an offset into node
- */
-function range_setTheStart(range, node, offset) {
- /**
- * 1. If node is a doctype, then throw an "InvalidNodeTypeError" DOMException.
- * 2. If offset is greater than node’s length, then throw an "IndexSizeError"
- * DOMException.
- * 3. Let bp be the boundary point (node, offset).
- * 4. If these steps were invoked as "set the start"
- * 4.1. If bp is after the range’s end, or if range’s root is not equal to
- * node’s root, set range’s end to bp.
- * 4.2. Set range’s start to bp.
- */
- if (util_1.Guard.isDocumentTypeNode(node)) {
- throw new DOMException_1.InvalidNodeTypeError();
- }
- if (offset > (0, TreeAlgorithm_1.tree_nodeLength)(node)) {
- throw new DOMException_1.IndexSizeError();
- }
- const bp = [node, offset];
- if (range_root(range) !== (0, TreeAlgorithm_1.tree_rootNode)(node) ||
- (0, BoundaryPointAlgorithm_1.boundaryPoint_position)(bp, range._end) === interfaces_1.BoundaryPosition.After) {
- range._end = bp;
- }
- range._start = bp;
-}
-/**
- * Sets the end boundary point of a range.
- *
- * @param range - a range
- * @param node - a node
- * @param offset - an offset into node
- */
-function range_setTheEnd(range, node, offset) {
- /**
- * 1. If node is a doctype, then throw an "InvalidNodeTypeError" DOMException.
- * 2. If offset is greater than node’s length, then throw an "IndexSizeError"
- * DOMException.
- * 3. Let bp be the boundary point (node, offset).
- * 4. If these steps were invoked as "set the end"
- * 4.1. If bp is before the range’s start, or if range’s root is not equal
- * to node’s root, set range’s start to bp.
- * 4.2. Set range’s end to bp.
- */
- if (util_1.Guard.isDocumentTypeNode(node)) {
- throw new DOMException_1.InvalidNodeTypeError();
- }
- if (offset > (0, TreeAlgorithm_1.tree_nodeLength)(node)) {
- throw new DOMException_1.IndexSizeError();
- }
- const bp = [node, offset];
- if (range_root(range) !== (0, TreeAlgorithm_1.tree_rootNode)(node) ||
- (0, BoundaryPointAlgorithm_1.boundaryPoint_position)(bp, range._start) === interfaces_1.BoundaryPosition.Before) {
- range._start = bp;
- }
- range._end = bp;
-}
-/**
- * Selects a node.
- *
- * @param range - a range
- * @param node - a node
- */
-function range_select(node, range) {
- /**
- * 1. Let parent be node’s parent.
- * 2. If parent is null, then throw an "InvalidNodeTypeError" DOMException.
- */
- const parent = node._parent;
- if (parent === null)
- throw new DOMException_1.InvalidNodeTypeError();
- /**
- * 3. Let index be node’s index.
- * 4. Set range’s start to boundary point (parent, index).
- * 5. Set range’s end to boundary point (parent, index plus 1).
- */
- const index = (0, TreeAlgorithm_1.tree_index)(node);
- range._start = [parent, index];
- range._end = [parent, index + 1];
-}
-/**
- * EXtracts the contents of range as a document fragment.
- *
- * @param range - a range
- */
-function range_extract(range) {
- /**
- * 1. Let fragment be a new DocumentFragment node whose node document is
- * range’s start node’s node document.
- * 2. If range is collapsed, then return fragment.
- */
- const fragment = (0, CreateAlgorithm_1.create_documentFragment)(range._startNode._nodeDocument);
- if (range_collapsed(range))
- return fragment;
- /**
- * 3. Let original start node, original start offset, original end node,
- * and original end offset be range’s start node, start offset, end node,
- * and end offset, respectively.
- */
- const originalStartNode = range._startNode;
- const originalStartOffset = range._startOffset;
- const originalEndNode = range._endNode;
- const originalEndOffset = range._endOffset;
- /**
- * 4. If original start node is original end node, and they are a Text,
- * ProcessingInstruction, or Comment node:
- * 4.1. Let clone be a clone of original start node.
- * 4.2. Set the data of clone to the result of substringing data with node
- * original start node, offset original start offset, and count original end
- * offset minus original start offset.
- * 4.3. Append clone to fragment.
- * 4.4. Replace data with node original start node, offset original start
- * offset, count original end offset minus original start offset, and data
- * the empty string.
- * 4.5. Return fragment.
- */
- if (originalStartNode === originalEndNode &&
- util_1.Guard.isCharacterDataNode(originalStartNode)) {
- const clone = (0, NodeAlgorithm_1.node_clone)(originalStartNode);
- clone._data = (0, CharacterDataAlgorithm_1.characterData_substringData)(originalStartNode, originalStartOffset, originalEndOffset - originalStartOffset);
- (0, MutationAlgorithm_1.mutation_append)(clone, fragment);
- (0, CharacterDataAlgorithm_1.characterData_replaceData)(originalStartNode, originalStartOffset, originalEndOffset - originalStartOffset, '');
- return fragment;
- }
- /**
- * 5. Let common ancestor be original start node.
- * 6. While common ancestor is not an inclusive ancestor of original end
- * node, set common ancestor to its own parent.
- */
- let commonAncestor = originalStartNode;
- while (!(0, TreeAlgorithm_1.tree_isAncestorOf)(originalEndNode, commonAncestor, true)) {
- if (commonAncestor._parent === null) {
- throw new Error("Parent node is null.");
- }
- commonAncestor = commonAncestor._parent;
- }
- /**
- * 7. Let first partially contained child be null.
- * 8. If original start node is not an inclusive ancestor of original end
- * node, set first partially contained child to the first child of common
- * ancestor that is partially contained in range.
- */
- let firstPartiallyContainedChild = null;
- if (!(0, TreeAlgorithm_1.tree_isAncestorOf)(originalEndNode, originalStartNode, true)) {
- for (const node of commonAncestor._children) {
- if (range_isPartiallyContained(node, range)) {
- firstPartiallyContainedChild = node;
- break;
- }
- }
- }
- /**
- * 9. Let last partially contained child be null.
- * 10. If original end node is not an inclusive ancestor of original start
- * node, set last partially contained child to the last child of common
- * ancestor that is partially contained in range.
- */
- let lastPartiallyContainedChild = null;
- if (!(0, TreeAlgorithm_1.tree_isAncestorOf)(originalStartNode, originalEndNode, true)) {
- const children = [...commonAncestor._children];
- for (let i = children.length - 1; i > 0; i--) {
- const node = children[i];
- if (range_isPartiallyContained(node, range)) {
- lastPartiallyContainedChild = node;
- break;
- }
- }
- }
- /**
- * 11. Let contained children be a list of all children of common ancestor
- * that are contained in range, in tree order.
- * 12. If any member of contained children is a doctype, then throw a
- * "HierarchyRequestError" DOMException.
- */
- const containedChildren = [];
- for (const child of commonAncestor._children) {
- if (range_isContained(child, range)) {
- if (util_1.Guard.isDocumentTypeNode(child)) {
- throw new DOMException_1.HierarchyRequestError();
- }
- containedChildren.push(child);
- }
- }
- let newNode;
- let newOffset;
- if ((0, TreeAlgorithm_1.tree_isAncestorOf)(originalEndNode, originalStartNode, true)) {
- /**
- * 13. If original start node is an inclusive ancestor of original end node,
- * set new node to original start node and new offset to original start
- * offset.
- */
- newNode = originalStartNode;
- newOffset = originalStartOffset;
- }
- else {
- /**
- * 14. Otherwise:
- * 14.1. Let reference node equal original start node.
- * 14.2. While reference node’s parent is not null and is not an inclusive
- * ancestor of original end node, set reference node to its parent.
- * 14.3. Set new node to the parent of reference node, and new offset to
- * one plus reference node’s index.
- */
- let referenceNode = originalStartNode;
- while (referenceNode._parent !== null &&
- !(0, TreeAlgorithm_1.tree_isAncestorOf)(originalEndNode, referenceNode._parent)) {
- referenceNode = referenceNode._parent;
- }
- /* istanbul ignore next */
- if (referenceNode._parent === null) {
- /**
- * If reference node’s parent is null, it would be the root of range,
- * so would be an inclusive ancestor of original end node, and we could
- * not reach this point.
- */
- throw new Error("Parent node is null.");
- }
- newNode = referenceNode._parent;
- newOffset = 1 + (0, TreeAlgorithm_1.tree_index)(referenceNode);
- }
- if (util_1.Guard.isCharacterDataNode(firstPartiallyContainedChild)) {
- /**
- * 15. If first partially contained child is a Text, ProcessingInstruction,
- * or Comment node:
- * 15.1. Let clone be a clone of original start node.
- * 15.2. Set the data of clone to the result of substringing data with
- * node original start node, offset original start offset, and count
- * original start node’s length minus original start offset.
- * 15.3. Append clone to fragment.
- * 15.4. Replace data with node original start node, offset original
- * start offset, count original start node’s length minus original start
- * offset, and data the empty string.
- */
- const clone = (0, NodeAlgorithm_1.node_clone)(originalStartNode);
- clone._data = (0, CharacterDataAlgorithm_1.characterData_substringData)(originalStartNode, originalStartOffset, (0, TreeAlgorithm_1.tree_nodeLength)(originalStartNode) - originalStartOffset);
- (0, MutationAlgorithm_1.mutation_append)(clone, fragment);
- (0, CharacterDataAlgorithm_1.characterData_replaceData)(originalStartNode, originalStartOffset, (0, TreeAlgorithm_1.tree_nodeLength)(originalStartNode) - originalStartOffset, '');
- }
- else if (firstPartiallyContainedChild !== null) {
- /**
- * 16. Otherwise, if first partially contained child is not null:
- * 16.1. Let clone be a clone of first partially contained child.
- * 16.2. Append clone to fragment.
- * 16.3. Let subrange be a new live range whose start is (original start
- * node, original start offset) and whose end is (first partially
- * contained child, first partially contained child’s length).
- * 16.4. Let subfragment be the result of extracting subrange.
- * 16.5. Append subfragment to clone.
- */
- const clone = (0, NodeAlgorithm_1.node_clone)(firstPartiallyContainedChild);
- (0, MutationAlgorithm_1.mutation_append)(clone, fragment);
- const subrange = (0, CreateAlgorithm_1.create_range)([originalStartNode, originalStartOffset], [firstPartiallyContainedChild, (0, TreeAlgorithm_1.tree_nodeLength)(firstPartiallyContainedChild)]);
- const subfragment = range_extract(subrange);
- (0, MutationAlgorithm_1.mutation_append)(subfragment, clone);
- }
- /**
- * 17. For each contained child in contained children, append contained
- * child to fragment.
- */
- for (const child of containedChildren) {
- (0, MutationAlgorithm_1.mutation_append)(child, fragment);
- }
- if (util_1.Guard.isCharacterDataNode(lastPartiallyContainedChild)) {
- /**
- * 18. If last partially contained child is a Text, ProcessingInstruction,
- * or Comment node:
- * 18.1. Let clone be a clone of original end node.
- * 18.2. Set the data of clone to the result of substringing data with
- * node original end node, offset 0, and count original end offset.
- * 18.3. Append clone to fragment.
- * 18.4. Replace data with node original end node, offset 0, count
- * original end offset, and data the empty string.
- */
- const clone = (0, NodeAlgorithm_1.node_clone)(originalEndNode);
- clone._data = (0, CharacterDataAlgorithm_1.characterData_substringData)(originalEndNode, 0, originalEndOffset);
- (0, MutationAlgorithm_1.mutation_append)(clone, fragment);
- (0, CharacterDataAlgorithm_1.characterData_replaceData)(originalEndNode, 0, originalEndOffset, '');
- }
- else if (lastPartiallyContainedChild !== null) {
- /**
- * 19. Otherwise, if last partially contained child is not null:
- * 19.1. Let clone be a clone of last partially contained child.
- * 19.2. Append clone to fragment.
- * 19.3. Let subrange be a new live range whose start is (last partially
- * contained child, 0) and whose end is (original end node, original
- * end offset).
- * 19.4. Let subfragment be the result of extracting subrange.
- * 19.5. Append subfragment to clone.
- */
- const clone = (0, NodeAlgorithm_1.node_clone)(lastPartiallyContainedChild);
- (0, MutationAlgorithm_1.mutation_append)(clone, fragment);
- const subrange = (0, CreateAlgorithm_1.create_range)([lastPartiallyContainedChild, 0], [originalEndNode, originalEndOffset]);
- const subfragment = range_extract(subrange);
- (0, MutationAlgorithm_1.mutation_append)(subfragment, clone);
- }
- /**
- * 20. Set range’s start and end to (new node, new offset).
- */
- range._start = [newNode, newOffset];
- range._end = [newNode, newOffset];
- /**
- * 21. Return fragment.
- */
- return fragment;
-}
-/**
- * Clones the contents of range as a document fragment.
- *
- * @param range - a range
- */
-function range_cloneTheContents(range) {
- /**
- * 1. Let fragment be a new DocumentFragment node whose node document
- * is range’s start node’s node document.
- * 2. If range is collapsed, then return fragment.
- */
- const fragment = (0, CreateAlgorithm_1.create_documentFragment)(range._startNode._nodeDocument);
- if (range_collapsed(range))
- return fragment;
- /**
- * 3. Let original start node, original start offset, original end node,
- * and original end offset be range’s start node, start offset, end node,
- * and end offset, respectively.
- * 4. If original start node is original end node, and they are a Text,
- * ProcessingInstruction, or Comment node:
- * 4.1. Let clone be a clone of original start node.
- * 4.2. Set the data of clone to the result of substringing data with node
- * original start node, offset original start offset, and count original end
- * offset minus original start offset.
- * 4.3. Append clone to fragment.
- * 4.5. Return fragment.
- */
- const originalStartNode = range._startNode;
- const originalStartOffset = range._startOffset;
- const originalEndNode = range._endNode;
- const originalEndOffset = range._endOffset;
- if (originalStartNode === originalEndNode &&
- util_1.Guard.isCharacterDataNode(originalStartNode)) {
- const clone = (0, NodeAlgorithm_1.node_clone)(originalStartNode);
- clone._data = (0, CharacterDataAlgorithm_1.characterData_substringData)(originalStartNode, originalStartOffset, originalEndOffset - originalStartOffset);
- (0, MutationAlgorithm_1.mutation_append)(clone, fragment);
- }
- /**
- * 5. Let common ancestor be original start node.
- * 6. While common ancestor is not an inclusive ancestor of original end
- * node, set common ancestor to its own parent.
- */
- let commonAncestor = originalStartNode;
- while (!(0, TreeAlgorithm_1.tree_isAncestorOf)(originalEndNode, commonAncestor, true)) {
- if (commonAncestor._parent === null) {
- throw new Error("Parent node is null.");
- }
- commonAncestor = commonAncestor._parent;
- }
- /**
- * 7. Let first partially contained child be null.
- * 8. If original start node is not an inclusive ancestor of original end
- * node, set first partially contained child to the first child of common
- * ancestor that is partially contained in range.
- */
- let firstPartiallyContainedChild = null;
- if (!(0, TreeAlgorithm_1.tree_isAncestorOf)(originalEndNode, originalStartNode, true)) {
- for (const node of commonAncestor._children) {
- if (range_isPartiallyContained(node, range)) {
- firstPartiallyContainedChild = node;
- break;
- }
- }
- }
- /**
- * 9. Let last partially contained child be null.
- * 10. If original end node is not an inclusive ancestor of original start
- * node, set last partially contained child to the last child of common
- * ancestor that is partially contained in range.
- */
- let lastPartiallyContainedChild = null;
- if (!(0, TreeAlgorithm_1.tree_isAncestorOf)(originalStartNode, originalEndNode, true)) {
- const children = [...commonAncestor._children];
- for (let i = children.length - 1; i > 0; i--) {
- const node = children[i];
- if (range_isPartiallyContained(node, range)) {
- lastPartiallyContainedChild = node;
- break;
- }
- }
- }
- /**
- * 11. Let contained children be a list of all children of common ancestor
- * that are contained in range, in tree order.
- * 12. If any member of contained children is a doctype, then throw a
- * "HierarchyRequestError" DOMException.
- */
- const containedChildren = [];
- for (const child of commonAncestor._children) {
- if (range_isContained(child, range)) {
- if (util_1.Guard.isDocumentTypeNode(child)) {
- throw new DOMException_1.HierarchyRequestError();
- }
- containedChildren.push(child);
- }
- }
- if (util_1.Guard.isCharacterDataNode(firstPartiallyContainedChild)) {
- /**
- * 13. If first partially contained child is a Text, ProcessingInstruction,
- * or Comment node:
- * 13.1. Let clone be a clone of original start node.
- * 13.2. Set the data of clone to the result of substringing data with
- * node original start node, offset original start offset, and count
- * original start node’s length minus original start offset.
- * 13.3. Append clone to fragment.
- */
- const clone = (0, NodeAlgorithm_1.node_clone)(originalStartNode);
- clone._data = (0, CharacterDataAlgorithm_1.characterData_substringData)(originalStartNode, originalStartOffset, (0, TreeAlgorithm_1.tree_nodeLength)(originalStartNode) - originalStartOffset);
- (0, MutationAlgorithm_1.mutation_append)(clone, fragment);
- }
- else if (firstPartiallyContainedChild !== null) {
- /**
- * 14. Otherwise, if first partially contained child is not null:
- * 14.1. Let clone be a clone of first partially contained child.
- * 14.2. Append clone to fragment.
- * 14.3. Let subrange be a new live range whose start is (original start
- * node, original start offset) and whose end is (first partially
- * contained child, first partially contained child’s length).
- * 14.4. Let subfragment be the result of cloning the contents of
- * subrange.
- * 14.5. Append subfragment to clone.
- */
- const clone = (0, NodeAlgorithm_1.node_clone)(firstPartiallyContainedChild);
- (0, MutationAlgorithm_1.mutation_append)(clone, fragment);
- const subrange = (0, CreateAlgorithm_1.create_range)([originalStartNode, originalStartOffset], [firstPartiallyContainedChild, (0, TreeAlgorithm_1.tree_nodeLength)(firstPartiallyContainedChild)]);
- const subfragment = range_cloneTheContents(subrange);
- (0, MutationAlgorithm_1.mutation_append)(subfragment, clone);
- }
- /**
- * 15. For each contained child in contained children, append contained
- * child to fragment.
- * 15.1. Let clone be a clone of contained child with the clone children
- * flag set.
- * 15.2. Append clone to fragment.
- */
- for (const child of containedChildren) {
- const clone = (0, NodeAlgorithm_1.node_clone)(child);
- (0, MutationAlgorithm_1.mutation_append)(clone, fragment);
- }
- if (util_1.Guard.isCharacterDataNode(lastPartiallyContainedChild)) {
- /**
- * 16. If last partially contained child is a Text, ProcessingInstruction,
- * or Comment node:
- * 16.1. Let clone be a clone of original end node.
- * 16.2. Set the data of clone to the result of substringing data with
- * node original end node, offset 0, and count original end offset.
- * 16.3. Append clone to fragment.
- */
- const clone = (0, NodeAlgorithm_1.node_clone)(originalEndNode);
- clone._data = (0, CharacterDataAlgorithm_1.characterData_substringData)(originalEndNode, 0, originalEndOffset);
- (0, MutationAlgorithm_1.mutation_append)(clone, fragment);
- }
- else if (lastPartiallyContainedChild !== null) {
- /**
- * 17. Otherwise, if last partially contained child is not null:
- * 17.1. Let clone be a clone of last partially contained child.
- * 17.2. Append clone to fragment.
- * 17.3. Let subrange be a new live range whose start is (last partially
- * contained child, 0) and whose end is (original end node, original
- * end offset).
- * 17.4. Let subfragment be the result of cloning the contents of subrange.
- * 17.5. Append subfragment to clone.
- */
- const clone = (0, NodeAlgorithm_1.node_clone)(lastPartiallyContainedChild);
- fragment.append(clone);
- const subrange = (0, CreateAlgorithm_1.create_range)([lastPartiallyContainedChild, 0], [originalEndNode, originalEndOffset]);
- const subfragment = range_extract(subrange);
- (0, MutationAlgorithm_1.mutation_append)(subfragment, clone);
- }
- /**
- * 18. Return fragment.
- */
- return fragment;
-}
-/**
- * Inserts a node into a range at the start boundary point.
- *
- * @param node - node to insert
- * @param range - a range
- */
-function range_insert(node, range) {
- /**
- * 1. If range’s start node is a ProcessingInstruction or Comment node, is a
- * Text node whose parent is null, or is node, then throw a
- * "HierarchyRequestError" DOMException.
- */
- if (util_1.Guard.isProcessingInstructionNode(range._startNode) ||
- util_1.Guard.isCommentNode(range._startNode) ||
- (util_1.Guard.isTextNode(range._startNode) && range._startNode._parent === null) ||
- range._startNode === node) {
- throw new DOMException_1.HierarchyRequestError();
- }
- /**
- * 2. Let referenceNode be null.
- * 3. If range’s start node is a Text node, set referenceNode to that Text
- * node.
- * 4. Otherwise, set referenceNode to the child of start node whose index is
- * start offset, and null if there is no such child.
- */
- let referenceNode = null;
- if (util_1.Guard.isTextNode(range._startNode)) {
- referenceNode = range._startNode;
- }
- else {
- let index = 0;
- for (const child of range._startNode._children) {
- if (index === range._startOffset) {
- referenceNode = child;
- break;
- }
- index++;
- }
- }
- /**
- * 5. Let parent be range’s start node if referenceNode is null, and
- * referenceNode’s parent otherwise.
- */
- let parent;
- if (referenceNode === null) {
- parent = range._startNode;
- }
- else {
- if (referenceNode._parent === null) {
- throw new Error("Parent node is null.");
- }
- parent = referenceNode._parent;
- }
- /**
- * 6. Ensure pre-insertion validity of node into parent before referenceNode.
- */
- (0, MutationAlgorithm_1.mutation_ensurePreInsertionValidity)(node, parent, referenceNode);
- /**
- * 7. If range’s start node is a Text node, set referenceNode to the result
- * of splitting it with offset range’s start offset.
- */
- if (util_1.Guard.isTextNode(range._startNode)) {
- referenceNode = (0, TextAlgorithm_1.text_split)(range._startNode, range._startOffset);
- }
- /**
- * 8. If node is referenceNode, set referenceNode to its next sibling.
- */
- if (node === referenceNode) {
- referenceNode = node._nextSibling;
- }
- /**
- * 9. If node’s parent is not null, remove node from its parent.
- */
- if (node._parent !== null) {
- (0, MutationAlgorithm_1.mutation_remove)(node, node._parent);
- }
- /**
- * 10. Let newOffset be parent’s length if referenceNode is null, and
- * referenceNode’s index otherwise.
- */
- let newOffset = (referenceNode === null ?
- (0, TreeAlgorithm_1.tree_nodeLength)(parent) : (0, TreeAlgorithm_1.tree_index)(referenceNode));
- /**
- * 11. Increase newOffset by node’s length if node is a DocumentFragment
- * node, and one otherwise.
- */
- if (util_1.Guard.isDocumentFragmentNode(node)) {
- newOffset += (0, TreeAlgorithm_1.tree_nodeLength)(node);
- }
- else {
- newOffset++;
- }
- /**
- * 12. Pre-insert node into parent before referenceNode.
- */
- (0, MutationAlgorithm_1.mutation_preInsert)(node, parent, referenceNode);
- /**
- * 13. If range is collapsed, then set range’s end to (parent, newOffset).
- */
- if (range_collapsed(range)) {
- range._end = [parent, newOffset];
- }
-}
-/**
- * Traverses through all contained nodes of a range.
- *
- * @param range - a range
- */
-function range_getContainedNodes(range) {
- return {
- [Symbol.iterator]: () => {
- const container = range.commonAncestorContainer;
- let currentNode = (0, TreeAlgorithm_1.tree_getFirstDescendantNode)(container);
- return {
- next: () => {
- while (currentNode && !range_isContained(currentNode, range)) {
- currentNode = (0, TreeAlgorithm_1.tree_getNextDescendantNode)(container, currentNode);
- }
- if (currentNode === null) {
- return { done: true, value: null };
- }
- else {
- const result = { done: false, value: currentNode };
- currentNode = (0, TreeAlgorithm_1.tree_getNextDescendantNode)(container, currentNode);
- return result;
- }
- }
- };
- }
- };
-}
-/**
- * Traverses through all partially contained nodes of a range.
- *
- * @param range - a range
- */
-function range_getPartiallyContainedNodes(range) {
- return {
- [Symbol.iterator]: () => {
- const container = range.commonAncestorContainer;
- let currentNode = (0, TreeAlgorithm_1.tree_getFirstDescendantNode)(container);
- return {
- next: () => {
- while (currentNode && !range_isPartiallyContained(currentNode, range)) {
- currentNode = (0, TreeAlgorithm_1.tree_getNextDescendantNode)(container, currentNode);
- }
- if (currentNode === null) {
- return { done: true, value: null };
- }
- else {
- const result = { done: false, value: currentNode };
- currentNode = (0, TreeAlgorithm_1.tree_getNextDescendantNode)(container, currentNode);
- return result;
- }
- }
- };
- }
- };
-}
-//# sourceMappingURL=RangeAlgorithm.js.map
-
-/***/ }),
-
-/***/ 3886:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.selectors_scopeMatchASelectorsString = selectors_scopeMatchASelectorsString;
-const DOMException_1 = __nccwpck_require__(7175);
-/**
- * Matches elements with the given selectors.
- *
- * @param selectors - selectors
- * @param node - the node to match against
- */
-function selectors_scopeMatchASelectorsString(selectors, node) {
- /**
- * TODO: Selectors
- * 1. Let s be the result of parse a selector selectors. [SELECTORS4]
- * 2. If s is failure, then throw a "SyntaxError" DOMException.
- * 3. Return the result of match a selector against a tree with s and node’s
- * root using scoping root node. [SELECTORS4].
- */
- throw new DOMException_1.NotSupportedError();
-}
-//# sourceMappingURL=SelectorsAlgorithm.js.map
-
-/***/ }),
-
-/***/ 708:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.shadowTree_signalASlotChange = shadowTree_signalASlotChange;
-exports.shadowTree_isConnected = shadowTree_isConnected;
-exports.shadowTree_isAssigned = shadowTree_isAssigned;
-exports.shadowTree_findASlot = shadowTree_findASlot;
-exports.shadowTree_findSlotables = shadowTree_findSlotables;
-exports.shadowTree_findFlattenedSlotables = shadowTree_findFlattenedSlotables;
-exports.shadowTree_assignSlotables = shadowTree_assignSlotables;
-exports.shadowTree_assignSlotablesForATree = shadowTree_assignSlotablesForATree;
-exports.shadowTree_assignASlot = shadowTree_assignASlot;
-const DOMImpl_1 = __nccwpck_require__(698);
-const util_1 = __nccwpck_require__(8247);
-const util_2 = __nccwpck_require__(7061);
-const TreeAlgorithm_1 = __nccwpck_require__(3532);
-const MutationObserverAlgorithm_1 = __nccwpck_require__(3243);
-/**
- * Signals a slot change to the given slot.
- *
- * @param slot - a slot
- */
-function shadowTree_signalASlotChange(slot) {
- /**
- * 1. Append slot to slot’s relevant agent’s signal slots.
- * 2. Queue a mutation observer microtask.
- */
- const window = DOMImpl_1.dom.window;
- window._signalSlots.add(slot);
- (0, MutationObserverAlgorithm_1.observer_queueAMutationObserverMicrotask)();
-}
-/**
- * Determines whether a the shadow tree of the given element node is
- * connected to a document node.
- *
- * @param element - an element node of the shadow tree
- */
-function shadowTree_isConnected(element) {
- /**
- * An element is connected if its shadow-including root is a document.
- */
- return util_1.Guard.isDocumentNode((0, TreeAlgorithm_1.tree_rootNode)(element, true));
-}
-/**
- * Determines whether a slotable is assigned.
- *
- * @param slotable - a slotable
- */
-function shadowTree_isAssigned(slotable) {
- /**
- * A slotable is assigned if its assigned slot is non-null.
- */
- return (slotable._assignedSlot !== null);
-}
-/**
- * Finds a slot for the given slotable.
- *
- * @param slotable - a slotable
- * @param openFlag - `true` to search open shadow tree's only
- */
-function shadowTree_findASlot(slotable, openFlag = false) {
- /**
- * 1. If slotable’s parent is null, then return null.
- * 2. Let shadow be slotable’s parent’s shadow root.
- * 3. If shadow is null, then return null.
- * 4. If the open flag is set and shadow’s mode is not "open", then
- * return null.
- * 5. Return the first slot in tree order in shadow’s descendants whose name
- * is slotable’s name, if any, and null otherwise.
- */
- const node = util_1.Cast.asNode(slotable);
- const parent = node._parent;
- if (parent === null)
- return null;
- const shadow = parent._shadowRoot || null;
- if (shadow === null)
- return null;
- if (openFlag && shadow._mode !== "open")
- return null;
- let child = (0, TreeAlgorithm_1.tree_getFirstDescendantNode)(shadow, false, true, (e) => util_1.Guard.isSlot(e));
- while (child !== null) {
- if (child._name === slotable._name)
- return child;
- child = (0, TreeAlgorithm_1.tree_getNextDescendantNode)(shadow, child, false, true, (e) => util_1.Guard.isSlot(e));
- }
- return null;
-}
-/**
- * Finds slotables for the given slot.
- *
- * @param slot - a slot
- */
-function shadowTree_findSlotables(slot) {
- /**
- * 1. Let result be an empty list.
- * 2. If slot’s root is not a shadow root, then return result.
- */
- const result = [];
- const root = (0, TreeAlgorithm_1.tree_rootNode)(slot);
- if (!util_1.Guard.isShadowRoot(root))
- return result;
- /**
- * 3. Let host be slot’s root’s host.
- * 4. For each slotable child of host, slotable, in tree order:
- */
- const host = root._host;
- for (const slotable of host._children) {
- if (util_1.Guard.isSlotable(slotable)) {
- /**
- * 4.1. Let foundSlot be the result of finding a slot given slotable.
- * 4.2. If foundSlot is slot, then append slotable to result.
- */
- const foundSlot = shadowTree_findASlot(slotable);
- if (foundSlot === slot) {
- result.push(slotable);
- }
- }
- }
- /**
- * 5. Return result.
- */
- return result;
-}
-/**
- * Finds slotables for the given slot.
- *
- * @param slot - a slot
- */
-function shadowTree_findFlattenedSlotables(slot) {
- /**
- * 1. Let result be an empty list.
- * 2. If slot’s root is not a shadow root, then return result.
- */
- const result = [];
- const root = (0, TreeAlgorithm_1.tree_rootNode)(slot);
- if (!util_1.Guard.isShadowRoot(root))
- return result;
- /**
- * 3. Let slotables be the result of finding slotables given slot.
- * 4. If slotables is the empty list, then append each slotable child of
- * slot, in tree order, to slotables.
- */
- const slotables = shadowTree_findSlotables(slot);
- if ((0, util_2.isEmpty)(slotables)) {
- for (const slotable of slot._children) {
- if (util_1.Guard.isSlotable(slotable)) {
- slotables.push(slotable);
- }
- }
- }
- /**
- * 5. For each node in slotables:
- */
- for (const node of slotables) {
- /**
- * 5.1. If node is a slot whose root is a shadow root, then:
- */
- if (util_1.Guard.isSlot(node) && util_1.Guard.isShadowRoot((0, TreeAlgorithm_1.tree_rootNode)(node))) {
- /**
- * 5.1.1. Let temporaryResult be the result of finding flattened slotables given node.
- * 5.1.2. Append each slotable in temporaryResult, in order, to result.
- */
- const temporaryResult = shadowTree_findFlattenedSlotables(node);
- result.push(...temporaryResult);
- }
- else {
- /**
- * 5.2. Otherwise, append node to result.
- */
- result.push(node);
- }
- }
- /**
- * 6. Return result.
- */
- return result;
-}
-/**
- * Assigns slotables to the given slot.
- *
- * @param slot - a slot
- */
-function shadowTree_assignSlotables(slot) {
- /**
- * 1. Let slotables be the result of finding slotables for slot.
- * 2. If slotables and slot’s assigned nodes are not identical, then run
- * signal a slot change for slot.
- */
- const slotables = shadowTree_findSlotables(slot);
- if (slotables.length === slot._assignedNodes.length) {
- let nodesIdentical = true;
- for (let i = 0; i < slotables.length; i++) {
- if (slotables[i] !== slot._assignedNodes[i]) {
- nodesIdentical = false;
- break;
- }
- }
- if (!nodesIdentical) {
- shadowTree_signalASlotChange(slot);
- }
- }
- /**
- * 3. Set slot’s assigned nodes to slotables.
- * 4. For each slotable in slotables, set slotable’s assigned slot to slot.
- */
- slot._assignedNodes = slotables;
- for (const slotable of slotables) {
- slotable._assignedSlot = slot;
- }
-}
-/**
- * Assigns slotables to all nodes of a tree.
- *
- * @param root - root node
- */
-function shadowTree_assignSlotablesForATree(root) {
- /**
- * To assign slotables for a tree, given a node root, run assign slotables
- * for each slot slot in root’s inclusive descendants, in tree order.
- */
- let descendant = (0, TreeAlgorithm_1.tree_getFirstDescendantNode)(root, true, false, (e) => util_1.Guard.isSlot(e));
- while (descendant !== null) {
- shadowTree_assignSlotables(descendant);
- descendant = (0, TreeAlgorithm_1.tree_getNextDescendantNode)(root, descendant, true, false, (e) => util_1.Guard.isSlot(e));
- }
-}
-/**
- * Assigns a slot to a slotables.
- *
- * @param slotable - a slotable
- */
-function shadowTree_assignASlot(slotable) {
- /**
- * 1. Let slot be the result of finding a slot with slotable.
- * 2. If slot is non-null, then run assign slotables for slot.
- */
- const slot = shadowTree_findASlot(slotable);
- if (slot !== null) {
- shadowTree_assignSlotables(slot);
- }
-}
-//# sourceMappingURL=ShadowTreeAlgorithm.js.map
-
-/***/ }),
-
-/***/ 3813:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.text_contiguousTextNodes = text_contiguousTextNodes;
-exports.text_contiguousExclusiveTextNodes = text_contiguousExclusiveTextNodes;
-exports.text_descendantTextContent = text_descendantTextContent;
-exports.text_split = text_split;
-const DOMImpl_1 = __nccwpck_require__(698);
-const util_1 = __nccwpck_require__(8247);
-const DOMException_1 = __nccwpck_require__(7175);
-const CreateAlgorithm_1 = __nccwpck_require__(8308);
-const TreeAlgorithm_1 = __nccwpck_require__(3532);
-const CharacterDataAlgorithm_1 = __nccwpck_require__(7785);
-const MutationAlgorithm_1 = __nccwpck_require__(45);
-/**
- * Returns node with its adjacent text and cdata node siblings.
- *
- * @param node - a node
- * @param self - whether to include node itself
- */
-function text_contiguousTextNodes(node, self = false) {
- /**
- * The contiguous Text nodes of a node node are node, node’s previous
- * sibling Text node, if any, and its contiguous Text nodes, and node’s next
- * sibling Text node, if any, and its contiguous Text nodes, avoiding any
- * duplicates.
- */
- return {
- [Symbol.iterator]() {
- let currentNode = node;
- while (currentNode && util_1.Guard.isTextNode(currentNode._previousSibling)) {
- currentNode = currentNode._previousSibling;
- }
- return {
- next() {
- if (currentNode && (!self && currentNode === node)) {
- if (util_1.Guard.isTextNode(currentNode._nextSibling)) {
- currentNode = currentNode._nextSibling;
- }
- else {
- currentNode = null;
- }
- }
- if (currentNode === null) {
- return { done: true, value: null };
- }
- else {
- const result = { done: false, value: currentNode };
- if (util_1.Guard.isTextNode(currentNode._nextSibling)) {
- currentNode = currentNode._nextSibling;
- }
- else {
- currentNode = null;
- }
- return result;
- }
- }
- };
- }
- };
-}
-/**
- * Returns node with its adjacent text node siblings.
- *
- * @param node - a node
- * @param self - whether to include node itself
- */
-function text_contiguousExclusiveTextNodes(node, self = false) {
- /**
- * The contiguous exclusive Text nodes of a node node are node, node’s
- * previous sibling exclusive Text node, if any, and its contiguous
- * exclusive Text nodes, and node’s next sibling exclusive Text node,
- * if any, and its contiguous exclusive Text nodes, avoiding any duplicates.
- */
- return {
- [Symbol.iterator]() {
- let currentNode = node;
- while (currentNode && util_1.Guard.isExclusiveTextNode(currentNode._previousSibling)) {
- currentNode = currentNode._previousSibling;
- }
- return {
- next() {
- if (currentNode && (!self && currentNode === node)) {
- if (util_1.Guard.isExclusiveTextNode(currentNode._nextSibling)) {
- currentNode = currentNode._nextSibling;
- }
- else {
- currentNode = null;
- }
- }
- if (currentNode === null) {
- return { done: true, value: null };
- }
- else {
- const result = { done: false, value: currentNode };
- if (util_1.Guard.isExclusiveTextNode(currentNode._nextSibling)) {
- currentNode = currentNode._nextSibling;
- }
- else {
- currentNode = null;
- }
- return result;
- }
- }
- };
- }
- };
-}
-/**
- * Returns the concatenation of the data of all the Text node descendants of
- * node, in tree order.
- *
- * @param node - a node
- */
-function text_descendantTextContent(node) {
- /**
- * The descendant text content of a node node is the concatenation of the
- * data of all the Text node descendants of node, in tree order.
- */
- let contents = '';
- let text = (0, TreeAlgorithm_1.tree_getFirstDescendantNode)(node, false, false, (e) => util_1.Guard.isTextNode(e));
- while (text !== null) {
- contents += text._data;
- text = (0, TreeAlgorithm_1.tree_getNextDescendantNode)(node, text, false, false, (e) => util_1.Guard.isTextNode(e));
- }
- return contents;
-}
-/**
- * Splits data at the given offset and returns the remainder as a text
- * node.
- *
- * @param node - a text node
- * @param offset - the offset at which to split the nodes.
- */
-function text_split(node, offset) {
- /**
- * 1. Let length be node’s length.
- * 2. If offset is greater than length, then throw an "IndexSizeError"
- * DOMException.
- */
- const length = node._data.length;
- if (offset > length) {
- throw new DOMException_1.IndexSizeError();
- }
- /**
- * 3. Let count be length minus offset.
- * 4. Let new data be the result of substringing data with node node,
- * offset offset, and count count.
- * 5. Let new node be a new Text node, with the same node document as node.
- * Set new node’s data to new data.
- * 6. Let parent be node’s parent.
- * 7. If parent is not null, then:
- */
- const count = length - offset;
- const newData = (0, CharacterDataAlgorithm_1.characterData_substringData)(node, offset, count);
- const newNode = (0, CreateAlgorithm_1.create_text)(node._nodeDocument, newData);
- const parent = node._parent;
- if (parent !== null) {
- /**
- * 7.1. Insert new node into parent before node’s next sibling.
- */
- (0, MutationAlgorithm_1.mutation_insert)(newNode, parent, node._nextSibling);
- /**
- * 7.2. For each live range whose start node is node and start offset is
- * greater than offset, set its start node to new node and decrease its
- * start offset by offset.
- * 7.3. For each live range whose end node is node and end offset is greater
- * than offset, set its end node to new node and decrease its end offset
- * by offset.
- * 7.4. For each live range whose start node is parent and start offset is
- * equal to the index of node plus 1, increase its start offset by 1.
- * 7.5. For each live range whose end node is parent and end offset is equal
- * to the index of node plus 1, increase its end offset by 1.
- */
- for (const range of DOMImpl_1.dom.rangeList) {
- if (range._start[0] === node && range._start[1] > offset) {
- range._start[0] = newNode;
- range._start[1] -= offset;
- }
- if (range._end[0] === node && range._end[1] > offset) {
- range._end[0] = newNode;
- range._end[1] -= offset;
- }
- const index = (0, TreeAlgorithm_1.tree_index)(node);
- if (range._start[0] === parent && range._start[1] === index + 1) {
- range._start[1]++;
- }
- if (range._end[0] === parent && range._end[1] === index + 1) {
- range._end[1]++;
- }
- }
- }
- /**
- * 8. Replace data with node node, offset offset, count count, and data
- * the empty string.
- * 9. Return new node.
- */
- (0, CharacterDataAlgorithm_1.characterData_replaceData)(node, offset, count, '');
- return newNode;
-}
-//# sourceMappingURL=TextAlgorithm.js.map
-
-/***/ }),
-
-/***/ 6746:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.traversal_filter = traversal_filter;
-const interfaces_1 = __nccwpck_require__(9454);
-const DOMException_1 = __nccwpck_require__(7175);
-/**
- * Applies the filter to the given node and returns the result.
- *
- * @param traverser - the `NodeIterator` or `TreeWalker` instance
- * @param node - the node to filter
- */
-function traversal_filter(traverser, node) {
- /**
- * 1. If traverser’s active flag is set, then throw an "InvalidStateError"
- * DOMException.
- */
- if (traverser._activeFlag) {
- throw new DOMException_1.InvalidStateError();
- }
- /**
- * 2. Let n be node’s nodeType attribute value − 1.
- */
- const n = node._nodeType - 1;
- /**
- * 3. If the nth bit (where 0 is the least significant bit) of traverser’s
- * whatToShow is not set, then return FILTER_SKIP.
- */
- const mask = 1 << n;
- if ((traverser.whatToShow & mask) === 0) {
- return interfaces_1.FilterResult.Skip;
- }
- /**
- * 4. If traverser’s filter is null, then return FILTER_ACCEPT.
- */
- if (!traverser.filter) {
- return interfaces_1.FilterResult.Accept;
- }
- /**
- * 5. Set traverser’s active flag.
- */
- traverser._activeFlag = true;
- /**
- * 6. Let result be the return value of call a user object’s operation with
- * traverser’s filter, "acceptNode", and « node ». If this throws an
- * exception, then unset traverser’s active flag and rethrow the exception.
- */
- let result = interfaces_1.FilterResult.Reject;
- try {
- result = traverser.filter.acceptNode(node);
- }
- catch (err) {
- traverser._activeFlag = false;
- throw err;
- }
- /**
- * 7. Unset traverser’s active flag.
- * 8. Return result.
- */
- traverser._activeFlag = false;
- return result;
-}
-//# sourceMappingURL=TraversalAlgorithm.js.map
-
-/***/ }),
-
-/***/ 3532:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.tree_getFirstDescendantNode = tree_getFirstDescendantNode;
-exports.tree_getNextDescendantNode = tree_getNextDescendantNode;
-exports.tree_getDescendantNodes = tree_getDescendantNodes;
-exports.tree_getDescendantElements = tree_getDescendantElements;
-exports.tree_getSiblingNodes = tree_getSiblingNodes;
-exports.tree_getFirstAncestorNode = tree_getFirstAncestorNode;
-exports.tree_getNextAncestorNode = tree_getNextAncestorNode;
-exports.tree_getAncestorNodes = tree_getAncestorNodes;
-exports.tree_getCommonAncestor = tree_getCommonAncestor;
-exports.tree_getFollowingNode = tree_getFollowingNode;
-exports.tree_getPrecedingNode = tree_getPrecedingNode;
-exports.tree_isConstrained = tree_isConstrained;
-exports.tree_nodeLength = tree_nodeLength;
-exports.tree_isEmpty = tree_isEmpty;
-exports.tree_rootNode = tree_rootNode;
-exports.tree_isDescendantOf = tree_isDescendantOf;
-exports.tree_isAncestorOf = tree_isAncestorOf;
-exports.tree_isHostIncludingAncestorOf = tree_isHostIncludingAncestorOf;
-exports.tree_isSiblingOf = tree_isSiblingOf;
-exports.tree_isPreceding = tree_isPreceding;
-exports.tree_isFollowing = tree_isFollowing;
-exports.tree_isParentOf = tree_isParentOf;
-exports.tree_isChildOf = tree_isChildOf;
-exports.tree_previousSibling = tree_previousSibling;
-exports.tree_nextSibling = tree_nextSibling;
-exports.tree_firstChild = tree_firstChild;
-exports.tree_lastChild = tree_lastChild;
-exports.tree_treePosition = tree_treePosition;
-exports.tree_index = tree_index;
-exports.tree_retarget = tree_retarget;
-const util_1 = __nccwpck_require__(8247);
-const interfaces_1 = __nccwpck_require__(9454);
-/**
- * Gets the next descendant of the given node of the tree rooted at `root`
- * in depth-first pre-order.
- *
- * @param root - root node of the tree
- * @param node - a node
- * @param shadow - whether to visit shadow tree nodes
- */
-function _getNextDescendantNode(root, node, shadow = false) {
- // traverse shadow tree
- if (shadow && util_1.Guard.isElementNode(node) && util_1.Guard.isShadowRoot(node.shadowRoot)) {
- if (node.shadowRoot._firstChild)
- return node.shadowRoot._firstChild;
- }
- // traverse child nodes
- if (node._firstChild)
- return node._firstChild;
- if (node === root)
- return null;
- // traverse siblings
- if (node._nextSibling)
- return node._nextSibling;
- // traverse parent's next sibling
- let parent = node._parent;
- while (parent && parent !== root) {
- if (parent._nextSibling)
- return parent._nextSibling;
- parent = parent._parent;
- }
- return null;
-}
-function _emptyIterator() {
- return {
- [Symbol.iterator]: () => {
- return {
- next: () => {
- return { done: true, value: null };
- }
- };
- }
- };
-}
-/**
- * Returns the first descendant node of the tree rooted at `node` in
- * depth-first pre-order.
- *
- * @param node - root node of the tree
- * @param self - whether to include `node` in traversal
- * @param shadow - whether to visit shadow tree nodes
- * @param filter - a function to filter nodes
- */
-function tree_getFirstDescendantNode(node, self = false, shadow = false, filter) {
- let firstNode = (self ? node : _getNextDescendantNode(node, node, shadow));
- while (firstNode && filter && !filter(firstNode)) {
- firstNode = _getNextDescendantNode(node, firstNode, shadow);
- }
- return firstNode;
-}
-/**
- * Returns the next descendant node of the tree rooted at `node` in
- * depth-first pre-order.
- *
- * @param node - root node of the tree
- * @param currentNode - current descendant node
- * @param self - whether to include `node` in traversal
- * @param shadow - whether to visit shadow tree nodes
- * @param filter - a function to filter nodes
- */
-function tree_getNextDescendantNode(node, currentNode, self = false, shadow = false, filter) {
- let nextNode = _getNextDescendantNode(node, currentNode, shadow);
- while (nextNode && filter && !filter(nextNode)) {
- nextNode = _getNextDescendantNode(node, nextNode, shadow);
- }
- return nextNode;
-}
-/**
- * Traverses through all descendant nodes of the tree rooted at
- * `node` in depth-first pre-order.
- *
- * @param node - root node of the tree
- * @param self - whether to include `node` in traversal
- * @param shadow - whether to visit shadow tree nodes
- * @param filter - a function to filter nodes
- */
-function tree_getDescendantNodes(node, self = false, shadow = false, filter) {
- if (!self && node._children.size === 0) {
- return _emptyIterator();
- }
- return {
- [Symbol.iterator]: () => {
- let currentNode = (self ? node : _getNextDescendantNode(node, node, shadow));
- return {
- next: () => {
- while (currentNode && filter && !filter(currentNode)) {
- currentNode = _getNextDescendantNode(node, currentNode, shadow);
- }
- if (currentNode === null) {
- return { done: true, value: null };
- }
- else {
- const result = { done: false, value: currentNode };
- currentNode = _getNextDescendantNode(node, currentNode, shadow);
- return result;
- }
- }
- };
- }
- };
-}
-/**
- * Traverses through all descendant element nodes of the tree rooted at
- * `node` in depth-first preorder.
- *
- * @param node - root node of the tree
- * @param self - whether to include `node` in traversal
- * @param shadow - whether to visit shadow tree nodes
- * @param filter - a function to filter nodes
- */
-function tree_getDescendantElements(node, self = false, shadow = false, filter) {
- if (!self && node._children.size === 0) {
- return _emptyIterator();
- }
- return {
- [Symbol.iterator]: () => {
- const it = tree_getDescendantNodes(node, self, shadow, (e) => util_1.Guard.isElementNode(e))[Symbol.iterator]();
- let currentNode = it.next().value;
- return {
- next() {
- while (currentNode && filter && !filter(currentNode)) {
- currentNode = it.next().value;
- }
- if (currentNode === null) {
- return { done: true, value: null };
- }
- else {
- const result = { done: false, value: currentNode };
- currentNode = it.next().value;
- return result;
- }
- }
- };
- }
- };
-}
-/**
- * Traverses through all sibling nodes of `node`.
- *
- * @param node - root node of the tree
- * @param self - whether to include `node` in traversal
- * @param filter - a function to filter nodes
- */
-function tree_getSiblingNodes(node, self = false, filter) {
- if (!node._parent || node._parent._children.size === 0) {
- return _emptyIterator();
- }
- return {
- [Symbol.iterator]() {
- let currentNode = node._parent ? node._parent._firstChild : null;
- return {
- next() {
- while (currentNode && (filter && !filter(currentNode) || (!self && currentNode === node))) {
- currentNode = currentNode._nextSibling;
- }
- if (currentNode === null) {
- return { done: true, value: null };
- }
- else {
- const result = { done: false, value: currentNode };
- currentNode = currentNode._nextSibling;
- return result;
- }
- }
- };
- }
- };
-}
-/**
- * Gets the first ancestor of `node` in reverse tree order.
- *
- * @param node - root node of the tree
- * @param self - whether to include `node` in traversal
- * @param filter - a function to filter nodes
- */
-function tree_getFirstAncestorNode(node, self = false, filter) {
- let firstNode = self ? node : node._parent;
- while (firstNode && filter && !filter(firstNode)) {
- firstNode = firstNode._parent;
- }
- return firstNode;
-}
-/**
- * Gets the first ancestor of `node` in reverse tree order.
- *
- * @param node - root node of the tree
- * @param self - whether to include `node` in traversal
- * @param filter - a function to filter nodes
- */
-function tree_getNextAncestorNode(node, currentNode, self = false, filter) {
- let nextNode = currentNode._parent;
- while (nextNode && filter && !filter(nextNode)) {
- nextNode = nextNode._parent;
- }
- return nextNode;
-}
-/**
- * Traverses through all ancestor nodes `node` in reverse tree order.
- *
- * @param node - root node of the tree
- * @param self - whether to include `node` in traversal
- * @param filter - a function to filter nodes
- */
-function tree_getAncestorNodes(node, self = false, filter) {
- if (!self && !node._parent) {
- return _emptyIterator();
- }
- return {
- [Symbol.iterator]() {
- let currentNode = tree_getFirstAncestorNode(node, self, filter);
- return {
- next() {
- if (currentNode === null) {
- return { done: true, value: null };
- }
- else {
- const result = { done: false, value: currentNode };
- currentNode = tree_getNextAncestorNode(node, currentNode, self, filter);
- return result;
- }
- }
- };
- }
- };
-}
-/**
- * Returns the common ancestor of the given nodes.
- *
- * @param nodeA - a node
- * @param nodeB - a node
- */
-function tree_getCommonAncestor(nodeA, nodeB) {
- if (nodeA === nodeB) {
- return nodeA._parent;
- }
- // lists of parent nodes
- const parentsA = [];
- const parentsB = [];
- let pA = tree_getFirstAncestorNode(nodeA, true);
- while (pA !== null) {
- parentsA.push(pA);
- pA = tree_getNextAncestorNode(nodeA, pA, true);
- }
- let pB = tree_getFirstAncestorNode(nodeB, true);
- while (pB !== null) {
- parentsB.push(pB);
- pB = tree_getNextAncestorNode(nodeB, pB, true);
- }
- // walk through parents backwards until they differ
- let pos1 = parentsA.length;
- let pos2 = parentsB.length;
- let parent = null;
- for (let i = Math.min(pos1, pos2); i > 0; i--) {
- const parent1 = parentsA[--pos1];
- const parent2 = parentsB[--pos2];
- if (parent1 !== parent2) {
- break;
- }
- parent = parent1;
- }
- return parent;
-}
-/**
- * Returns the node following `node` in depth-first preorder.
- *
- * @param root - root of the subtree
- * @param node - a node
- */
-function tree_getFollowingNode(root, node) {
- if (node._firstChild) {
- return node._firstChild;
- }
- else if (node._nextSibling) {
- return node._nextSibling;
- }
- else {
- while (true) {
- const parent = node._parent;
- if (parent === null || parent === root) {
- return null;
- }
- else if (parent._nextSibling) {
- return parent._nextSibling;
- }
- else {
- node = parent;
- }
- }
- }
-}
-/**
- * Returns the node preceding `node` in depth-first preorder.
- *
- * @param root - root of the subtree
- * @param node - a node
- */
-function tree_getPrecedingNode(root, node) {
- if (node === root) {
- return null;
- }
- if (node._previousSibling) {
- node = node._previousSibling;
- if (node._lastChild) {
- return node._lastChild;
- }
- else {
- return node;
- }
- }
- else {
- return node._parent;
- }
-}
-/**
- * Determines if the node tree is constrained. A node tree is
- * constrained as follows, expressed as a relationship between the
- * type of node and its allowed children:
- * - Document (In tree order)
- * * Zero or more nodes each of which is ProcessingInstruction
- * or Comment.
- * * Optionally one DocumentType node.
- * * Zero or more nodes each of which is ProcessingInstruction
- * or Comment.
- * * Optionally one Element node.
- * * Zero or more nodes each of which is ProcessingInstruction
- * or Comment.
- * - DocumentFragment, Element
- * * Zero or more nodes each of which is Element, Text,
- * ProcessingInstruction, or Comment.
- * - DocumentType, Text, ProcessingInstruction, Comment
- * * None.
- *
- * @param node - the root of the tree
- */
-function tree_isConstrained(node) {
- switch (node._nodeType) {
- case interfaces_1.NodeType.Document:
- let hasDocType = false;
- let hasElement = false;
- for (const childNode of node._children) {
- switch (childNode._nodeType) {
- case interfaces_1.NodeType.ProcessingInstruction:
- case interfaces_1.NodeType.Comment:
- break;
- case interfaces_1.NodeType.DocumentType:
- if (hasDocType || hasElement)
- return false;
- hasDocType = true;
- break;
- case interfaces_1.NodeType.Element:
- if (hasElement)
- return false;
- hasElement = true;
- break;
- default:
- return false;
- }
- }
- break;
- case interfaces_1.NodeType.DocumentFragment:
- case interfaces_1.NodeType.Element:
- for (const childNode of node._children) {
- switch (childNode._nodeType) {
- case interfaces_1.NodeType.Element:
- case interfaces_1.NodeType.Text:
- case interfaces_1.NodeType.ProcessingInstruction:
- case interfaces_1.NodeType.CData:
- case interfaces_1.NodeType.Comment:
- break;
- default:
- return false;
- }
- }
- break;
- case interfaces_1.NodeType.DocumentType:
- case interfaces_1.NodeType.Text:
- case interfaces_1.NodeType.ProcessingInstruction:
- case interfaces_1.NodeType.CData:
- case interfaces_1.NodeType.Comment:
- return (!node.hasChildNodes());
- }
- for (const childNode of node._children) {
- // recursively check child nodes
- if (!tree_isConstrained(childNode))
- return false;
- }
- return true;
-}
-/**
- * Returns the length of a node.
- *
- * @param node - a node to check
- */
-function tree_nodeLength(node) {
- /**
- * To determine the length of a node node, switch on node:
- * - DocumentType
- * Zero.
- * - Text
- * - ProcessingInstruction
- * - Comment
- * Its data’s length.
- * - Any other node
- * Its number of children.
- */
- if (util_1.Guard.isDocumentTypeNode(node)) {
- return 0;
- }
- else if (util_1.Guard.isCharacterDataNode(node)) {
- return node._data.length;
- }
- else {
- return node._children.size;
- }
-}
-/**
- * Determines if a node is empty.
- *
- * @param node - a node to check
- */
-function tree_isEmpty(node) {
- /**
- * A node is considered empty if its length is zero.
- */
- return (tree_nodeLength(node) === 0);
-}
-/**
- * Returns the root node of a tree. The root of an object is itself,
- * if its parent is `null`, or else it is the root of its parent.
- * The root of a tree is any object participating in that tree
- * whose parent is `null`.
- *
- * @param node - a node of the tree
- * @param shadow - `true` to return shadow-including root, otherwise
- * `false`
- */
-function tree_rootNode(node, shadow = false) {
- /**
- * The root of an object is itself, if its parent is null, or else it is the
- * root of its parent. The root of a tree is any object participating in
- * that tree whose parent is null.
- */
- if (shadow) {
- const root = tree_rootNode(node, false);
- if (util_1.Guard.isShadowRoot(root))
- return tree_rootNode(root._host, true);
- else
- return root;
- }
- else {
- if (!node._parent)
- return node;
- else
- return tree_rootNode(node._parent);
- }
-}
-/**
- * Determines whether `other` is a descendant of `node`. An object
- * A is called a descendant of an object B, if either A is a child
- * of B or A is a child of an object C that is a descendant of B.
- *
- * @param node - a node
- * @param other - the node to check
- * @param self - if `true`, traversal includes `node` itself
- * @param shadow - if `true`, traversal includes the
- * node's and its descendant's shadow trees as well.
- */
-function tree_isDescendantOf(node, other, self = false, shadow = false) {
- /**
- * An object A is called a descendant of an object B, if either A is a
- * child of B or A is a child of an object C that is a descendant of B.
- *
- * An inclusive descendant is an object or one of its descendants.
- */
- let child = tree_getFirstDescendantNode(node, self, shadow);
- while (child !== null) {
- if (child === other) {
- return true;
- }
- child = tree_getNextDescendantNode(node, child, self, shadow);
- }
- return false;
-}
-/**
- * Determines whether `other` is an ancestor of `node`. An object A
- * is called an ancestor of an object B if and only if B is a
- * descendant of A.
- *
- * @param node - a node
- * @param other - the node to check
- * @param self - if `true`, traversal includes `node` itself
- * @param shadow - if `true`, traversal includes the
- * node's and its descendant's shadow trees as well.
- */
-function tree_isAncestorOf(node, other, self = false, shadow = false) {
- let ancestor = self ? node : shadow && util_1.Guard.isShadowRoot(node) ?
- node._host : node._parent;
- while (ancestor !== null) {
- if (ancestor === other)
- return true;
- ancestor = shadow && util_1.Guard.isShadowRoot(ancestor) ?
- ancestor._host : ancestor._parent;
- }
- return false;
-}
-/**
- * Determines whether `other` is a host-including ancestor of `node`. An
- * object A is a host-including inclusive ancestor of an object B, if either
- * A is an inclusive ancestor of B, or if B’s root has a non-null host and
- * A is a host-including inclusive ancestor of B’s root’s host.
- *
- * @param node - a node
- * @param other - the node to check
- * @param self - if `true`, traversal includes `node` itself
- */
-function tree_isHostIncludingAncestorOf(node, other, self = false) {
- if (tree_isAncestorOf(node, other, self))
- return true;
- const root = tree_rootNode(node);
- if (util_1.Guard.isDocumentFragmentNode(root) && root._host !== null &&
- tree_isHostIncludingAncestorOf(root._host, other, self))
- return true;
- return false;
-}
-/**
- * Determines whether `other` is a sibling of `node`. An object A is
- * called a sibling of an object B, if and only if B and A share
- * the same non-null parent.
- *
- * @param node - a node
- * @param other - the node to check
- * @param self - if `true`, traversal includes `node` itself
- */
-function tree_isSiblingOf(node, other, self = false) {
- /**
- * An object A is called a sibling of an object B, if and only if B and A
- * share the same non-null parent.
- *
- * An inclusive sibling is an object or one of its siblings.
- */
- if (node === other) {
- if (self)
- return true;
- }
- else {
- return (node._parent !== null && node._parent === other._parent);
- }
- return false;
-}
-/**
- * Determines whether `other` is preceding `node`. An object A is
- * preceding an object B if A and B are in the same tree and A comes
- * before B in tree order.
- *
- * @param node - a node
- * @param other - the node to check
- */
-function tree_isPreceding(node, other) {
- /**
- * An object A is preceding an object B if A and B are in the same tree and
- * A comes before B in tree order.
- */
- const nodePos = tree_treePosition(node);
- const otherPos = tree_treePosition(other);
- if (nodePos === -1 || otherPos === -1)
- return false;
- else if (tree_rootNode(node) !== tree_rootNode(other))
- return false;
- else
- return otherPos < nodePos;
-}
-/**
- * Determines whether `other` is following `node`. An object A is
- * following an object B if A and B are in the same tree and A comes
- * after B in tree order.
- *
- * @param node - a node
- * @param other - the node to check
- */
-function tree_isFollowing(node, other) {
- /**
- * An object A is following an object B if A and B are in the same tree and
- * A comes after B in tree order.
- */
- const nodePos = tree_treePosition(node);
- const otherPos = tree_treePosition(other);
- if (nodePos === -1 || otherPos === -1)
- return false;
- else if (tree_rootNode(node) !== tree_rootNode(other))
- return false;
- else
- return otherPos > nodePos;
-}
-/**
- * Determines whether `other` is the parent node of `node`.
- *
- * @param node - a node
- * @param other - the node to check
- */
-function tree_isParentOf(node, other) {
- /**
- * An object that participates in a tree has a parent, which is either
- * null or an object, and has children, which is an ordered set of objects.
- * An object A whose parent is object B is a child of B.
- */
- return (node._parent === other);
-}
-/**
- * Determines whether `other` is a child node of `node`.
- *
- * @param node - a node
- * @param other - the node to check
- */
-function tree_isChildOf(node, other) {
- /**
- * An object that participates in a tree has a parent, which is either
- * null or an object, and has children, which is an ordered set of objects.
- * An object A whose parent is object B is a child of B.
- */
- return (other._parent === node);
-}
-/**
- * Returns the previous sibling node of `node` or null if it has no
- * preceding sibling.
- *
- * @param node
- */
-function tree_previousSibling(node) {
- /**
- * The previous sibling of an object is its first preceding sibling or null
- * if it has no preceding sibling.
- */
- return node._previousSibling;
-}
-/**
- * Returns the next sibling node of `node` or null if it has no
- * following sibling.
- *
- * @param node
- */
-function tree_nextSibling(node) {
- /**
- * The next sibling of an object is its first following sibling or null
- * if it has no following sibling.
- */
- return node._nextSibling;
-}
-/**
- * Returns the first child node of `node` or null if it has no
- * children.
- *
- * @param node
- */
-function tree_firstChild(node) {
- /**
- * The first child of an object is its first child or null if it has no
- * children.
- */
- return node._firstChild;
-}
-/**
- * Returns the last child node of `node` or null if it has no
- * children.
- *
- * @param node
- */
-function tree_lastChild(node) {
- /**
- * The last child of an object is its last child or null if it has no
- * children.
- */
- return node._lastChild;
-}
-/**
- * Returns the zero-based index of `node` when counted preorder in
- * the tree rooted at `root`. Returns `-1` if `node` is not in
- * the tree.
- *
- * @param node - the node to get the index of
- */
-function tree_treePosition(node) {
- const root = tree_rootNode(node);
- let pos = 0;
- let childNode = tree_getFirstDescendantNode(root);
- while (childNode !== null) {
- pos++;
- if (childNode === node)
- return pos;
- childNode = tree_getNextDescendantNode(root, childNode);
- }
- return -1;
-}
-/**
- * Determines the index of `node`. The index of an object is its number of
- * preceding siblings, or 0 if it has none.
- *
- * @param node - a node
- * @param other - the node to check
- */
-function tree_index(node) {
- /**
- * The index of an object is its number of preceding siblings, or 0 if it
- * has none.
- */
- let n = 0;
- while (node._previousSibling !== null) {
- n++;
- node = node._previousSibling;
- }
- return n;
-}
-/**
- * Retargets an object against another object.
- *
- * @param a - an object to retarget
- * @param b - an object to retarget against
- */
-function tree_retarget(a, b) {
- /**
- * To retarget an object A against an object B, repeat these steps until
- * they return an object:
- * 1. If one of the following is true
- * - A is not a node
- * - A's root is not a shadow root
- * - B is a node and A's root is a shadow-including inclusive ancestor
- * of B
- * then return A.
- * 2. Set A to A's root's host.
- */
- while (true) {
- if (!a || !util_1.Guard.isNode(a)) {
- return a;
- }
- const rootOfA = tree_rootNode(a);
- if (!util_1.Guard.isShadowRoot(rootOfA)) {
- return a;
- }
- if (b && util_1.Guard.isNode(b) && tree_isAncestorOf(rootOfA, b, true, true)) {
- return a;
- }
- a = rootOfA.host;
- }
-}
-//# sourceMappingURL=TreeAlgorithm.js.map
-
-/***/ }),
-
-/***/ 6094:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.treeWalker_traverseChildren = treeWalker_traverseChildren;
-exports.treeWalker_traverseSiblings = treeWalker_traverseSiblings;
-const interfaces_1 = __nccwpck_require__(9454);
-const TraversalAlgorithm_1 = __nccwpck_require__(6746);
-/**
- * Returns the first or last child node, or `null` if there are none.
- *
- * @param walker - the `TreeWalker` instance
- * @param first - `true` to return the first child node, or `false` to
- * return the last child node.
- */
-function treeWalker_traverseChildren(walker, first) {
- /**
- * 1. Let node be walker’s current.
- * 2. Set node to node’s first child if type is first, and node’s last child
- * if type is last.
- * 3. While node is non-null:
- */
- let node = (first ? walker._current._firstChild : walker._current._lastChild);
- while (node !== null) {
- /**
- * 3.1. Let result be the result of filtering node within walker.
- */
- const result = (0, TraversalAlgorithm_1.traversal_filter)(walker, node);
- if (result === interfaces_1.FilterResult.Accept) {
- /**
- * 3.2. If result is FILTER_ACCEPT, then set walker’s current to node and
- * return node.
- */
- walker._current = node;
- return node;
- }
- else if (result === interfaces_1.FilterResult.Skip) {
- /**
- * 3.3. If result is FILTER_SKIP, then:
- * 3.3.1. Let child be node’s first child if type is first, and node’s
- * last child if type is last.
- * 3.3.2. If child is non-null, then set node to child and continue.
- */
- const child = (first ? node._firstChild : node._lastChild);
- if (child !== null) {
- node = child;
- continue;
- }
- }
- /**
- * 3.4. While node is non-null:
- */
- while (node !== null) {
- /**
- * 3.4.1. Let sibling be node’s next sibling if type is first, and
- * node’s previous sibling if type is last.
- * 3.4.2. If sibling is non-null, then set node to sibling and break.
- */
- const sibling = (first ? node._nextSibling : node._previousSibling);
- if (sibling !== null) {
- node = sibling;
- break;
- }
- /**
- * 3.4.3. Let parent be node’s parent.
- * 3.4.4. If parent is null, walker’s root, or walker’s current, then
- * return null.
- */
- const parent = node._parent;
- if (parent === null || parent === walker._root || parent === walker._current) {
- return null;
- }
- /**
- * 3.4.5. Set node to parent.
- */
- node = parent;
- }
- }
- /**
- * 5. Return null
- */
- return null;
-}
-/**
- * Returns the next or previous sibling node, or `null` if there are none.
- *
- * @param walker - the `TreeWalker` instance
- * @param next - `true` to return the next sibling node, or `false` to
- * return the previous sibling node.
- */
-function treeWalker_traverseSiblings(walker, next) {
- /**
- * 1. Let node be walker’s current.
- * 2. If node is root, then return null.
- * 3. While node is non-null:
- */
- let node = walker._current;
- if (node === walker._root)
- return null;
- while (true) {
- /**
- * 3.1. Let sibling be node’s next sibling if type is next, and node’s
- * previous sibling if type is previous.
- * 3.2. While sibling is non-null:
- */
- let sibling = (next ? node._nextSibling : node._previousSibling);
- while (sibling !== null) {
- /**
- * 3.2.1. Set node to sibling.
- * 3.2.2. Let result be the result of filtering node within walker.
- * 3.2.3. If result is FILTER_ACCEPT, then set walker’s current to node
- * and return node.
- */
- node = sibling;
- const result = (0, TraversalAlgorithm_1.traversal_filter)(walker, node);
- if (result === interfaces_1.FilterResult.Accept) {
- walker._current = node;
- return node;
- }
- /**
- * 3.2.4. Set sibling to node’s first child if type is next, and node’s
- * last child if type is previous.
- * 3.2.5. If result is FILTER_REJECT or sibling is null, then set
- * sibling to node’s next sibling if type is next, and node’s previous
- * sibling if type is previous.
- */
- sibling = (next ? node._firstChild : node._lastChild);
- if (result === interfaces_1.FilterResult.Reject || sibling === null) {
- sibling = (next ? node._nextSibling : node._previousSibling);
- }
- }
- /**
- * 3.3. Set node to node’s parent.
- * 3.4. If node is null or walker’s root, then return null.
- */
- node = node._parent;
- if (node === null || node === walker._root) {
- return null;
- }
- /**
- * 3.5. If the return value of filtering node within walker is FILTER_ACCEPT,
- * then return null.
- */
- if ((0, TraversalAlgorithm_1.traversal_filter)(walker, node) === interfaces_1.FilterResult.Accept) {
- return null;
- }
- }
-}
-//# sourceMappingURL=TreeWalkerAlgorithm.js.map
-
-/***/ }),
-
-/***/ 4239:
-/***/ ((__unused_webpack_module, exports) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.idl_defineConst = idl_defineConst;
-/**
- * Defines a WebIDL `Const` property on the given object.
- *
- * @param o - object on which to add the property
- * @param name - property name
- * @param value - property value
- */
-function idl_defineConst(o, name, value) {
- Object.defineProperty(o, name, { writable: false, enumerable: true, configurable: false, value: value });
-}
-//# sourceMappingURL=WebIDLAlgorithm.js.map
-
-/***/ }),
-
-/***/ 6879:
-/***/ ((__unused_webpack_module, exports) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.xml_isName = xml_isName;
-exports.xml_isQName = xml_isQName;
-exports.xml_isLegalChar = xml_isLegalChar;
-exports.xml_isPubidChar = xml_isPubidChar;
-/**
- * Determines if the given string is valid for a `"Name"` construct.
- *
- * @param name - name string to test
- */
-function xml_isName(name) {
- for (let i = 0; i < name.length; i++) {
- let n = name.charCodeAt(i);
- // NameStartChar
- if ((n >= 97 && n <= 122) || // [a-z]
- (n >= 65 && n <= 90) || // [A-Z]
- n === 58 || n === 95 || // ':' or '_'
- (n >= 0xC0 && n <= 0xD6) ||
- (n >= 0xD8 && n <= 0xF6) ||
- (n >= 0xF8 && n <= 0x2FF) ||
- (n >= 0x370 && n <= 0x37D) ||
- (n >= 0x37F && n <= 0x1FFF) ||
- (n >= 0x200C && n <= 0x200D) ||
- (n >= 0x2070 && n <= 0x218F) ||
- (n >= 0x2C00 && n <= 0x2FEF) ||
- (n >= 0x3001 && n <= 0xD7FF) ||
- (n >= 0xF900 && n <= 0xFDCF) ||
- (n >= 0xFDF0 && n <= 0xFFFD)) {
- continue;
- }
- else if (i !== 0 &&
- (n === 45 || n === 46 || // '-' or '.'
- (n >= 48 && n <= 57) || // [0-9]
- (n === 0xB7) ||
- (n >= 0x0300 && n <= 0x036F) ||
- (n >= 0x203F && n <= 0x2040))) {
- continue;
- }
- if (n >= 0xD800 && n <= 0xDBFF && i < name.length - 1) {
- const n2 = name.charCodeAt(i + 1);
- if (n2 >= 0xDC00 && n2 <= 0xDFFF) {
- n = (n - 0xD800) * 0x400 + n2 - 0xDC00 + 0x10000;
- i++;
- if (n >= 0x10000 && n <= 0xEFFFF) {
- continue;
- }
- }
- }
- return false;
- }
- return true;
-}
-/**
- * Determines if the given string is valid for a `"QName"` construct.
- *
- * @param name - name string to test
- */
-function xml_isQName(name) {
- let colonFound = false;
- for (let i = 0; i < name.length; i++) {
- let n = name.charCodeAt(i);
- // NameStartChar
- if ((n >= 97 && n <= 122) || // [a-z]
- (n >= 65 && n <= 90) || // [A-Z]
- n === 95 || // '_'
- (n >= 0xC0 && n <= 0xD6) ||
- (n >= 0xD8 && n <= 0xF6) ||
- (n >= 0xF8 && n <= 0x2FF) ||
- (n >= 0x370 && n <= 0x37D) ||
- (n >= 0x37F && n <= 0x1FFF) ||
- (n >= 0x200C && n <= 0x200D) ||
- (n >= 0x2070 && n <= 0x218F) ||
- (n >= 0x2C00 && n <= 0x2FEF) ||
- (n >= 0x3001 && n <= 0xD7FF) ||
- (n >= 0xF900 && n <= 0xFDCF) ||
- (n >= 0xFDF0 && n <= 0xFFFD)) {
- continue;
- }
- else if (i !== 0 &&
- (n === 45 || n === 46 || // '-' or '.'
- (n >= 48 && n <= 57) || // [0-9]
- (n === 0xB7) ||
- (n >= 0x0300 && n <= 0x036F) ||
- (n >= 0x203F && n <= 0x2040))) {
- continue;
- }
- else if (i !== 0 && n === 58) { // :
- if (colonFound)
- return false; // multiple colons in qname
- if (i === name.length - 1)
- return false; // colon at the end of qname
- colonFound = true;
- continue;
- }
- if (n >= 0xD800 && n <= 0xDBFF && i < name.length - 1) {
- const n2 = name.charCodeAt(i + 1);
- if (n2 >= 0xDC00 && n2 <= 0xDFFF) {
- n = (n - 0xD800) * 0x400 + n2 - 0xDC00 + 0x10000;
- i++;
- if (n >= 0x10000 && n <= 0xEFFFF) {
- continue;
- }
- }
- }
- return false;
- }
- return true;
-}
-/**
- * Determines if the given string contains legal characters.
- *
- * @param chars - sequence of characters to test
- */
-function xml_isLegalChar(chars) {
- for (let i = 0; i < chars.length; i++) {
- let n = chars.charCodeAt(i);
- // #x9 | #xA | #xD | [#x20-#xD7FF] | [#xE000-#xFFFD] | [#x10000-#x10FFFF]
- if (n === 0x9 || n === 0xA || n === 0xD ||
- (n >= 0x20 && n <= 0xD7FF) ||
- (n >= 0xE000 && n <= 0xFFFD)) {
- continue;
- }
- if (n >= 0xD800 && n <= 0xDBFF && i < chars.length - 1) {
- const n2 = chars.charCodeAt(i + 1);
- if (n2 >= 0xDC00 && n2 <= 0xDFFF) {
- n = (n - 0xD800) * 0x400 + n2 - 0xDC00 + 0x10000;
- i++;
- if (n >= 0x10000 && n <= 0x10FFFF) {
- continue;
- }
- }
- }
- return false;
- }
- return true;
-}
-/**
- * Determines if the given string contains legal characters for a public
- * identifier.
- *
- * @param chars - sequence of characters to test
- */
-function xml_isPubidChar(chars) {
- for (let i = 0; i < chars.length; i++) {
- // PubId chars are all in the ASCII range, no need to check surrogates
- const n = chars.charCodeAt(i);
- // #x20 | #xD | #xA | [a-zA-Z0-9] | [-'()+,./:=?;!*#@$_%]
- if ((n >= 97 && n <= 122) || // [a-z]
- (n >= 65 && n <= 90) || // [A-Z]
- (n >= 39 && n <= 59) || // ['()*+,-./] | [0-9] | [:;]
- n === 0x20 || n === 0xD || n === 0xA || // #x20 | #xD | #xA
- (n >= 35 && n <= 37) || // [#$%]
- n === 33 || // !
- n === 61 || n === 63 || n === 64 || n === 95) { // [=?@_]
- continue;
- }
- else {
- return false;
- }
- }
- return true;
-}
-//# sourceMappingURL=XMLAlgorithm.js.map
-
-/***/ }),
-
-/***/ 6573:
-/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
-
-
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
- if (k2 === undefined) k2 = k;
- var desc = Object.getOwnPropertyDescriptor(m, k);
- if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
- desc = { enumerable: true, get: function() { return m[k]; } };
- }
- Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
- if (k2 === undefined) k2 = k;
- o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
- for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-__exportStar(__nccwpck_require__(5878), exports);
-__exportStar(__nccwpck_require__(8365), exports);
-__exportStar(__nccwpck_require__(8652), exports);
-__exportStar(__nccwpck_require__(7785), exports);
-__exportStar(__nccwpck_require__(8308), exports);
-__exportStar(__nccwpck_require__(5075), exports);
-__exportStar(__nccwpck_require__(1327), exports);
-__exportStar(__nccwpck_require__(9484), exports);
-__exportStar(__nccwpck_require__(6827), exports);
-__exportStar(__nccwpck_require__(2720), exports);
-__exportStar(__nccwpck_require__(8012), exports);
-__exportStar(__nccwpck_require__(9807), exports);
-__exportStar(__nccwpck_require__(45), exports);
-__exportStar(__nccwpck_require__(3243), exports);
-__exportStar(__nccwpck_require__(9733), exports);
-__exportStar(__nccwpck_require__(1228), exports);
-__exportStar(__nccwpck_require__(9670), exports);
-__exportStar(__nccwpck_require__(8421), exports);
-__exportStar(__nccwpck_require__(9892), exports);
-__exportStar(__nccwpck_require__(6687), exports);
-__exportStar(__nccwpck_require__(3886), exports);
-__exportStar(__nccwpck_require__(708), exports);
-__exportStar(__nccwpck_require__(3813), exports);
-__exportStar(__nccwpck_require__(6746), exports);
-__exportStar(__nccwpck_require__(3532), exports);
-__exportStar(__nccwpck_require__(6094), exports);
-__exportStar(__nccwpck_require__(4239), exports);
-__exportStar(__nccwpck_require__(6879), exports);
-//# sourceMappingURL=index.js.map
-
-/***/ }),
-
-/***/ 7528:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.AbortControllerImpl = void 0;
-const algorithm_1 = __nccwpck_require__(6573);
-/**
- * Represents a controller that allows to abort DOM requests.
- */
-class AbortControllerImpl {
- _signal;
- /**
- * Initializes a new instance of `AbortController`.
- */
- constructor() {
- /**
- * 1. Let signal be a new AbortSignal object.
- * 2. Let controller be a new AbortController object whose signal is signal.
- * 3. Return controller.
- */
- this._signal = (0, algorithm_1.create_abortSignal)();
- }
- /** @inheritdoc */
- get signal() { return this._signal; }
- /** @inheritdoc */
- abort() {
- (0, algorithm_1.abort_signalAbort)(this._signal);
- }
-}
-exports.AbortControllerImpl = AbortControllerImpl;
-//# sourceMappingURL=AbortControllerImpl.js.map
-
-/***/ }),
-
-/***/ 4560:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.AbortSignalImpl = void 0;
-const EventTargetImpl_1 = __nccwpck_require__(3611);
-const algorithm_1 = __nccwpck_require__(6573);
-/**
- * Represents a signal object that communicates with a DOM request and abort
- * it through an AbortController.
- */
-class AbortSignalImpl extends EventTargetImpl_1.EventTargetImpl {
- _abortedFlag = false;
- _abortAlgorithms = new Set();
- /**
- * Initializes a new instance of `AbortSignal`.
- */
- constructor() {
- super();
- }
- /** @inheritdoc */
- get aborted() { return this._abortedFlag; }
- /** @inheritdoc */
- get onabort() {
- return (0, algorithm_1.event_getterEventHandlerIDLAttribute)(this, "onabort");
- }
- set onabort(val) {
- (0, algorithm_1.event_setterEventHandlerIDLAttribute)(this, "onabort", val);
- }
- /**
- * Creates a new `AbortSignal`.
- */
- static _create() {
- return new AbortSignalImpl();
- }
-}
-exports.AbortSignalImpl = AbortSignalImpl;
-//# sourceMappingURL=AbortSignalImpl.js.map
-
-/***/ }),
-
-/***/ 3773:
-/***/ ((__unused_webpack_module, exports) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.AbstractRangeImpl = void 0;
-/**
- * Represents an abstract range with a start and end boundary point.
- */
-class AbstractRangeImpl {
- get _startNode() { return this._start[0]; }
- get _startOffset() { return this._start[1]; }
- get _endNode() { return this._end[0]; }
- get _endOffset() { return this._end[1]; }
- get _collapsed() {
- return (this._start[0] === this._end[0] &&
- this._start[1] === this._end[1]);
- }
- /** @inheritdoc */
- get startContainer() { return this._startNode; }
- /** @inheritdoc */
- get startOffset() { return this._startOffset; }
- /** @inheritdoc */
- get endContainer() { return this._endNode; }
- /** @inheritdoc */
- get endOffset() { return this._endOffset; }
- /** @inheritdoc */
- get collapsed() { return this._collapsed; }
-}
-exports.AbstractRangeImpl = AbstractRangeImpl;
-//# sourceMappingURL=AbstractRangeImpl.js.map
-
-/***/ }),
-
-/***/ 2875:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.AttrImpl = void 0;
-const interfaces_1 = __nccwpck_require__(9454);
-const NodeImpl_1 = __nccwpck_require__(2280);
-const algorithm_1 = __nccwpck_require__(6573);
-const WebIDLAlgorithm_1 = __nccwpck_require__(4239);
-/**
- * Represents an attribute of an element node.
- */
-class AttrImpl extends NodeImpl_1.NodeImpl {
- _nodeType = interfaces_1.NodeType.Attribute;
- _localName;
- _namespace = null;
- _namespacePrefix = null;
- _element = null;
- _value = '';
- /**
- * Initializes a new instance of `Attr`.
- *
- * @param localName - local name
- */
- constructor(localName) {
- super();
- this._localName = localName;
- }
- /** @inheritdoc */
- specified;
- /** @inheritdoc */
- get ownerElement() { return this._element; }
- /** @inheritdoc */
- get namespaceURI() { return this._namespace; }
- /** @inheritdoc */
- get prefix() { return this._namespacePrefix; }
- /** @inheritdoc */
- get localName() { return this._localName; }
- /** @inheritdoc */
- get name() { return this._qualifiedName; }
- /** @inheritdoc */
- get value() { return this._value; }
- set value(value) {
- /**
- * The value attribute’s setter must set an existing attribute value with
- * context object and the given value.
- */
- (0, algorithm_1.attr_setAnExistingAttributeValue)(this, value);
- }
- /**
- * Returns the qualified name.
- */
- get _qualifiedName() {
- /**
- * An attribute’s qualified name is its local name if its namespace prefix
- * is null, and its namespace prefix, followed by ":", followed by its
- * local name, otherwise.
- */
- return (this._namespacePrefix !== null ?
- this._namespacePrefix + ':' + this._localName :
- this._localName);
- }
- /**
- * Creates an `Attr`.
- *
- * @param document - owner document
- * @param localName - local name
- */
- static _create(document, localName) {
- const node = new AttrImpl(localName);
- node._nodeDocument = document;
- return node;
- }
-}
-exports.AttrImpl = AttrImpl;
-/**
- * Initialize prototype properties
- */
-(0, WebIDLAlgorithm_1.idl_defineConst)(AttrImpl.prototype, "_nodeType", interfaces_1.NodeType.Attribute);
-(0, WebIDLAlgorithm_1.idl_defineConst)(AttrImpl.prototype, "specified", true);
-//# sourceMappingURL=AttrImpl.js.map
-
-/***/ }),
-
-/***/ 4104:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.CDATASectionImpl = void 0;
-const TextImpl_1 = __nccwpck_require__(4063);
-const interfaces_1 = __nccwpck_require__(9454);
-const WebIDLAlgorithm_1 = __nccwpck_require__(4239);
-/**
- * Represents a CDATA node.
- */
-class CDATASectionImpl extends TextImpl_1.TextImpl {
- _nodeType = interfaces_1.NodeType.CData;
- /**
- * Initializes a new instance of `CDATASection`.
- *
- * @param data - node contents
- */
- constructor(data) {
- super(data);
- }
- /**
- * Creates a new `CDATASection`.
- *
- * @param document - owner document
- * @param data - node contents
- */
- static _create(document, data = '') {
- const node = new CDATASectionImpl(data);
- node._nodeDocument = document;
- return node;
- }
-}
-exports.CDATASectionImpl = CDATASectionImpl;
-/**
- * Initialize prototype properties
- */
-(0, WebIDLAlgorithm_1.idl_defineConst)(CDATASectionImpl.prototype, "_nodeType", interfaces_1.NodeType.CData);
-//# sourceMappingURL=CDATASectionImpl.js.map
-
-/***/ }),
-
-/***/ 765:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.CharacterDataImpl = void 0;
-const NodeImpl_1 = __nccwpck_require__(2280);
-const algorithm_1 = __nccwpck_require__(6573);
-/**
- * Represents a generic text node.
- */
-class CharacterDataImpl extends NodeImpl_1.NodeImpl {
- _data;
- /**
- * Initializes a new instance of `CharacterData`.
- *
- * @param data - the text content
- */
- constructor(data) {
- super();
- this._data = data;
- }
- /** @inheritdoc */
- get data() { return this._data; }
- set data(value) {
- (0, algorithm_1.characterData_replaceData)(this, 0, this._data.length, value);
- }
- /** @inheritdoc */
- get length() { return this._data.length; }
- /** @inheritdoc */
- substringData(offset, count) {
- /**
- * The substringData(offset, count) method, when invoked, must return the
- * result of running substring data with node context object, offset offset, and count count.
- */
- return (0, algorithm_1.characterData_substringData)(this, offset, count);
- }
- /** @inheritdoc */
- appendData(data) {
- /**
- * The appendData(data) method, when invoked, must replace data with node
- * context object, offset context object’s length, count 0, and data data.
- */
- return (0, algorithm_1.characterData_replaceData)(this, this._data.length, 0, data);
- }
- /** @inheritdoc */
- insertData(offset, data) {
- /**
- * The insertData(offset, data) method, when invoked, must replace data with
- * node context object, offset offset, count 0, and data data.
- */
- (0, algorithm_1.characterData_replaceData)(this, offset, 0, data);
- }
- /** @inheritdoc */
- deleteData(offset, count) {
- /**
- * The deleteData(offset, count) method, when invoked, must replace data
- * with node context object, offset offset, count count, and data the
- * empty string.
- */
- (0, algorithm_1.characterData_replaceData)(this, offset, count, '');
- }
- /** @inheritdoc */
- replaceData(offset, count, data) {
- /**
- * The replaceData(offset, count, data) method, when invoked, must replace
- * data with node context object, offset offset, count count, and data data.
- */
- (0, algorithm_1.characterData_replaceData)(this, offset, count, data);
- }
- // MIXIN: NonDocumentTypeChildNode
- /* istanbul ignore next */
- get previousElementSibling() { throw new Error("Mixin: NonDocumentTypeChildNode not implemented."); }
- /* istanbul ignore next */
- get nextElementSibling() { throw new Error("Mixin: NonDocumentTypeChildNode not implemented."); }
- // MIXIN: ChildNode
- /* istanbul ignore next */
- before(...nodes) { throw new Error("Mixin: ChildNode not implemented."); }
- /* istanbul ignore next */
- after(...nodes) { throw new Error("Mixin: ChildNode not implemented."); }
- /* istanbul ignore next */
- replaceWith(...nodes) { throw new Error("Mixin: ChildNode not implemented."); }
- /* istanbul ignore next */
- remove() { throw new Error("Mixin: ChildNode not implemented."); }
-}
-exports.CharacterDataImpl = CharacterDataImpl;
-//# sourceMappingURL=CharacterDataImpl.js.map
-
-/***/ }),
-
-/***/ 3728:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.ChildNodeImpl = void 0;
-const util_1 = __nccwpck_require__(8247);
-const algorithm_1 = __nccwpck_require__(6573);
-/**
- * Represents a mixin that extends child nodes that can have siblings
- * including doctypes. This mixin is implemented by {@link Element},
- * {@link CharacterData} and {@link DocumentType}.
- */
-class ChildNodeImpl {
- /** @inheritdoc */
- before(...nodes) {
- /**
- * 1. Let parent be context object’s parent.
- * 2. If parent is null, then return.
- */
- const context = util_1.Cast.asNode(this);
- const parent = context._parent;
- if (parent === null)
- return;
- /**
- * 3. Let viablePreviousSibling be context object’s first preceding
- * sibling not in nodes, and null otherwise.
- */
- let viablePreviousSibling = context._previousSibling;
- let flag = true;
- while (flag && viablePreviousSibling) {
- flag = false;
- for (let i = 0; i < nodes.length; i++) {
- const child = nodes[i];
- if (child === viablePreviousSibling) {
- viablePreviousSibling = viablePreviousSibling._previousSibling;
- flag = true;
- break;
- }
- }
- }
- /**
- * 4. Let node be the result of converting nodes into a node, given nodes
- * and context object’s node document.
- */
- const node = (0, algorithm_1.parentNode_convertNodesIntoANode)(nodes, context._nodeDocument);
- /**
- * 5. If viablePreviousSibling is null, set it to parent’s first child,
- * and to viablePreviousSibling’s next sibling otherwise.
- */
- if (viablePreviousSibling === null)
- viablePreviousSibling = parent._firstChild;
- else
- viablePreviousSibling = viablePreviousSibling._nextSibling;
- /**
- * 6. Pre-insert node into parent before viablePreviousSibling.
- */
- (0, algorithm_1.mutation_preInsert)(node, parent, viablePreviousSibling);
- }
- /** @inheritdoc */
- after(...nodes) {
- /**
- * 1. Let parent be context object’s parent.
- * 2. If parent is null, then return.
- */
- const context = util_1.Cast.asNode(this);
- const parent = context._parent;
- if (!parent)
- return;
- /**
- * 3. Let viableNextSibling be context object’s first following sibling not
- * in nodes, and null otherwise.
- */
- let viableNextSibling = context._nextSibling;
- let flag = true;
- while (flag && viableNextSibling) {
- flag = false;
- for (let i = 0; i < nodes.length; i++) {
- const child = nodes[i];
- if (child === viableNextSibling) {
- viableNextSibling = viableNextSibling._nextSibling;
- flag = true;
- break;
- }
- }
- }
- /**
- * 4. Let node be the result of converting nodes into a node, given nodes
- * and context object’s node document.
- */
- const node = (0, algorithm_1.parentNode_convertNodesIntoANode)(nodes, context._nodeDocument);
- /**
- * 5. Pre-insert node into parent before viableNextSibling.
- */
- (0, algorithm_1.mutation_preInsert)(node, parent, viableNextSibling);
- }
- /** @inheritdoc */
- replaceWith(...nodes) {
- /**
- * 1. Let parent be context object’s parent.
- * 2. If parent is null, then return.
- */
- const context = util_1.Cast.asNode(this);
- const parent = context._parent;
- if (!parent)
- return;
- /**
- * 3. Let viableNextSibling be context object’s first following sibling not
- * in nodes, and null otherwise.
- */
- let viableNextSibling = context._nextSibling;
- let flag = true;
- while (flag && viableNextSibling) {
- flag = false;
- for (let i = 0; i < nodes.length; i++) {
- const child = nodes[i];
- if (child === viableNextSibling) {
- viableNextSibling = viableNextSibling._nextSibling;
- flag = true;
- break;
- }
- }
- }
- /**
- * 4. Let node be the result of converting nodes into a node, given nodes
- * and context object’s node document.
- */
- const node = (0, algorithm_1.parentNode_convertNodesIntoANode)(nodes, context._nodeDocument);
- /**
- * 5. If context object’s parent is parent, replace the context object with
- * node within parent.
- * _Note:_ Context object could have been inserted into node.
- * 6. Otherwise, pre-insert node into parent before viableNextSibling.
- */
- if (context._parent === parent)
- (0, algorithm_1.mutation_replace)(context, node, parent);
- else
- (0, algorithm_1.mutation_preInsert)(node, parent, viableNextSibling);
- }
- /** @inheritdoc */
- remove() {
- /**
- * 1. If context object’s parent is null, then return.
- * 2. Remove the context object from context object’s parent.
- */
- const context = util_1.Cast.asNode(this);
- const parent = context._parent;
- if (!parent)
- return;
- (0, algorithm_1.mutation_remove)(context, parent);
- }
-}
-exports.ChildNodeImpl = ChildNodeImpl;
-//# sourceMappingURL=ChildNodeImpl.js.map
-
-/***/ }),
-
-/***/ 8223:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.CommentImpl = void 0;
-const interfaces_1 = __nccwpck_require__(9454);
-const CharacterDataImpl_1 = __nccwpck_require__(765);
-const WebIDLAlgorithm_1 = __nccwpck_require__(4239);
-/**
- * Represents a comment node.
- */
-class CommentImpl extends CharacterDataImpl_1.CharacterDataImpl {
- _nodeType = interfaces_1.NodeType.Comment;
- /**
- * Initializes a new instance of `Comment`.
- *
- * @param data - the text content
- */
- constructor(data = '') {
- super(data);
- }
- /**
- * Creates a new `Comment`.
- *
- * @param document - owner document
- * @param data - node contents
- */
- static _create(document, data = '') {
- const node = new CommentImpl(data);
- node._nodeDocument = document;
- return node;
- }
-}
-exports.CommentImpl = CommentImpl;
-/**
- * Initialize prototype properties
- */
-(0, WebIDLAlgorithm_1.idl_defineConst)(CommentImpl.prototype, "_nodeType", interfaces_1.NodeType.Comment);
-//# sourceMappingURL=CommentImpl.js.map
-
-/***/ }),
-
-/***/ 3171:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.CustomEventImpl = void 0;
-const EventImpl_1 = __nccwpck_require__(2390);
-const algorithm_1 = __nccwpck_require__(6573);
-/**
- * Represents and event that carries custom data.
- */
-class CustomEventImpl extends EventImpl_1.EventImpl {
- _detail = null;
- /**
- * Initializes a new instance of `CustomEvent`.
- */
- constructor(type, eventInit) {
- super(type, eventInit);
- this._detail = (eventInit && eventInit.detail) || null;
- }
- /** @inheritdoc */
- get detail() { return this._detail; }
- /** @inheritdoc */
- initCustomEvent(type, bubbles = false, cancelable = false, detail = null) {
- /**
- * 1. If the context object’s dispatch flag is set, then return.
- */
- if (this._dispatchFlag)
- return;
- /**
- * 2. Initialize the context object with type, bubbles, and cancelable.
- */
- (0, algorithm_1.event_initialize)(this, type, bubbles, cancelable);
- /**
- * 3. Set the context object’s detail attribute to detail.
- */
- this._detail = detail;
- }
-}
-exports.CustomEventImpl = CustomEventImpl;
-//# sourceMappingURL=CustomEventImpl.js.map
-
-/***/ }),
-
-/***/ 7175:
-/***/ ((__unused_webpack_module, exports) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.InvalidCharacterError = exports.SyntaxError = exports.IndexSizeError = exports.NotFoundError = exports.HierarchyRequestError = exports.NotImplementedError = exports.DataCloneError = exports.InvalidNodeTypeError = exports.TimeoutError = exports.QuotaExceededError = exports.URLMismatchError = exports.AbortError = exports.NetworkError = exports.SecurityError = exports.TypeMismatchError = exports.ValidationError = exports.InvalidAccessError = exports.NamespaceError = exports.InvalidModificationError = exports.InvalidStateError = exports.InUseAttributeError = exports.NotSupportedError = exports.NoModificationAllowedError = exports.NoDataAllowedError = exports.WrongDocumentError = exports.DOMStringSizeError = exports.DOMException = void 0;
-/**
- * Represents the base class of `Error` objects used by this module.
- */
-class DOMException extends Error {
- /**
- * Returns the name of the error message.
- */
- name;
- /**
- *
- * @param name - message name
- * @param message - error message
- */
- constructor(name, message = "") {
- super(message);
- this.name = name;
- }
-}
-exports.DOMException = DOMException;
-class DOMStringSizeError extends DOMException {
- /**
- * @param message - error message
- */
- constructor(message = "") {
- super("DOMStringSizeError", message);
- }
-}
-exports.DOMStringSizeError = DOMStringSizeError;
-class WrongDocumentError extends DOMException {
- /**
- * @param message - error message
- */
- constructor(message = "") {
- super("WrongDocumentError", "The object is in the wrong document. " + message);
- }
-}
-exports.WrongDocumentError = WrongDocumentError;
-class NoDataAllowedError extends DOMException {
- /**
- * @param message - error message
- */
- constructor(message = "") {
- super("NoDataAllowedError", message);
- }
-}
-exports.NoDataAllowedError = NoDataAllowedError;
-class NoModificationAllowedError extends DOMException {
- /**
- * @param message - error message
- */
- constructor(message = "") {
- super("NoModificationAllowedError", "The object can not be modified. " + message);
- }
-}
-exports.NoModificationAllowedError = NoModificationAllowedError;
-class NotSupportedError extends DOMException {
- /**
- * @param message - error message
- */
- constructor(message = "") {
- super("NotSupportedError", "The operation is not supported. " + message);
- }
-}
-exports.NotSupportedError = NotSupportedError;
-class InUseAttributeError extends DOMException {
- /**
- * @param message - error message
- */
- constructor(message = "") {
- super("InUseAttributeError", message);
- }
-}
-exports.InUseAttributeError = InUseAttributeError;
-class InvalidStateError extends DOMException {
- /**
- * @param message - error message
- */
- constructor(message = "") {
- super("InvalidStateError", "The object is in an invalid state. " + message);
- }
-}
-exports.InvalidStateError = InvalidStateError;
-class InvalidModificationError extends DOMException {
- /**
- * @param message - error message
- */
- constructor(message = "") {
- super("InvalidModificationError", "The object can not be modified in this way. " + message);
- }
-}
-exports.InvalidModificationError = InvalidModificationError;
-class NamespaceError extends DOMException {
- /**
- * @param message - error message
- */
- constructor(message = "") {
- super("NamespaceError", "The operation is not allowed by Namespaces in XML. [XMLNS] " + message);
- }
-}
-exports.NamespaceError = NamespaceError;
-class InvalidAccessError extends DOMException {
- /**
- * @param message - error message
- */
- constructor(message = "") {
- super("InvalidAccessError", "The object does not support the operation or argument. " + message);
- }
-}
-exports.InvalidAccessError = InvalidAccessError;
-class ValidationError extends DOMException {
- /**
- * @param message - error message
- */
- constructor(message = "") {
- super("ValidationError", message);
- }
-}
-exports.ValidationError = ValidationError;
-class TypeMismatchError extends DOMException {
- /**
- * @param message - error message
- */
- constructor(message = "") {
- super("TypeMismatchError", message);
- }
-}
-exports.TypeMismatchError = TypeMismatchError;
-class SecurityError extends DOMException {
- /**
- * @param message - error message
- */
- constructor(message = "") {
- super("SecurityError", "The operation is insecure. " + message);
- }
-}
-exports.SecurityError = SecurityError;
-class NetworkError extends DOMException {
- /**
- * @param message - error message
- */
- constructor(message = "") {
- super("NetworkError", "A network error occurred. " + message);
- }
-}
-exports.NetworkError = NetworkError;
-class AbortError extends DOMException {
- /**
- * @param message - error message
- */
- constructor(message = "") {
- super("AbortError", "The operation was aborted. " + message);
- }
-}
-exports.AbortError = AbortError;
-class URLMismatchError extends DOMException {
- /**
- * @param message - error message
- */
- constructor(message = "") {
- super("URLMismatchError", "The given URL does not match another URL. " + message);
- }
-}
-exports.URLMismatchError = URLMismatchError;
-class QuotaExceededError extends DOMException {
- /**
- * @param message - error message
- */
- constructor(message = "") {
- super("QuotaExceededError", "The quota has been exceeded. " + message);
- }
-}
-exports.QuotaExceededError = QuotaExceededError;
-class TimeoutError extends DOMException {
- /**
- * @param message - error message
- */
- constructor(message = "") {
- super("TimeoutError", "The operation timed out. " + message);
- }
-}
-exports.TimeoutError = TimeoutError;
-class InvalidNodeTypeError extends DOMException {
- /**
- * @param message - error message
- */
- constructor(message = "") {
- super("InvalidNodeTypeError", "The supplied node is incorrect or has an incorrect ancestor for this operation. " + message);
- }
-}
-exports.InvalidNodeTypeError = InvalidNodeTypeError;
-class DataCloneError extends DOMException {
- /**
- * @param message - error message
- */
- constructor(message = "") {
- super("DataCloneError", "The object can not be cloned. " + message);
- }
-}
-exports.DataCloneError = DataCloneError;
-class NotImplementedError extends DOMException {
- /**
- * @param message - error message
- */
- constructor(message = "") {
- super("NotImplementedError", "The DOM method is not implemented by this module. " + message);
- }
-}
-exports.NotImplementedError = NotImplementedError;
-class HierarchyRequestError extends DOMException {
- /**
- * @param message - error message
- */
- constructor(message = "") {
- super("HierarchyRequestError", "The operation would yield an incorrect node tree. " + message);
- }
-}
-exports.HierarchyRequestError = HierarchyRequestError;
-class NotFoundError extends DOMException {
- /**
- * @param message - error message
- */
- constructor(message = "") {
- super("NotFoundError", "The object can not be found here. " + message);
- }
-}
-exports.NotFoundError = NotFoundError;
-class IndexSizeError extends DOMException {
- /**
- * @param message - error message
- */
- constructor(message = "") {
- super("IndexSizeError", "The index is not in the allowed range. " + message);
- }
-}
-exports.IndexSizeError = IndexSizeError;
-class SyntaxError extends DOMException {
- /**
- * @param message - error message
- */
- constructor(message = "") {
- super("SyntaxError", "The string did not match the expected pattern. " + message);
- }
-}
-exports.SyntaxError = SyntaxError;
-class InvalidCharacterError extends DOMException {
- /**
- * @param message - error message
- */
- constructor(message = "") {
- super("InvalidCharacterError", "The string contains invalid characters. " + message);
- }
-}
-exports.InvalidCharacterError = InvalidCharacterError;
-//# sourceMappingURL=DOMException.js.map
-
-/***/ }),
-
-/***/ 698:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.dom = void 0;
-const util_1 = __nccwpck_require__(7061);
-const CreateAlgorithm_1 = __nccwpck_require__(8308);
-/**
- * Represents an object implementing DOM algorithms.
- */
-class DOMImpl {
- static _instance;
- _features = {
- mutationObservers: true,
- customElements: true,
- slots: true,
- steps: true
- };
- _window = null;
- _compareCache;
- _rangeList;
- /**
- * Initializes a new instance of `DOM`.
- */
- constructor() {
- this._compareCache = new util_1.CompareCache();
- this._rangeList = new util_1.FixedSizeSet();
- }
- /**
- * Sets DOM algorithm features.
- *
- * @param features - DOM features supported by algorithms. All features are
- * enabled by default unless explicity disabled.
- */
- setFeatures(features) {
- if (features === undefined)
- features = true;
- if ((0, util_1.isObject)(features)) {
- for (const key in features) {
- this._features[key] = features[key] || false;
- }
- }
- else {
- // enable/disable all features
- for (const key in this._features) {
- this._features[key] = features;
- }
- }
- }
- /**
- * Gets DOM algorithm features.
- */
- get features() { return this._features; }
- /**
- * Gets the DOM window.
- */
- get window() {
- if (this._window === null) {
- this._window = (0, CreateAlgorithm_1.create_window)();
- }
- return this._window;
- }
- /**
- * Gets the global node compare cache.
- */
- get compareCache() { return this._compareCache; }
- /**
- * Gets the global range list.
- */
- get rangeList() { return this._rangeList; }
- /**
- * Returns the instance of `DOM`.
- */
- static get instance() {
- if (!DOMImpl._instance) {
- DOMImpl._instance = new DOMImpl();
- }
- return DOMImpl._instance;
- }
-}
-/**
- * Represents an object implementing DOM algorithms.
- */
-exports.dom = DOMImpl.instance;
-//# sourceMappingURL=DOMImpl.js.map
-
-/***/ }),
-
-/***/ 6348:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.DOMImplementationImpl = void 0;
-const DOMImpl_1 = __nccwpck_require__(698);
-const infra_1 = __nccwpck_require__(4737);
-const algorithm_1 = __nccwpck_require__(6573);
-const WebIDLAlgorithm_1 = __nccwpck_require__(4239);
-/**
- * Represents an object providing methods which are not dependent on
- * any particular document.
- */
-class DOMImplementationImpl {
- _ID = "@oozcitak/dom";
- _associatedDocument;
- /**
- * Initializes a new instance of `DOMImplementation`.
- *
- * @param document - the associated document
- */
- constructor(document) {
- this._associatedDocument = document || DOMImpl_1.dom.window.document;
- }
- /** @inheritdoc */
- createDocumentType(qualifiedName, publicId, systemId) {
- /**
- * 1. Validate qualifiedName.
- * 2. Return a new doctype, with qualifiedName as its name, publicId as its
- * public ID, and systemId as its system ID, and with its node document set
- * to the associated document of the context object.
- */
- (0, algorithm_1.namespace_validate)(qualifiedName);
- return (0, algorithm_1.create_documentType)(this._associatedDocument, qualifiedName, publicId, systemId);
- }
- /** @inheritdoc */
- createDocument(namespace, qualifiedName, doctype = null) {
- /**
- * 1. Let document be a new XMLDocument.
- */
- const document = (0, algorithm_1.create_xmlDocument)();
- /**
- * 2. Let element be null.
- * 3. If qualifiedName is not the empty string, then set element to
- * the result of running the internal createElementNS steps, given document,
- * namespace, qualifiedName, and an empty dictionary.
- */
- let element = null;
- if (qualifiedName) {
- element = (0, algorithm_1.document_internalCreateElementNS)(document, namespace, qualifiedName);
- }
- /**
- * 4. If doctype is non-null, append doctype to document.
- * 5. If element is non-null, append element to document.
- */
- if (doctype)
- document.appendChild(doctype);
- if (element)
- document.appendChild(element);
- /**
- * 6. document’s origin is context object’s associated document’s origin.
- */
- document._origin = this._associatedDocument._origin;
- /**
- * 7. document’s content type is determined by namespace:
- * - HTML namespace
- * application/xhtml+xml
- * - SVG namespace
- * image/svg+xml
- * - Any other namespace
- * application/xml
- */
- if (namespace === infra_1.namespace.HTML)
- document._contentType = "application/xhtml+xml";
- else if (namespace === infra_1.namespace.SVG)
- document._contentType = "image/svg+xml";
- else
- document._contentType = "application/xml";
- /**
- * 8. Return document.
- */
- return document;
- }
- /** @inheritdoc */
- createHTMLDocument(title) {
- /**
- * 1. Let doc be a new document that is an HTML document.
- * 2. Set doc’s content type to "text/html".
- */
- const doc = (0, algorithm_1.create_document)();
- doc._type = "html";
- doc._contentType = "text/html";
- /**
- * 3. Append a new doctype, with "html" as its name and with its node
- * document set to doc, to doc.
- */
- doc.appendChild((0, algorithm_1.create_documentType)(doc, "html", "", ""));
- /**
- * 4. Append the result of creating an element given doc, html, and the
- * HTML namespace, to doc.
- */
- const htmlElement = (0, algorithm_1.element_createAnElement)(doc, "html", infra_1.namespace.HTML);
- doc.appendChild(htmlElement);
- /**
- * 5. Append the result of creating an element given doc, head, and the
- * HTML namespace, to the html element created earlier.
- */
- const headElement = (0, algorithm_1.element_createAnElement)(doc, "head", infra_1.namespace.HTML);
- htmlElement.appendChild(headElement);
- /**
- * 6. If title is given:
- * 6.1. Append the result of creating an element given doc, title, and
- * the HTML namespace, to the head element created earlier.
- * 6.2. Append a new Text node, with its data set to title (which could
- * be the empty string) and its node document set to doc, to the title
- * element created earlier.
- */
- if (title !== undefined) {
- const titleElement = (0, algorithm_1.element_createAnElement)(doc, "title", infra_1.namespace.HTML);
- headElement.appendChild(titleElement);
- const textElement = (0, algorithm_1.create_text)(doc, title);
- titleElement.appendChild(textElement);
- }
- /**
- * 7. Append the result of creating an element given doc, body, and the
- * HTML namespace, to the html element created earlier.
- */
- const bodyElement = (0, algorithm_1.element_createAnElement)(doc, "body", infra_1.namespace.HTML);
- htmlElement.appendChild(bodyElement);
- /**
- * 8. doc’s origin is context object’s associated document’s origin.
- */
- doc._origin = this._associatedDocument._origin;
- /**
- * 9. Return doc.
- */
- return doc;
- }
- /** @inheritdoc */
- hasFeature() { return true; }
- /**
- * Creates a new `DOMImplementation`.
- *
- * @param document - owner document
- */
- static _create(document) {
- return new DOMImplementationImpl(document);
- }
-}
-exports.DOMImplementationImpl = DOMImplementationImpl;
-(0, WebIDLAlgorithm_1.idl_defineConst)(DOMImplementationImpl.prototype, "_ID", "@oozcitak/dom");
-//# sourceMappingURL=DOMImplementationImpl.js.map
-
-/***/ }),
-
-/***/ 6629:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.DOMTokenListImpl = void 0;
-const DOMImpl_1 = __nccwpck_require__(698);
-const DOMException_1 = __nccwpck_require__(7175);
-const infra_1 = __nccwpck_require__(4737);
-const algorithm_1 = __nccwpck_require__(6573);
-/**
- * Represents a token set.
- */
-class DOMTokenListImpl {
- _element;
- _attribute;
- _tokenSet;
- /**
- * Initializes a new instance of `DOMTokenList`.
- *
- * @param element - associated element
- * @param attribute - associated attribute
- */
- constructor(element, attribute) {
- /**
- * 1. Let element be associated element.
- * 2. Let localName be associated attribute’s local name.
- * 3. Let value be the result of getting an attribute value given element
- * and localName.
- * 4. Run the attribute change steps for element, localName, value, value,
- * and null.
- */
- this._element = element;
- this._attribute = attribute;
- this._tokenSet = new Set();
- const localName = attribute._localName;
- const value = (0, algorithm_1.element_getAnAttributeValue)(element, localName);
- // define a closure to be called when the associated attribute's value changes
- const thisObj = this;
- function updateTokenSet(element, localName, oldValue, value, namespace) {
- /**
- * 1. If localName is associated attribute’s local name, namespace is null,
- * and value is null, then empty token set.
- * 2. Otherwise, if localName is associated attribute’s local name,
- * namespace is null, then set token set to value, parsed.
- */
- if (localName === thisObj._attribute._localName && namespace === null) {
- if (!value)
- thisObj._tokenSet.clear();
- else
- thisObj._tokenSet = (0, algorithm_1.orderedSet_parse)(value);
- }
- }
- // add the closure to the associated element's attribute change steps
- this._element._attributeChangeSteps.push(updateTokenSet);
- if (DOMImpl_1.dom.features.steps) {
- (0, algorithm_1.dom_runAttributeChangeSteps)(element, localName, value, value, null);
- }
- }
- /** @inheritdoc */
- get length() {
- /**
- * The length attribute' getter must return context object’s token set’s
- * size.
- */
- return this._tokenSet.size;
- }
- /** @inheritdoc */
- item(index) {
- /**
- * 1. If index is equal to or greater than context object’s token set’s
- * size, then return null.
- * 2. Return context object’s token set[index].
- */
- let i = 0;
- for (const token of this._tokenSet) {
- if (i === index)
- return token;
- i++;
- }
- return null;
- }
- /** @inheritdoc */
- contains(token) {
- /**
- * The contains(token) method, when invoked, must return true if context
- * object’s token set[token] exists, and false otherwise.
- */
- return this._tokenSet.has(token);
- }
- /** @inheritdoc */
- add(...tokens) {
- /**
- * 1. For each token in tokens:
- * 1.1. If token is the empty string, then throw a "SyntaxError"
- * DOMException.
- * 1.2. If token contains any ASCII whitespace, then throw an
- * "InvalidCharacterError" DOMException.
- * 2. For each token in tokens, append token to context object’s token set.
- * 3. Run the update steps.
- */
- for (const token of tokens) {
- if (token === '') {
- throw new DOMException_1.SyntaxError("Cannot add an empty token.");
- }
- else if (infra_1.codePoint.ASCIIWhiteSpace.test(token)) {
- throw new DOMException_1.InvalidCharacterError("Token cannot contain whitespace.");
- }
- else {
- this._tokenSet.add(token);
- }
- }
- (0, algorithm_1.tokenList_updateSteps)(this);
- }
- /** @inheritdoc */
- remove(...tokens) {
- /**
- * 1. For each token in tokens:
- * 1.1. If token is the empty string, then throw a "SyntaxError"
- * DOMException.
- * 1.2. If token contains any ASCII whitespace, then throw an
- * "InvalidCharacterError" DOMException.
- * 2. For each token in tokens, remove token from context object’s token set.
- * 3. Run the update steps.
- */
- for (const token of tokens) {
- if (token === '') {
- throw new DOMException_1.SyntaxError("Cannot remove an empty token.");
- }
- else if (infra_1.codePoint.ASCIIWhiteSpace.test(token)) {
- throw new DOMException_1.InvalidCharacterError("Token cannot contain whitespace.");
- }
- else {
- this._tokenSet.delete(token);
- }
- }
- (0, algorithm_1.tokenList_updateSteps)(this);
- }
- /** @inheritdoc */
- toggle(token, force = undefined) {
- /**
- * 1. If token is the empty string, then throw a "SyntaxError" DOMException.
- * 2. If token contains any ASCII whitespace, then throw an
- * "InvalidCharacterError" DOMException.
- */
- if (token === '') {
- throw new DOMException_1.SyntaxError("Cannot toggle an empty token.");
- }
- else if (infra_1.codePoint.ASCIIWhiteSpace.test(token)) {
- throw new DOMException_1.InvalidCharacterError("Token cannot contain whitespace.");
- }
- /**
- * 3. If context object’s token set[token] exists, then:
- */
- if (this._tokenSet.has(token)) {
- /**
- * 3.1. If force is either not given or is false, then remove token from
- * context object’s token set, run the update steps and return false.
- * 3.2. Return true.
- */
- if (force === undefined || force === false) {
- this._tokenSet.delete(token);
- (0, algorithm_1.tokenList_updateSteps)(this);
- return false;
- }
- return true;
- }
- /**
- * 4. Otherwise, if force not given or is true, append token to context
- * object’s token set, run the update steps, and return true.
- */
- if (force === undefined || force === true) {
- this._tokenSet.add(token);
- (0, algorithm_1.tokenList_updateSteps)(this);
- return true;
- }
- /**
- * 5. Return false.
- */
- return false;
- }
- /** @inheritdoc */
- replace(token, newToken) {
- /**
- * 1. If either token or newToken is the empty string, then throw a
- * "SyntaxError" DOMException.
- * 2. If either token or newToken contains any ASCII whitespace, then throw
- * an "InvalidCharacterError" DOMException.
- */
- if (token === '' || newToken === '') {
- throw new DOMException_1.SyntaxError("Cannot replace an empty token.");
- }
- else if (infra_1.codePoint.ASCIIWhiteSpace.test(token) || infra_1.codePoint.ASCIIWhiteSpace.test(newToken)) {
- throw new DOMException_1.InvalidCharacterError("Token cannot contain whitespace.");
- }
- /**
- * 3. If context object’s token set does not contain token, then return
- * false.
- */
- if (!this._tokenSet.has(token))
- return false;
- /**
- * 4. Replace token in context object’s token set with newToken.
- * 5. Run the update steps.
- * 6. Return true.
- */
- infra_1.set.replace(this._tokenSet, token, newToken);
- (0, algorithm_1.tokenList_updateSteps)(this);
- return true;
- }
- /** @inheritdoc */
- supports(token) {
- /**
- * 1. Let result be the return value of validation steps called with token.
- * 2. Return result.
- */
- return (0, algorithm_1.tokenList_validationSteps)(this, token);
- }
- /** @inheritdoc */
- get value() {
- /**
- * The value attribute must return the result of running context object’s
- * serialize steps.
- */
- return (0, algorithm_1.tokenList_serializeSteps)(this);
- }
- set value(value) {
- /**
- * Setting the value attribute must set an attribute value for the
- * associated element using associated attribute’s local name and the given
- * value.
- */
- (0, algorithm_1.element_setAnAttributeValue)(this._element, this._attribute._localName, value);
- }
- /**
- * Returns an iterator for the token set.
- */
- [Symbol.iterator]() {
- const it = this._tokenSet[Symbol.iterator]();
- return {
- next() {
- return it.next();
- }
- };
- }
- /**
- * Creates a new `DOMTokenList`.
- *
- * @param element - associated element
- * @param attribute - associated attribute
- */
- static _create(element, attribute) {
- return new DOMTokenListImpl(element, attribute);
- }
-}
-exports.DOMTokenListImpl = DOMTokenListImpl;
-//# sourceMappingURL=DOMTokenListImpl.js.map
-
-/***/ }),
-
-/***/ 9793:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.DocumentFragmentImpl = void 0;
-const interfaces_1 = __nccwpck_require__(9454);
-const NodeImpl_1 = __nccwpck_require__(2280);
-const WebIDLAlgorithm_1 = __nccwpck_require__(4239);
-/**
- * Represents a document fragment in the XML tree.
- */
-class DocumentFragmentImpl extends NodeImpl_1.NodeImpl {
- _nodeType = interfaces_1.NodeType.DocumentFragment;
- _children = new Set();
- _host;
- /**
- * Initializes a new instance of `DocumentFragment`.
- *
- * @param host - shadow root's host element
- */
- constructor(host = null) {
- super();
- this._host = host;
- }
- // MIXIN: NonElementParentNode
- /* istanbul ignore next */
- getElementById(elementId) { throw new Error("Mixin: NonElementParentNode not implemented."); }
- // MIXIN: ParentNode
- /* istanbul ignore next */
- get children() { throw new Error("Mixin: ParentNode not implemented."); }
- /* istanbul ignore next */
- get firstElementChild() { throw new Error("Mixin: ParentNode not implemented."); }
- /* istanbul ignore next */
- get lastElementChild() { throw new Error("Mixin: ParentNode not implemented."); }
- /* istanbul ignore next */
- get childElementCount() { throw new Error("Mixin: ParentNode not implemented."); }
- /* istanbul ignore next */
- prepend(...nodes) { throw new Error("Mixin: ParentNode not implemented."); }
- /* istanbul ignore next */
- append(...nodes) { throw new Error("Mixin: ParentNode not implemented."); }
- /* istanbul ignore next */
- querySelector(selectors) { throw new Error("Mixin: ParentNode not implemented."); }
- /* istanbul ignore next */
- querySelectorAll(selectors) { throw new Error("Mixin: ParentNode not implemented."); }
- /**
- * Creates a new `DocumentFragment`.
- *
- * @param document - owner document
- * @param host - shadow root's host element
- */
- static _create(document, host = null) {
- const node = new DocumentFragmentImpl(host);
- node._nodeDocument = document;
- return node;
- }
-}
-exports.DocumentFragmentImpl = DocumentFragmentImpl;
-/**
- * Initialize prototype properties
- */
-(0, WebIDLAlgorithm_1.idl_defineConst)(DocumentFragmentImpl.prototype, "_nodeType", interfaces_1.NodeType.DocumentFragment);
-//# sourceMappingURL=DocumentFragmentImpl.js.map
-
-/***/ }),
-
-/***/ 2113:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.DocumentImpl = void 0;
-const DOMImpl_1 = __nccwpck_require__(698);
-const interfaces_1 = __nccwpck_require__(9454);
-const DOMException_1 = __nccwpck_require__(7175);
-const NodeImpl_1 = __nccwpck_require__(2280);
-const util_1 = __nccwpck_require__(8247);
-const util_2 = __nccwpck_require__(7061);
-const infra_1 = __nccwpck_require__(4737);
-const URLAlgorithm_1 = __nccwpck_require__(3650);
-const algorithm_1 = __nccwpck_require__(6573);
-const WebIDLAlgorithm_1 = __nccwpck_require__(4239);
-/**
- * Represents a document node.
- */
-class DocumentImpl extends NodeImpl_1.NodeImpl {
- _nodeType = interfaces_1.NodeType.Document;
- _children = new Set();
- _encoding = {
- name: "UTF-8",
- labels: ["unicode-1-1-utf-8", "utf-8", "utf8"]
- };
- _contentType = 'application/xml';
- _URL = {
- scheme: "about",
- username: "",
- password: "",
- host: null,
- port: null,
- path: ["blank"],
- query: null,
- fragment: null,
- _cannotBeABaseURLFlag: true,
- _blobURLEntry: null
- };
- _origin = null;
- _type = "xml";
- _mode = "no-quirks";
- _implementation;
- _documentElement = null;
- _hasNamespaces = false;
- _nodeDocumentOverwrite = null;
- get _nodeDocument() { return this._nodeDocumentOverwrite || this; }
- set _nodeDocument(val) { this._nodeDocumentOverwrite = val; }
- /**
- * Initializes a new instance of `Document`.
- */
- constructor() {
- super();
- }
- /** @inheritdoc */
- get implementation() {
- /**
- * The implementation attribute’s getter must return the DOMImplementation
- * object that is associated with the document.
- */
- return this._implementation || (this._implementation = (0, algorithm_1.create_domImplementation)(this));
- }
- /** @inheritdoc */
- get URL() {
- /**
- * The URL attribute’s getter and documentURI attribute’s getter must return
- * the URL, serialized.
- * See: https://url.spec.whatwg.org/#concept-url-serializer
- */
- return (0, URLAlgorithm_1.urlSerializer)(this._URL);
- }
- /** @inheritdoc */
- get documentURI() { return this.URL; }
- /** @inheritdoc */
- get origin() {
- return "null";
- }
- /** @inheritdoc */
- get compatMode() {
- /**
- * The compatMode attribute’s getter must return "BackCompat" if context
- * object’s mode is "quirks", and "CSS1Compat" otherwise.
- */
- return this._mode === "quirks" ? "BackCompat" : "CSS1Compat";
- }
- /** @inheritdoc */
- get characterSet() {
- /**
- * The characterSet attribute’s getter, charset attribute’s getter, and
- * inputEncoding attribute’s getter, must return context object’s
- * encoding’s name.
- */
- return this._encoding.name;
- }
- /** @inheritdoc */
- get charset() { return this._encoding.name; }
- /** @inheritdoc */
- get inputEncoding() { return this._encoding.name; }
- /** @inheritdoc */
- get contentType() {
- /**
- * The contentType attribute’s getter must return the content type.
- */
- return this._contentType;
- }
- /** @inheritdoc */
- get doctype() {
- /**
- * The doctype attribute’s getter must return the child of the document
- * that is a doctype, and null otherwise.
- */
- for (const child of this._children) {
- if (util_1.Guard.isDocumentTypeNode(child))
- return child;
- }
- return null;
- }
- /** @inheritdoc */
- get documentElement() {
- /**
- * The documentElement attribute’s getter must return the document element.
- */
- return this._documentElement;
- }
- /** @inheritdoc */
- getElementsByTagName(qualifiedName) {
- /**
- * The getElementsByTagName(qualifiedName) method, when invoked, must return
- * the list of elements with qualified name qualifiedName for the context object.
- */
- return (0, algorithm_1.node_listOfElementsWithQualifiedName)(qualifiedName, this);
- }
- /** @inheritdoc */
- getElementsByTagNameNS(namespace, localName) {
- /**
- * The getElementsByTagNameNS(namespace, localName) method, when invoked,
- * must return the list of elements with namespace namespace and local name
- * localName for the context object.
- */
- return (0, algorithm_1.node_listOfElementsWithNamespace)(namespace, localName, this);
- }
- /** @inheritdoc */
- getElementsByClassName(classNames) {
- /**
- * The getElementsByClassName(classNames) method, when invoked, must return
- * the list of elements with class names classNames for the context object.
- */
- return (0, algorithm_1.node_listOfElementsWithClassNames)(classNames, this);
- }
- /** @inheritdoc */
- createElement(localName, options) {
- /**
- * 1. If localName does not match the Name production, then throw an
- * "InvalidCharacterError" DOMException.
- * 2. If the context object is an HTML document, then set localName to
- * localName in ASCII lowercase.
- * 3. Let is be null.
- * 4. If options is a dictionary and options’s is is present, then set is
- * to it.
- * 5. Let namespace be the HTML namespace, if the context object is an
- * HTML document or context object’s content type is
- * "application/xhtml+xml", and null otherwise.
- * 6. Return the result of creating an element given the context object,
- * localName, namespace, null, is, and with the synchronous custom elements
- * flag set.
- */
- if (!(0, algorithm_1.xml_isName)(localName))
- throw new DOMException_1.InvalidCharacterError();
- if (this._type === "html")
- localName = localName.toLowerCase();
- let is = null;
- if (options !== undefined) {
- if ((0, util_2.isString)(options)) {
- is = options;
- }
- else {
- is = options.is;
- }
- }
- const namespace = (this._type === "html" || this._contentType === "application/xhtml+xml") ?
- infra_1.namespace.HTML : null;
- return (0, algorithm_1.element_createAnElement)(this, localName, namespace, null, is, true);
- }
- /** @inheritdoc */
- createElementNS(namespace, qualifiedName, options) {
- /**
- * The createElementNS(namespace, qualifiedName, options) method, when
- * invoked, must return the result of running the internal createElementNS
- * steps, given context object, namespace, qualifiedName, and options.
- */
- return (0, algorithm_1.document_internalCreateElementNS)(this, namespace, qualifiedName, options);
- }
- /** @inheritdoc */
- createDocumentFragment() {
- /**
- * The createDocumentFragment() method, when invoked, must return a new
- * DocumentFragment node with its node document set to the context object.
- */
- return (0, algorithm_1.create_documentFragment)(this);
- }
- /** @inheritdoc */
- createTextNode(data) {
- /**
- * The createTextNode(data) method, when invoked, must return a new Text
- * node with its data set to data and node document set to the context object.
- */
- return (0, algorithm_1.create_text)(this, data);
- }
- /** @inheritdoc */
- createCDATASection(data) {
- /**
- * 1. If context object is an HTML document, then throw a
- * "NotSupportedError" DOMException.
- * 2. If data contains the string "]]>", then throw an
- * "InvalidCharacterError" DOMException.
- * 3. Return a new CDATASection node with its data set to data and node
- * document set to the context object.
- */
- if (this._type === "html")
- throw new DOMException_1.NotSupportedError();
- if (data.indexOf(']]>') !== -1)
- throw new DOMException_1.InvalidCharacterError();
- return (0, algorithm_1.create_cdataSection)(this, data);
- }
- /** @inheritdoc */
- createComment(data) {
- /**
- * The createComment(data) method, when invoked, must return a new Comment
- * node with its data set to data and node document set to the context object.
- */
- return (0, algorithm_1.create_comment)(this, data);
- }
- /** @inheritdoc */
- createProcessingInstruction(target, data) {
- /**
- * 1. If target does not match the Name production, then throw an
- * "InvalidCharacterError" DOMException.
- * 2. If data contains the string "?>", then throw an
- * "InvalidCharacterError" DOMException.
- * 3. Return a new ProcessingInstruction node, with target set to target,
- * data set to data, and node document set to the context object.
- */
- if (!(0, algorithm_1.xml_isName)(target))
- throw new DOMException_1.InvalidCharacterError();
- if (data.indexOf("?>") !== -1)
- throw new DOMException_1.InvalidCharacterError();
- return (0, algorithm_1.create_processingInstruction)(this, target, data);
- }
- /** @inheritdoc */
- importNode(node, deep = false) {
- /**
- * 1. If node is a document or shadow root, then throw a "NotSupportedError" DOMException.
- */
- if (util_1.Guard.isDocumentNode(node) || util_1.Guard.isShadowRoot(node))
- throw new DOMException_1.NotSupportedError();
- /**
- * 2. Return a clone of node, with context object and the clone children flag set if deep is true.
- */
- return (0, algorithm_1.node_clone)(node, this, deep);
- }
- /** @inheritdoc */
- adoptNode(node) {
- /**
- * 1. If node is a document, then throw a "NotSupportedError" DOMException.
- */
- if (util_1.Guard.isDocumentNode(node))
- throw new DOMException_1.NotSupportedError();
- /**
- * 2. If node is a shadow root, then throw a "HierarchyRequestError" DOMException.
- */
- if (util_1.Guard.isShadowRoot(node))
- throw new DOMException_1.HierarchyRequestError();
- /**
- * 3. Adopt node into the context object.
- * 4. Return node.
- */
- (0, algorithm_1.document_adopt)(node, this);
- return node;
- }
- /** @inheritdoc */
- createAttribute(localName) {
- /**
- * 1. If localName does not match the Name production in XML, then throw
- * an "InvalidCharacterError" DOMException.
- * 2. If the context object is an HTML document, then set localName to
- * localName in ASCII lowercase.
- * 3. Return a new attribute whose local name is localName and node document
- * is context object.
- */
- if (!(0, algorithm_1.xml_isName)(localName))
- throw new DOMException_1.InvalidCharacterError();
- if (this._type === "html") {
- localName = localName.toLowerCase();
- }
- const attr = (0, algorithm_1.create_attr)(this, localName);
- return attr;
- }
- /** @inheritdoc */
- createAttributeNS(namespace, qualifiedName) {
- /**
- * 1. Let namespace, prefix, and localName be the result of passing
- * namespace and qualifiedName to validate and extract.
- * 2. Return a new attribute whose namespace is namespace, namespace prefix
- * is prefix, local name is localName, and node document is context object.
- */
- const [ns, prefix, localName] = (0, algorithm_1.namespace_validateAndExtract)(namespace, qualifiedName);
- const attr = (0, algorithm_1.create_attr)(this, localName);
- attr._namespace = ns;
- attr._namespacePrefix = prefix;
- return attr;
- }
- /** @inheritdoc */
- createEvent(eventInterface) {
- return (0, algorithm_1.event_createLegacyEvent)(eventInterface);
- }
- /** @inheritdoc */
- createRange() {
- /**
- * The createRange() method, when invoked, must return a new live range
- * with (context object, 0) as its start and end.
- */
- const range = (0, algorithm_1.create_range)();
- range._start = [this, 0];
- range._end = [this, 0];
- return range;
- }
- /** @inheritdoc */
- createNodeIterator(root, whatToShow = interfaces_1.WhatToShow.All, filter = null) {
- /**
- * 1. Let iterator be a new NodeIterator object.
- * 2. Set iterator’s root and iterator’s reference to root.
- * 3. Set iterator’s pointer before reference to true.
- * 4. Set iterator’s whatToShow to whatToShow.
- * 5. Set iterator’s filter to filter.
- * 6. Return iterator.
- */
- const iterator = (0, algorithm_1.create_nodeIterator)(root, root, true);
- iterator._whatToShow = whatToShow;
- iterator._iteratorCollection = (0, algorithm_1.create_nodeList)(root);
- if ((0, util_2.isFunction)(filter)) {
- iterator._filter = (0, algorithm_1.create_nodeFilter)();
- iterator._filter.acceptNode = filter;
- }
- else {
- iterator._filter = filter;
- }
- return iterator;
- }
- /** @inheritdoc */
- createTreeWalker(root, whatToShow = interfaces_1.WhatToShow.All, filter = null) {
- /**
- * 1. Let walker be a new TreeWalker object.
- * 2. Set walker’s root and walker’s current to root.
- * 3. Set walker’s whatToShow to whatToShow.
- * 4. Set walker’s filter to filter.
- * 5. Return walker.
- */
- const walker = (0, algorithm_1.create_treeWalker)(root, root);
- walker._whatToShow = whatToShow;
- if ((0, util_2.isFunction)(filter)) {
- walker._filter = (0, algorithm_1.create_nodeFilter)();
- walker._filter.acceptNode = filter;
- }
- else {
- walker._filter = filter;
- }
- return walker;
- }
- /**
- * Gets the parent event target for the given event.
- *
- * @param event - an event
- */
- _getTheParent(event) {
- /**
- * TODO: Implement realms
- * A document’s get the parent algorithm, given an event, returns null if
- * event’s type attribute value is "load" or document does not have a
- * browsing context, and the document’s relevant global object otherwise.
- */
- if (event._type === "load") {
- return null;
- }
- else {
- return DOMImpl_1.dom.window;
- }
- }
- // MIXIN: NonElementParentNode
- /* istanbul ignore next */
- getElementById(elementId) { throw new Error("Mixin: NonElementParentNode not implemented."); }
- // MIXIN: DocumentOrShadowRoot
- // No elements
- // MIXIN: ParentNode
- /* istanbul ignore next */
- get children() { throw new Error("Mixin: ParentNode not implemented."); }
- /* istanbul ignore next */
- get firstElementChild() { throw new Error("Mixin: ParentNode not implemented."); }
- /* istanbul ignore next */
- get lastElementChild() { throw new Error("Mixin: ParentNode not implemented."); }
- /* istanbul ignore next */
- get childElementCount() { throw new Error("Mixin: ParentNode not implemented."); }
- /* istanbul ignore next */
- prepend(...nodes) { throw new Error("Mixin: ParentNode not implemented."); }
- /* istanbul ignore next */
- append(...nodes) { throw new Error("Mixin: ParentNode not implemented."); }
- /* istanbul ignore next */
- querySelector(selectors) { throw new Error("Mixin: ParentNode not implemented."); }
- /* istanbul ignore next */
- querySelectorAll(selectors) { throw new Error("Mixin: ParentNode not implemented."); }
-}
-exports.DocumentImpl = DocumentImpl;
-/**
- * Initialize prototype properties
- */
-(0, WebIDLAlgorithm_1.idl_defineConst)(DocumentImpl.prototype, "_nodeType", interfaces_1.NodeType.Document);
-//# sourceMappingURL=DocumentImpl.js.map
-
-/***/ }),
-
-/***/ 8024:
-/***/ ((__unused_webpack_module, exports) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.DocumentOrShadowRootImpl = void 0;
-/**
- * Represents a mixin for an interface to be used to share APIs between
- * documents and shadow roots. This mixin is implemented by
- * {@link Document} and {@link ShadowRoot}.
- *
- * _Note:_ The DocumentOrShadowRoot mixin is expected to be used by other
- * standards that want to define APIs shared between documents and shadow roots.
- */
-class DocumentOrShadowRootImpl {
-}
-exports.DocumentOrShadowRootImpl = DocumentOrShadowRootImpl;
-//# sourceMappingURL=DocumentOrShadowRootImpl.js.map
-
-/***/ }),
-
-/***/ 1401:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.DocumentTypeImpl = void 0;
-const interfaces_1 = __nccwpck_require__(9454);
-const NodeImpl_1 = __nccwpck_require__(2280);
-const WebIDLAlgorithm_1 = __nccwpck_require__(4239);
-/**
- * Represents an object providing methods which are not dependent on
- * any particular document
- */
-class DocumentTypeImpl extends NodeImpl_1.NodeImpl {
- _nodeType = interfaces_1.NodeType.DocumentType;
- _name = '';
- _publicId = '';
- _systemId = '';
- /**
- * Initializes a new instance of `DocumentType`.
- *
- * @param name - name of the node
- * @param publicId - `PUBLIC` identifier
- * @param systemId - `SYSTEM` identifier
- */
- constructor(name, publicId, systemId) {
- super();
- this._name = name;
- this._publicId = publicId;
- this._systemId = systemId;
- }
- /** @inheritdoc */
- get name() { return this._name; }
- /** @inheritdoc */
- get publicId() { return this._publicId; }
- /** @inheritdoc */
- get systemId() { return this._systemId; }
- // MIXIN: ChildNode
- /* istanbul ignore next */
- before(...nodes) { throw new Error("Mixin: ChildNode not implemented."); }
- /* istanbul ignore next */
- after(...nodes) { throw new Error("Mixin: ChildNode not implemented."); }
- /* istanbul ignore next */
- replaceWith(...nodes) { throw new Error("Mixin: ChildNode not implemented."); }
- /* istanbul ignore next */
- remove() { throw new Error("Mixin: ChildNode not implemented."); }
- /**
- * Creates a new `DocumentType`.
- *
- * @param document - owner document
- * @param name - name of the node
- * @param publicId - `PUBLIC` identifier
- * @param systemId - `SYSTEM` identifier
- */
- static _create(document, name, publicId = '', systemId = '') {
- const node = new DocumentTypeImpl(name, publicId, systemId);
- node._nodeDocument = document;
- return node;
- }
-}
-exports.DocumentTypeImpl = DocumentTypeImpl;
-/**
- * Initialize prototype properties
- */
-(0, WebIDLAlgorithm_1.idl_defineConst)(DocumentTypeImpl.prototype, "_nodeType", interfaces_1.NodeType.DocumentType);
-//# sourceMappingURL=DocumentTypeImpl.js.map
-
-/***/ }),
-
-/***/ 1342:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.ElementImpl = void 0;
-const interfaces_1 = __nccwpck_require__(9454);
-const NodeImpl_1 = __nccwpck_require__(2280);
-const DOMException_1 = __nccwpck_require__(7175);
-const infra_1 = __nccwpck_require__(4737);
-const algorithm_1 = __nccwpck_require__(6573);
-const WebIDLAlgorithm_1 = __nccwpck_require__(4239);
-/**
- * Represents an element node.
- */
-class ElementImpl extends NodeImpl_1.NodeImpl {
- _nodeType = interfaces_1.NodeType.Element;
- _children = new Set();
- _namespace = null;
- _namespacePrefix = null;
- _localName = "";
- _customElementState = "undefined";
- _customElementDefinition = null;
- _is = null;
- _shadowRoot = null;
- _attributeList = (0, algorithm_1.create_namedNodeMap)(this);
- _uniqueIdentifier;
- _attributeChangeSteps = [];
- _name = '';
- _assignedSlot = null;
- /**
- * Initializes a new instance of `Element`.
- */
- constructor() {
- super();
- }
- /** @inheritdoc */
- get namespaceURI() { return this._namespace; }
- /** @inheritdoc */
- get prefix() { return this._namespacePrefix; }
- /** @inheritdoc */
- get localName() { return this._localName; }
- /** @inheritdoc */
- get tagName() { return this._htmlUppercasedQualifiedName; }
- /** @inheritdoc */
- get id() {
- return (0, algorithm_1.element_getAnAttributeValue)(this, "id");
- }
- set id(value) {
- (0, algorithm_1.element_setAnAttributeValue)(this, "id", value);
- }
- /** @inheritdoc */
- get className() {
- return (0, algorithm_1.element_getAnAttributeValue)(this, "class");
- }
- set className(value) {
- (0, algorithm_1.element_setAnAttributeValue)(this, "class", value);
- }
- /** @inheritdoc */
- get classList() {
- let attr = (0, algorithm_1.element_getAnAttributeByName)("class", this);
- if (attr === null) {
- attr = (0, algorithm_1.create_attr)(this._nodeDocument, "class");
- }
- return (0, algorithm_1.create_domTokenList)(this, attr);
- }
- /** @inheritdoc */
- get slot() {
- return (0, algorithm_1.element_getAnAttributeValue)(this, "slot");
- }
- set slot(value) {
- (0, algorithm_1.element_setAnAttributeValue)(this, "slot", value);
- }
- /** @inheritdoc */
- hasAttributes() {
- return this._attributeList.length !== 0;
- }
- /** @inheritdoc */
- get attributes() { return this._attributeList; }
- /** @inheritdoc */
- getAttributeNames() {
- /**
- * The getAttributeNames() method, when invoked, must return the qualified
- * names of the attributes in context object’s attribute list, in order,
- * and a new list otherwise.
- */
- const names = [];
- for (const attr of this._attributeList) {
- names.push(attr._qualifiedName);
- }
- return names;
- }
- /** @inheritdoc */
- getAttribute(qualifiedName) {
- /**
- * 1. Let attr be the result of getting an attribute given qualifiedName
- * and the context object.
- * 2. If attr is null, return null.
- * 3. Return attr’s value.
- */
- const attr = (0, algorithm_1.element_getAnAttributeByName)(qualifiedName, this);
- return (attr ? attr._value : null);
- }
- /** @inheritdoc */
- getAttributeNS(namespace, localName) {
- /**
- * 1. Let attr be the result of getting an attribute given namespace,
- * localName, and the context object.
- * 2. If attr is null, return null.
- * 3. Return attr’s value.
- */
- const attr = (0, algorithm_1.element_getAnAttributeByNamespaceAndLocalName)(namespace, localName, this);
- return (attr ? attr._value : null);
- }
- /** @inheritdoc */
- setAttribute(qualifiedName, value) {
- /**
- * 1. If qualifiedName does not match the Name production in XML, then
- * throw an "InvalidCharacterError" DOMException.
- */
- if (!(0, algorithm_1.xml_isName)(qualifiedName))
- throw new DOMException_1.InvalidCharacterError();
- /**
- * 2. If the context object is in the HTML namespace and its node document
- * is an HTML document, then set qualifiedName to qualifiedName in ASCII
- * lowercase.
- */
- if (this._namespace === infra_1.namespace.HTML && this._nodeDocument._type === "html") {
- qualifiedName = qualifiedName.toLowerCase();
- }
- /**
- * 3. Let attribute be the first attribute in context object’s attribute
- * list whose qualified name is qualifiedName, and null otherwise.
- */
- let attribute = null;
- for (let i = 0; i < this._attributeList.length; i++) {
- const attr = this._attributeList[i];
- if (attr._qualifiedName === qualifiedName) {
- attribute = attr;
- break;
- }
- }
- /**
- * 4. If attribute is null, create an attribute whose local name is
- * qualifiedName, value is value, and node document is context object’s
- * node document, then append this attribute to context object, and
- * then return.
- */
- if (attribute === null) {
- attribute = (0, algorithm_1.create_attr)(this._nodeDocument, qualifiedName);
- attribute._value = value;
- (0, algorithm_1.element_append)(attribute, this);
- return;
- }
- /**
- * 5. Change attribute from context object to value.
- */
- (0, algorithm_1.element_change)(attribute, this, value);
- }
- /** @inheritdoc */
- setAttributeNS(namespace, qualifiedName, value) {
- /**
- * 1. Let namespace, prefix, and localName be the result of passing
- * namespace and qualifiedName to validate and extract.
- * 2. Set an attribute value for the context object using localName, value,
- * and also prefix and namespace.
- */
- const [ns, prefix, localName] = (0, algorithm_1.namespace_validateAndExtract)(namespace, qualifiedName);
- (0, algorithm_1.element_setAnAttributeValue)(this, localName, value, prefix, ns);
- }
- /** @inheritdoc */
- removeAttribute(qualifiedName) {
- /**
- * The removeAttribute(qualifiedName) method, when invoked, must remove an
- * attribute given qualifiedName and the context object, and then return
- * undefined.
- */
- (0, algorithm_1.element_removeAnAttributeByName)(qualifiedName, this);
- }
- /** @inheritdoc */
- removeAttributeNS(namespace, localName) {
- /**
- * The removeAttributeNS(namespace, localName) method, when invoked, must
- * remove an attribute given namespace, localName, and context object, and
- * then return undefined.
- */
- (0, algorithm_1.element_removeAnAttributeByNamespaceAndLocalName)(namespace, localName, this);
- }
- /** @inheritdoc */
- hasAttribute(qualifiedName) {
- /**
- * 1. If the context object is in the HTML namespace and its node document
- * is an HTML document, then set qualifiedName to qualifiedName in ASCII
- * lowercase.
- * 2. Return true if the context object has an attribute whose qualified
- * name is qualifiedName, and false otherwise.
- */
- if (this._namespace === infra_1.namespace.HTML && this._nodeDocument._type === "html") {
- qualifiedName = qualifiedName.toLowerCase();
- }
- for (let i = 0; i < this._attributeList.length; i++) {
- const attr = this._attributeList[i];
- if (attr._qualifiedName === qualifiedName) {
- return true;
- }
- }
- return false;
- }
- /** @inheritdoc */
- toggleAttribute(qualifiedName, force) {
- /**
- * 1. If qualifiedName does not match the Name production in XML, then
- * throw an "InvalidCharacterError" DOMException.
- */
- if (!(0, algorithm_1.xml_isName)(qualifiedName))
- throw new DOMException_1.InvalidCharacterError();
- /**
- * 2. If the context object is in the HTML namespace and its node document
- * is an HTML document, then set qualifiedName to qualifiedName in ASCII
- * lowercase.
- */
- if (this._namespace === infra_1.namespace.HTML && this._nodeDocument._type === "html") {
- qualifiedName = qualifiedName.toLowerCase();
- }
- /**
- * 3. Let attribute be the first attribute in the context object’s attribute
- * list whose qualified name is qualifiedName, and null otherwise.
- */
- let attribute = null;
- for (let i = 0; i < this._attributeList.length; i++) {
- const attr = this._attributeList[i];
- if (attr._qualifiedName === qualifiedName) {
- attribute = attr;
- break;
- }
- }
- if (attribute === null) {
- /**
- * 4. If attribute is null, then:
- * 4.1. If force is not given or is true, create an attribute whose local
- * name is qualifiedName, value is the empty string, and node document is
- * the context object’s node document, then append this attribute to the
- * context object, and then return true.
- * 4.2. Return false.
- */
- if (force === undefined || force === true) {
- attribute = (0, algorithm_1.create_attr)(this._nodeDocument, qualifiedName);
- attribute._value = '';
- (0, algorithm_1.element_append)(attribute, this);
- return true;
- }
- return false;
- }
- else if (force === undefined || force === false) {
- /**
- * 5. Otherwise, if force is not given or is false, remove an attribute
- * given qualifiedName and the context object, and then return false.
- */
- (0, algorithm_1.element_removeAnAttributeByName)(qualifiedName, this);
- return false;
- }
- /**
- * 6. Return true.
- */
- return true;
- }
- /** @inheritdoc */
- hasAttributeNS(namespace, localName) {
- /**
- * 1. If namespace is the empty string, set it to null.
- * 2. Return true if the context object has an attribute whose namespace is
- * namespace and local name is localName, and false otherwise.
- */
- const ns = namespace || null;
- for (let i = 0; i < this._attributeList.length; i++) {
- const attr = this._attributeList[i];
- if (attr._namespace === ns && attr._localName === localName) {
- return true;
- }
- }
- return false;
- }
- /** @inheritdoc */
- getAttributeNode(qualifiedName) {
- /**
- * The getAttributeNode(qualifiedName) method, when invoked, must return the
- * result of getting an attribute given qualifiedName and context object.
- */
- return (0, algorithm_1.element_getAnAttributeByName)(qualifiedName, this);
- }
- /** @inheritdoc */
- getAttributeNodeNS(namespace, localName) {
- /**
- * The getAttributeNodeNS(namespace, localName) method, when invoked, must
- * return the result of getting an attribute given namespace, localName, and
- * the context object.
- */
- return (0, algorithm_1.element_getAnAttributeByNamespaceAndLocalName)(namespace, localName, this);
- }
- /** @inheritdoc */
- setAttributeNode(attr) {
- /**
- * The setAttributeNode(attr) and setAttributeNodeNS(attr) methods, when
- * invoked, must return the result of setting an attribute given attr and
- * the context object.
- */
- return (0, algorithm_1.element_setAnAttribute)(attr, this);
- }
- /** @inheritdoc */
- setAttributeNodeNS(attr) {
- return (0, algorithm_1.element_setAnAttribute)(attr, this);
- }
- /** @inheritdoc */
- removeAttributeNode(attr) {
- /**
- * 1. If context object’s attribute list does not contain attr, then throw
- * a "NotFoundError" DOMException.
- * 2. Remove attr from context object.
- * 3. Return attr.
- */
- let found = false;
- for (let i = 0; i < this._attributeList.length; i++) {
- const attribute = this._attributeList[i];
- if (attribute === attr) {
- found = true;
- break;
- }
- }
- if (!found)
- throw new DOMException_1.NotFoundError();
- (0, algorithm_1.element_remove)(attr, this);
- return attr;
- }
- /** @inheritdoc */
- attachShadow(init) {
- /**
- * 1. If context object’s namespace is not the HTML namespace, then throw a
- * "NotSupportedError" DOMException.
- */
- if (this._namespace !== infra_1.namespace.HTML)
- throw new DOMException_1.NotSupportedError();
- /**
- * 2. If context object’s local name is not a valid custom element name,
- * "article", "aside", "blockquote", "body", "div", "footer", "h1", "h2",
- * "h3", "h4", "h5", "h6", "header", "main" "nav", "p", "section",
- * or "span", then throw a "NotSupportedError" DOMException.
- */
- if (!(0, algorithm_1.customElement_isValidCustomElementName)(this._localName) &&
- !(0, algorithm_1.customElement_isValidShadowHostName)(this._localName))
- throw new DOMException_1.NotSupportedError();
- /**
- * 3. If context object’s local name is a valid custom element name,
- * or context object’s is value is not null, then:
- * 3.1. Let definition be the result of looking up a custom element
- * definition given context object’s node document, its namespace, its
- * local name, and its is value.
- * 3.2. If definition is not null and definition’s disable shadow is true,
- * then throw a "NotSupportedError" DOMException.
- */
- if ((0, algorithm_1.customElement_isValidCustomElementName)(this._localName) || this._is !== null) {
- const definition = (0, algorithm_1.customElement_lookUpACustomElementDefinition)(this._nodeDocument, this._namespace, this._localName, this._is);
- if (definition !== null && definition.disableShadow === true) {
- throw new DOMException_1.NotSupportedError();
- }
- }
- /**
- * 4. If context object is a shadow host, then throw an "NotSupportedError"
- * DOMException.
- */
- if (this._shadowRoot !== null)
- throw new DOMException_1.NotSupportedError();
- /**
- * 5. Let shadow be a new shadow root whose node document is context
- * object’s node document, host is context object, and mode is init’s mode.
- * 6. Set context object’s shadow root to shadow.
- * 7. Return shadow.
- */
- const shadow = (0, algorithm_1.create_shadowRoot)(this._nodeDocument, this);
- shadow._mode = init.mode;
- this._shadowRoot = shadow;
- return shadow;
- }
- /** @inheritdoc */
- get shadowRoot() {
- /**
- * 1. Let shadow be context object’s shadow root.
- * 2. If shadow is null or its mode is "closed", then return null.
- * 3. Return shadow.
- */
- const shadow = this._shadowRoot;
- if (shadow === null || shadow.mode === "closed")
- return null;
- else
- return shadow;
- }
- /** @inheritdoc */
- closest(selectors) {
- /**
- * TODO: Selectors
- * 1. Let s be the result of parse a selector from selectors. [SELECTORS4]
- * 2. If s is failure, throw a "SyntaxError" DOMException.
- * 3. Let elements be context object’s inclusive ancestors that are
- * elements, in reverse tree order.
- * 4. For each element in elements, if match a selector against an element,
- * using s, element, and :scope element context object, returns success,
- * return element. [SELECTORS4]
- * 5. Return null.
- */
- throw new DOMException_1.NotImplementedError();
- }
- /** @inheritdoc */
- matches(selectors) {
- /**
- * TODO: Selectors
- * 1. Let s be the result of parse a selector from selectors. [SELECTORS4]
- * 2. If s is failure, throw a "SyntaxError" DOMException.
- * 3. Return true if the result of match a selector against an element,
- * using s, element, and :scope element context object, returns success,
- * and false otherwise. [SELECTORS4]
- */
- throw new DOMException_1.NotImplementedError();
- }
- /** @inheritdoc */
- webkitMatchesSelector(selectors) {
- return this.matches(selectors);
- }
- /** @inheritdoc */
- getElementsByTagName(qualifiedName) {
- /**
- * The getElementsByTagName(qualifiedName) method, when invoked, must return
- * the list of elements with qualified name qualifiedName for context
- * object.
- */
- return (0, algorithm_1.node_listOfElementsWithQualifiedName)(qualifiedName, this);
- }
- /** @inheritdoc */
- getElementsByTagNameNS(namespace, localName) {
- /**
- * The getElementsByTagNameNS(namespace, localName) method, when invoked,
- * must return the list of elements with namespace namespace and local name
- * localName for context object.
- */
- return (0, algorithm_1.node_listOfElementsWithNamespace)(namespace, localName, this);
- }
- /** @inheritdoc */
- getElementsByClassName(classNames) {
- /**
- * The getElementsByClassName(classNames) method, when invoked, must return
- * the list of elements with class names classNames for context object.
- */
- return (0, algorithm_1.node_listOfElementsWithClassNames)(classNames, this);
- }
- /** @inheritdoc */
- insertAdjacentElement(where, element) {
- /**
- * The insertAdjacentElement(where, element) method, when invoked, must
- * return the result of running insert adjacent, given context object,
- * where, and element.
- */
- return (0, algorithm_1.element_insertAdjacent)(this, where, element);
- }
- /** @inheritdoc */
- insertAdjacentText(where, data) {
- /**
- * 1. Let text be a new Text node whose data is data and node document is
- * context object’s node document.
- * 2. Run insert adjacent, given context object, where, and text.
- */
- const text = (0, algorithm_1.create_text)(this._nodeDocument, data);
- (0, algorithm_1.element_insertAdjacent)(this, where, text);
- }
- /**
- * Returns the qualified name.
- */
- get _qualifiedName() {
- /**
- * An element’s qualified name is its local name if its namespace prefix is
- * null, and its namespace prefix, followed by ":", followed by its
- * local name, otherwise.
- */
- return (this._namespacePrefix ?
- this._namespacePrefix + ':' + this._localName :
- this._localName);
- }
- /**
- * Returns the upper-cased qualified name for a html element.
- */
- get _htmlUppercasedQualifiedName() {
- /**
- * 1. Let qualifiedName be context object’s qualified name.
- * 2. If the context object is in the HTML namespace and its node document
- * is an HTML document, then set qualifiedName to qualifiedName in ASCII
- * uppercase.
- * 3. Return qualifiedName.
- */
- let qualifiedName = this._qualifiedName;
- if (this._namespace === infra_1.namespace.HTML && this._nodeDocument._type === "html") {
- qualifiedName = qualifiedName.toUpperCase();
- }
- return qualifiedName;
- }
- // MIXIN: ParentNode
- /* istanbul ignore next */
- get children() { throw new Error("Mixin: ParentNode not implemented."); }
- /* istanbul ignore next */
- get firstElementChild() { throw new Error("Mixin: ParentNode not implemented."); }
- /* istanbul ignore next */
- get lastElementChild() { throw new Error("Mixin: ParentNode not implemented."); }
- /* istanbul ignore next */
- get childElementCount() { throw new Error("Mixin: ParentNode not implemented."); }
- /* istanbul ignore next */
- prepend(...nodes) { throw new Error("Mixin: ParentNode not implemented."); }
- /* istanbul ignore next */
- append(...nodes) { throw new Error("Mixin: ParentNode not implemented."); }
- /* istanbul ignore next */
- querySelector(selectors) { throw new Error("Mixin: ParentNode not implemented."); }
- /* istanbul ignore next */
- querySelectorAll(selectors) { throw new Error("Mixin: ParentNode not implemented."); }
- // MIXIN: NonDocumentTypeChildNode
- /* istanbul ignore next */
- get previousElementSibling() { throw new Error("Mixin: NonDocumentTypeChildNode not implemented."); }
- /* istanbul ignore next */
- get nextElementSibling() { throw new Error("Mixin: NonDocumentTypeChildNode not implemented."); }
- // MIXIN: ChildNode
- /* istanbul ignore next */
- before(...nodes) { throw new Error("Mixin: ChildNode not implemented."); }
- /* istanbul ignore next */
- after(...nodes) { throw new Error("Mixin: ChildNode not implemented."); }
- /* istanbul ignore next */
- replaceWith(...nodes) { throw new Error("Mixin: ChildNode not implemented."); }
- /* istanbul ignore next */
- remove() { throw new Error("Mixin: ChildNode not implemented."); }
- // MIXIN: Slotable
- /* istanbul ignore next */
- get assignedSlot() { throw new Error("Mixin: Slotable not implemented."); }
- /**
- * Creates a new `Element`.
- *
- * @param document - owner document
- * @param localName - local name
- * @param namespace - namespace
- * @param prefix - namespace prefix
- */
- static _create(document, localName, namespace = null, namespacePrefix = null) {
- const node = new ElementImpl();
- node._localName = localName;
- node._namespace = namespace;
- node._namespacePrefix = namespacePrefix;
- node._nodeDocument = document;
- return node;
- }
-}
-exports.ElementImpl = ElementImpl;
-/**
- * Initialize prototype properties
- */
-(0, WebIDLAlgorithm_1.idl_defineConst)(ElementImpl.prototype, "_nodeType", interfaces_1.NodeType.Element);
-//# sourceMappingURL=ElementImpl.js.map
-
-/***/ }),
-
-/***/ 2390:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.EventImpl = void 0;
-const interfaces_1 = __nccwpck_require__(9454);
-const algorithm_1 = __nccwpck_require__(6573);
-const WebIDLAlgorithm_1 = __nccwpck_require__(4239);
-/**
- * Represents a DOM event.
- */
-class EventImpl {
- static NONE = 0;
- static CAPTURING_PHASE = 1;
- static AT_TARGET = 2;
- static BUBBLING_PHASE = 3;
- NONE = 0;
- CAPTURING_PHASE = 1;
- AT_TARGET = 2;
- BUBBLING_PHASE = 3;
- _target = null;
- _relatedTarget = null;
- _touchTargetList = [];
- _path = [];
- _currentTarget = null;
- _eventPhase = interfaces_1.EventPhase.None;
- _stopPropagationFlag = false;
- _stopImmediatePropagationFlag = false;
- _canceledFlag = false;
- _inPassiveListenerFlag = false;
- _composedFlag = false;
- _initializedFlag = false;
- _dispatchFlag = false;
- _isTrusted = false;
- _type;
- _bubbles = false;
- _cancelable = false;
- _timeStamp;
- /**
- * Initializes a new instance of `Event`.
- */
- constructor(type, eventInit) {
- /**
- * When a constructor of the Event interface, or of an interface that
- * inherits from the Event interface, is invoked, these steps must be run,
- * given the arguments type and eventInitDict:
- * 1. Let event be the result of running the inner event creation steps with
- * this interface, null, now, and eventInitDict.
- * 2. Initialize event’s type attribute to type.
- * 3. Return event.
- */
- this._type = type;
- if (eventInit) {
- this._bubbles = eventInit.bubbles || false;
- this._cancelable = eventInit.cancelable || false;
- this._composedFlag = eventInit.composed || false;
- }
- this._initializedFlag = true;
- this._timeStamp = new Date().getTime();
- }
- /** @inheritdoc */
- get type() { return this._type; }
- /** @inheritdoc */
- get target() { return this._target; }
- /** @inheritdoc */
- get srcElement() { return this._target; }
- /** @inheritdoc */
- get currentTarget() { return this._currentTarget; }
- /** @inheritdoc */
- composedPath() {
- /**
- * 1. Let composedPath be an empty list.
- * 2. Let path be the context object’s path.
- * 3. If path is empty, then return composedPath.
- * 4. Let currentTarget be the context object’s currentTarget attribute
- * value.
- * 5. Append currentTarget to composedPath.
- * 6. Let currentTargetIndex be 0.
- * 7. Let currentTargetHiddenSubtreeLevel be 0.
- */
- const composedPath = [];
- const path = this._path;
- if (path.length === 0)
- return composedPath;
- const currentTarget = this._currentTarget;
- if (currentTarget === null) {
- throw new Error("Event currentTarget is null.");
- }
- composedPath.push(currentTarget);
- let currentTargetIndex = 0;
- let currentTargetHiddenSubtreeLevel = 0;
- /**
- * 8. Let index be path’s size − 1.
- * 9. While index is greater than or equal to 0:
- */
- let index = path.length - 1;
- while (index >= 0) {
- /**
- * 9.1. If path[index]'s root-of-closed-tree is true, then increase
- * currentTargetHiddenSubtreeLevel by 1.
- * 9.2. If path[index]'s invocation target is currentTarget, then set
- * currentTargetIndex to index and break.
- * 9.3. If path[index]'s slot-in-closed-tree is true, then decrease
- * currentTargetHiddenSubtreeLevel by 1.
- * 9.4. Decrease index by 1.
- */
- if (path[index].rootOfClosedTree) {
- currentTargetHiddenSubtreeLevel++;
- }
- if (path[index].invocationTarget === currentTarget) {
- currentTargetIndex = index;
- break;
- }
- if (path[index].slotInClosedTree) {
- currentTargetHiddenSubtreeLevel--;
- }
- index--;
- }
- /**
- * 10. Let currentHiddenLevel and maxHiddenLevel be
- * currentTargetHiddenSubtreeLevel.
- */
- let currentHiddenLevel = currentTargetHiddenSubtreeLevel;
- let maxHiddenLevel = currentTargetHiddenSubtreeLevel;
- /**
- * 11. Set index to currentTargetIndex − 1.
- * 12. While index is greater than or equal to 0:
- */
- index = currentTargetIndex - 1;
- while (index >= 0) {
- /**
- * 12.1. If path[index]'s root-of-closed-tree is true, then increase
- * currentHiddenLevel by 1.
- * 12.2. If currentHiddenLevel is less than or equal to maxHiddenLevel,
- * then prepend path[index]'s invocation target to composedPath.
- */
- if (path[index].rootOfClosedTree) {
- currentHiddenLevel++;
- }
- if (currentHiddenLevel <= maxHiddenLevel) {
- composedPath.unshift(path[index].invocationTarget);
- }
- /**
- * 12.3. If path[index]'s slot-in-closed-tree is true, then:
- */
- if (path[index].slotInClosedTree) {
- /**
- * 12.3.1. Decrease currentHiddenLevel by 1.
- * 12.3.2. If currentHiddenLevel is less than maxHiddenLevel, then set
- * maxHiddenLevel to currentHiddenLevel.
- */
- currentHiddenLevel--;
- if (currentHiddenLevel < maxHiddenLevel) {
- maxHiddenLevel = currentHiddenLevel;
- }
- }
- /**
- * 12.4. Decrease index by 1.
- */
- index--;
- }
- /**
- * 13. Set currentHiddenLevel and maxHiddenLevel to
- * currentTargetHiddenSubtreeLevel.
- */
- currentHiddenLevel = currentTargetHiddenSubtreeLevel;
- maxHiddenLevel = currentTargetHiddenSubtreeLevel;
- /**
- * 14. Set index to currentTargetIndex + 1.
- * 15. While index is less than path’s size:
- */
- index = currentTargetIndex + 1;
- while (index < path.length) {
- /**
- * 15.1. If path[index]'s slot-in-closed-tree is true, then increase
- * currentHiddenLevel by 1.
- * 15.2. If currentHiddenLevel is less than or equal to maxHiddenLevel,
- * then append path[index]'s invocation target to composedPath.
- */
- if (path[index].slotInClosedTree) {
- currentHiddenLevel++;
- }
- if (currentHiddenLevel <= maxHiddenLevel) {
- composedPath.push(path[index].invocationTarget);
- }
- /**
- * 15.3. If path[index]'s root-of-closed-tree is true, then:
- */
- if (path[index].rootOfClosedTree) {
- /**
- * 15.3.1. Decrease currentHiddenLevel by 1.
- * 15.3.2. If currentHiddenLevel is less than maxHiddenLevel, then set
- * maxHiddenLevel to currentHiddenLevel.
- */
- currentHiddenLevel--;
- if (currentHiddenLevel < maxHiddenLevel) {
- maxHiddenLevel = currentHiddenLevel;
- }
- }
- /**
- * 15.4. Increase index by 1.
- */
- index++;
- }
- /**
- * 16. Return composedPath.
- */
- return composedPath;
- }
- /** @inheritdoc */
- get eventPhase() { return this._eventPhase; }
- /** @inheritdoc */
- stopPropagation() { this._stopPropagationFlag = true; }
- /** @inheritdoc */
- get cancelBubble() { return this._stopPropagationFlag; }
- set cancelBubble(value) { if (value)
- this.stopPropagation(); }
- /** @inheritdoc */
- stopImmediatePropagation() {
- this._stopPropagationFlag = true;
- this._stopImmediatePropagationFlag = true;
- }
- /** @inheritdoc */
- get bubbles() { return this._bubbles; }
- /** @inheritdoc */
- get cancelable() { return this._cancelable; }
- /** @inheritdoc */
- get returnValue() { return !this._canceledFlag; }
- set returnValue(value) {
- if (!value) {
- (0, algorithm_1.event_setTheCanceledFlag)(this);
- }
- }
- /** @inheritdoc */
- preventDefault() {
- (0, algorithm_1.event_setTheCanceledFlag)(this);
- }
- /** @inheritdoc */
- get defaultPrevented() { return this._canceledFlag; }
- /** @inheritdoc */
- get composed() { return this._composedFlag; }
- /** @inheritdoc */
- get isTrusted() { return this._isTrusted; }
- /** @inheritdoc */
- get timeStamp() { return this._timeStamp; }
- /** @inheritdoc */
- initEvent(type, bubbles = false, cancelable = false) {
- /**
- * 1. If the context object’s dispatch flag is set, then return.
- */
- if (this._dispatchFlag)
- return;
- /**
- * 2. Initialize the context object with type, bubbles, and cancelable.
- */
- (0, algorithm_1.event_initialize)(this, type, bubbles, cancelable);
- }
-}
-exports.EventImpl = EventImpl;
-/**
- * Define constants on prototype.
- */
-(0, WebIDLAlgorithm_1.idl_defineConst)(EventImpl.prototype, "NONE", 0);
-(0, WebIDLAlgorithm_1.idl_defineConst)(EventImpl.prototype, "CAPTURING_PHASE", 1);
-(0, WebIDLAlgorithm_1.idl_defineConst)(EventImpl.prototype, "AT_TARGET", 2);
-(0, WebIDLAlgorithm_1.idl_defineConst)(EventImpl.prototype, "BUBBLING_PHASE", 3);
-//# sourceMappingURL=EventImpl.js.map
-
-/***/ }),
-
-/***/ 3611:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.EventTargetImpl = void 0;
-const DOMException_1 = __nccwpck_require__(7175);
-const util_1 = __nccwpck_require__(8247);
-const algorithm_1 = __nccwpck_require__(6573);
-/**
- * Represents a target to which an event can be dispatched.
- */
-class EventTargetImpl {
- __eventListenerList;
- get _eventListenerList() {
- return this.__eventListenerList || (this.__eventListenerList = []);
- }
- __eventHandlerMap;
- get _eventHandlerMap() {
- return this.__eventHandlerMap || (this.__eventHandlerMap = {});
- }
- /**
- * Initializes a new instance of `EventTarget`.
- */
- constructor() { }
- /** @inheritdoc */
- addEventListener(type, callback, options = { passive: false, once: false, capture: false }) {
- /**
- * 1. Let capture, passive, and once be the result of flattening more options.
- */
- const [capture, passive, once] = (0, algorithm_1.eventTarget_flattenMore)(options);
- // convert callback function to EventListener, return if null
- let listenerCallback;
- if (!callback) {
- return;
- }
- else if (util_1.Guard.isEventListener(callback)) {
- listenerCallback = callback;
- }
- else {
- listenerCallback = { handleEvent: callback };
- }
- /**
- * 2. Add an event listener with the context object and an event listener
- * whose type is type, callback is callback, capture is capture, passive is
- * passive, and once is once.
- */
- (0, algorithm_1.eventTarget_addEventListener)(this, {
- type: type,
- callback: listenerCallback,
- capture: capture,
- passive: passive,
- once: once,
- removed: false
- });
- }
- /** @inheritdoc */
- removeEventListener(type, callback, options = { capture: false }) {
- /**
- * TODO: Implement realms
- * 1. If the context object’s relevant global object is a
- * ServiceWorkerGlobalScope object and its associated service worker’s
- * script resource’s has ever been evaluated flag is set, then throw
- * a TypeError. [SERVICE-WORKERS]
- */
- /**
- * 2. Let capture be the result of flattening options.
- */
- const capture = (0, algorithm_1.eventTarget_flatten)(options);
- if (!callback)
- return;
- /**
- * 3. If the context object’s event listener list contains an event listener
- * whose type is type, callback is callback, and capture is capture, then
- * remove an event listener with the context object and that event listener.
- */
- for (let i = 0; i < this._eventListenerList.length; i++) {
- const entry = this._eventListenerList[i];
- if (entry.type !== type || entry.capture !== capture)
- continue;
- if (util_1.Guard.isEventListener(callback) && entry.callback === callback) {
- (0, algorithm_1.eventTarget_removeEventListener)(this, entry, i);
- break;
- }
- else if (callback && entry.callback.handleEvent === callback) {
- (0, algorithm_1.eventTarget_removeEventListener)(this, entry, i);
- break;
- }
- }
- }
- /** @inheritdoc */
- dispatchEvent(event) {
- /**
- * 1. If event’s dispatch flag is set, or if its initialized flag is not
- * set, then throw an "InvalidStateError" DOMException.
- * 2. Initialize event’s isTrusted attribute to false.
- * 3. Return the result of dispatching event to the context object.
- */
- if (event._dispatchFlag || !event._initializedFlag) {
- throw new DOMException_1.InvalidStateError();
- }
- event._isTrusted = false;
- return (0, algorithm_1.event_dispatch)(event, this);
- }
- /** @inheritdoc */
- _getTheParent(event) {
- return null;
- }
-}
-exports.EventTargetImpl = EventTargetImpl;
-//# sourceMappingURL=EventTargetImpl.js.map
-
-/***/ }),
-
-/***/ 9065:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.HTMLCollectionImpl = void 0;
-const infra_1 = __nccwpck_require__(4737);
-const algorithm_1 = __nccwpck_require__(6573);
-const util_1 = __nccwpck_require__(8247);
-const util_2 = __nccwpck_require__(7061);
-/**
- * Represents a collection of elements.
- */
-class HTMLCollectionImpl {
- _live = true;
- _root;
- _filter;
- static reservedNames = ['_root', '_live', '_filter', 'length',
- 'item', 'namedItem', 'get', 'set'];
- /**
- * Initializes a new instance of `HTMLCollection`.
- *
- * @param root - root node
- * @param filter - node filter
- */
- constructor(root, filter) {
- this._root = root;
- this._filter = filter;
- return new Proxy(this, this);
- }
- /** @inheritdoc */
- get length() {
- /**
- * The length attribute’s getter must return the number of nodes
- * represented by the collection.
- */
- let count = 0;
- let node = (0, algorithm_1.tree_getFirstDescendantNode)(this._root, false, false, (e) => util_1.Guard.isElementNode(e) && this._filter(e));
- while (node !== null) {
- count++;
- node = (0, algorithm_1.tree_getNextDescendantNode)(this._root, node, false, false, (e) => util_1.Guard.isElementNode(e) && this._filter(e));
- }
- return count;
- }
- /** @inheritdoc */
- item(index) {
- /**
- * The item(index) method, when invoked, must return the indexth element
- * in the collection. If there is no indexth element in the collection,
- * then the method must return null.
- */
- let i = 0;
- let node = (0, algorithm_1.tree_getFirstDescendantNode)(this._root, false, false, (e) => util_1.Guard.isElementNode(e) && this._filter(e));
- while (node !== null) {
- if (i === index)
- return node;
- else
- i++;
- node = (0, algorithm_1.tree_getNextDescendantNode)(this._root, node, false, false, (e) => util_1.Guard.isElementNode(e) && this._filter(e));
- }
- return null;
- }
- /** @inheritdoc */
- namedItem(key) {
- /**
- * 1. If key is the empty string, return null.
- * 2. Return the first element in the collection for which at least one of
- * the following is true:
- * - it has an ID which is key;
- * - it is in the HTML namespace and has a name attribute whose value is key;
- * or null if there is no such element.
- */
- if (key === '')
- return null;
- let ele = (0, algorithm_1.tree_getFirstDescendantNode)(this._root, false, false, (e) => util_1.Guard.isElementNode(e) && this._filter(e));
- while (ele != null) {
- if (ele._uniqueIdentifier === key) {
- return ele;
- }
- else if (ele._namespace === infra_1.namespace.HTML) {
- for (let i = 0; i < ele._attributeList.length; i++) {
- const attr = ele._attributeList[i];
- if (attr._localName === "name" && attr._namespace === null &&
- attr._namespacePrefix === null && attr._value === key)
- return ele;
- }
- }
- ele = (0, algorithm_1.tree_getNextDescendantNode)(this._root, ele, false, false, (e) => util_1.Guard.isElementNode(e) && this._filter(e));
- }
- return null;
- }
- /** @inheritdoc */
- [Symbol.iterator]() {
- const root = this._root;
- const filter = this._filter;
- let currentNode = (0, algorithm_1.tree_getFirstDescendantNode)(root, false, false, (e) => util_1.Guard.isElementNode(e) && filter(e));
- return {
- next() {
- if (currentNode === null) {
- return { done: true, value: null };
- }
- else {
- const result = { done: false, value: currentNode };
- currentNode = (0, algorithm_1.tree_getNextDescendantNode)(root, currentNode, false, false, (e) => util_1.Guard.isElementNode(e) && filter(e));
- return result;
- }
- }
- };
- }
- /**
- * Implements a proxy get trap to provide array-like access.
- */
- get(target, key, receiver) {
- if (!(0, util_2.isString)(key) || HTMLCollectionImpl.reservedNames.indexOf(key) !== -1) {
- return Reflect.get(target, key, receiver);
- }
- const index = Number(key);
- if (isNaN(index)) {
- return target.namedItem(key) || undefined;
- }
- else {
- return target.item(index) || undefined;
- }
- }
- /**
- * Implements a proxy set trap to provide array-like access.
- */
- set(target, key, value, receiver) {
- if (!(0, util_2.isString)(key) || HTMLCollectionImpl.reservedNames.indexOf(key) !== -1) {
- return Reflect.set(target, key, value, receiver);
- }
- const index = Number(key);
- const node = isNaN(index) ?
- target.namedItem(key) || undefined : target.item(index) || undefined;
- if (node && node._parent) {
- (0, algorithm_1.mutation_replace)(node, value, node._parent);
- return true;
- }
- else {
- return false;
- }
- }
- /**
- * Creates a new `HTMLCollection`.
- *
- * @param root - root node
- * @param filter - node filter
- */
- static _create(root, filter = (() => true)) {
- return new HTMLCollectionImpl(root, filter);
- }
-}
-exports.HTMLCollectionImpl = HTMLCollectionImpl;
-//# sourceMappingURL=HTMLCollectionImpl.js.map
-
-/***/ }),
-
-/***/ 9137:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.MutationObserverImpl = void 0;
-const DOMImpl_1 = __nccwpck_require__(698);
-const util_1 = __nccwpck_require__(8247);
-const infra_1 = __nccwpck_require__(4737);
-/**
- * Represents an object that can be used to observe mutations to the tree of
- * nodes.
- */
-class MutationObserverImpl {
- _callback;
- _nodeList = [];
- _recordQueue = [];
- /**
- * Initializes a new instance of `MutationObserver`.
- *
- * @param callback - the callback function
- */
- constructor(callback) {
- /**
- * 1. Let mo be a new MutationObserver object whose callback is callback.
- * 2. Append mo to mo’s relevant agent’s mutation observers.
- * 3. Return mo.
- */
- this._callback = callback;
- const window = DOMImpl_1.dom.window;
- infra_1.set.append(window._mutationObservers, this);
- }
- /** @inheritdoc */
- observe(target, options) {
- options = options || {
- childList: false,
- subtree: false
- };
- /**
- * 1. If either options’s attributeOldValue or attributeFilter is present
- * and options’s attributes is omitted, then set options’s attributes
- * to true.
- * 2. If options’s characterDataOldValue is present and options’s
- * characterData is omitted, then set options’s characterData to true.
- * 3. If none of options’s childList, attributes, and characterData is
- * true, then throw a TypeError.
- * 4. If options’s attributeOldValue is true and options’s attributes is
- * false, then throw a TypeError.
- * 5. If options’s attributeFilter is present and options’s attributes is
- * false, then throw a TypeError.
- * 6. If options’s characterDataOldValue is true and options’s characterData
- * is false, then throw a TypeError.
- */
- if ((options.attributeOldValue !== undefined || options.attributeFilter !== undefined) &&
- options.attributes === undefined) {
- options.attributes = true;
- }
- if (options.characterDataOldValue !== undefined && options.characterData === undefined) {
- options.characterData = true;
- }
- if (!options.childList && !options.attributes && !options.characterData) {
- throw new TypeError();
- }
- if (options.attributeOldValue && !options.attributes) {
- throw new TypeError();
- }
- if (options.attributeFilter !== undefined && !options.attributes) {
- throw new TypeError();
- }
- if (options.characterDataOldValue && !options.characterData) {
- throw new TypeError();
- }
- /**
- * 7. For each registered of target’s registered observer list, if
- * registered’s observer is the context object:
- */
- let isRegistered = false;
- const coptions = options;
- for (const registered of target._registeredObserverList) {
- if (registered.observer === this) {
- isRegistered = true;
- /**
- * 7.1. For each node of the context object’s node list, remove all
- * transient registered observers whose source is registered from node’s
- * registered observer list.
- */
- for (const node of this._nodeList) {
- infra_1.list.remove(node._registeredObserverList, (ob) => util_1.Guard.isTransientRegisteredObserver(ob) && ob.source === registered);
- }
- /**
- * 7.2. Set registered’s options to options.
- */
- registered.options = coptions;
- }
- }
- /**
- * 8. Otherwise:
- * 8.1. Append a new registered observer whose observer is the context
- * object and options is options to target’s registered observer list.
- * 8.2. Append target to the context object’s node list.
- */
- if (!isRegistered) {
- target._registeredObserverList.push({ observer: this, options: options });
- this._nodeList.push(target);
- }
- }
- /** @inheritdoc */
- disconnect() {
- /**
- * 1. For each node of the context object’s node list, remove any
- * registered observer from node’s registered observer list for which the
- * context object is the observer.
- */
- for (const node of this._nodeList) {
- infra_1.list.remove((node)._registeredObserverList, (ob) => ob.observer === this);
- }
- /**
- * 2. Empty the context object’s record queue.
- */
- this._recordQueue = [];
- }
- /** @inheritdoc */
- takeRecords() {
- /**
- * 1. Let records be a clone of the context object’s record queue.
- * 2. Empty the context object’s record queue.
- * 3. Return records.
- */
- const records = this._recordQueue;
- this._recordQueue = [];
- return records;
- }
-}
-exports.MutationObserverImpl = MutationObserverImpl;
-//# sourceMappingURL=MutationObserverImpl.js.map
-
-/***/ }),
-
-/***/ 33:
-/***/ ((__unused_webpack_module, exports) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.MutationRecordImpl = void 0;
-/**
- * Represents a mutation record.
- */
-class MutationRecordImpl {
- _type;
- _target;
- _addedNodes;
- _removedNodes;
- _previousSibling;
- _nextSibling;
- _attributeName;
- _attributeNamespace;
- _oldValue;
- /**
- * Initializes a new instance of `MutationRecord`.
- *
- * @param type - type of mutation: `"attributes"` for an attribute
- * mutation, `"characterData"` for a mutation to a CharacterData node
- * and `"childList"` for a mutation to the tree of nodes.
- * @param target - node affected by the mutation.
- * @param addedNodes - list of added nodes.
- * @param removedNodes - list of removed nodes.
- * @param previousSibling - previous sibling of added or removed nodes.
- * @param nextSibling - next sibling of added or removed nodes.
- * @param attributeName - local name of the changed attribute,
- * and `null` otherwise.
- * @param attributeNamespace - namespace of the changed attribute,
- * and `null` otherwise.
- * @param oldValue - value before mutation: attribute value for an attribute
- * mutation, node `data` for a mutation to a CharacterData node and `null`
- * for a mutation to the tree of nodes.
- */
- constructor(type, target, addedNodes, removedNodes, previousSibling, nextSibling, attributeName, attributeNamespace, oldValue) {
- this._type = type;
- this._target = target;
- this._addedNodes = addedNodes;
- this._removedNodes = removedNodes;
- this._previousSibling = previousSibling;
- this._nextSibling = nextSibling;
- this._attributeName = attributeName;
- this._attributeNamespace = attributeNamespace;
- this._oldValue = oldValue;
- }
- /** @inheritdoc */
- get type() { return this._type; }
- /** @inheritdoc */
- get target() { return this._target; }
- /** @inheritdoc */
- get addedNodes() { return this._addedNodes; }
- /** @inheritdoc */
- get removedNodes() { return this._removedNodes; }
- /** @inheritdoc */
- get previousSibling() { return this._previousSibling; }
- /** @inheritdoc */
- get nextSibling() { return this._nextSibling; }
- /** @inheritdoc */
- get attributeName() { return this._attributeName; }
- /** @inheritdoc */
- get attributeNamespace() { return this._attributeNamespace; }
- /** @inheritdoc */
- get oldValue() { return this._oldValue; }
- /**
- * Creates a new `MutationRecord`.
- *
- * @param type - type of mutation: `"attributes"` for an attribute
- * mutation, `"characterData"` for a mutation to a CharacterData node
- * and `"childList"` for a mutation to the tree of nodes.
- * @param target - node affected by the mutation.
- * @param addedNodes - list of added nodes.
- * @param removedNodes - list of removed nodes.
- * @param previousSibling - previous sibling of added or removed nodes.
- * @param nextSibling - next sibling of added or removed nodes.
- * @param attributeName - local name of the changed attribute,
- * and `null` otherwise.
- * @param attributeNamespace - namespace of the changed attribute,
- * and `null` otherwise.
- * @param oldValue - value before mutation: attribute value for an attribute
- * mutation, node `data` for a mutation to a CharacterData node and `null`
- * for a mutation to the tree of nodes.
- */
- static _create(type, target, addedNodes, removedNodes, previousSibling, nextSibling, attributeName, attributeNamespace, oldValue) {
- return new MutationRecordImpl(type, target, addedNodes, removedNodes, previousSibling, nextSibling, attributeName, attributeNamespace, oldValue);
- }
-}
-exports.MutationRecordImpl = MutationRecordImpl;
-//# sourceMappingURL=MutationRecordImpl.js.map
-
-/***/ }),
-
-/***/ 3145:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.NamedNodeMapImpl = void 0;
-const DOMException_1 = __nccwpck_require__(7175);
-const algorithm_1 = __nccwpck_require__(6573);
-/**
- * Represents a collection of attributes.
- */
-class NamedNodeMapImpl extends Array {
- _element;
- /**
- * Initializes a new instance of `NamedNodeMap`.
- *
- * @param element - parent element
- */
- constructor(element) {
- super();
- this._element = element;
- // TODO: This workaround is needed to extend Array in ES5
- Object.setPrototypeOf(this, NamedNodeMapImpl.prototype);
- }
- _asArray() { return this; }
- /** @inheritdoc */
- item(index) {
- /**
- * 1. If index is equal to or greater than context object’s attribute list’s
- * size, then return null.
- * 2. Otherwise, return context object’s attribute list[index].
- *
- */
- return this[index] || null;
- }
- /** @inheritdoc */
- getNamedItem(qualifiedName) {
- /**
- * The getNamedItem(qualifiedName) method, when invoked, must return the
- * result of getting an attribute given qualifiedName and element.
- */
- return (0, algorithm_1.element_getAnAttributeByName)(qualifiedName, this._element);
- }
- /** @inheritdoc */
- getNamedItemNS(namespace, localName) {
- /**
- * The getNamedItemNS(namespace, localName) method, when invoked, must
- * return the result of getting an attribute given namespace, localName,
- * and element.
- */
- return (0, algorithm_1.element_getAnAttributeByNamespaceAndLocalName)(namespace || '', localName, this._element);
- }
- /** @inheritdoc */
- setNamedItem(attr) {
- /**
- * The setNamedItem(attr) and setNamedItemNS(attr) methods, when invoked,
- * must return the result of setting an attribute given attr and element.
- */
- return (0, algorithm_1.element_setAnAttribute)(attr, this._element);
- }
- /** @inheritdoc */
- setNamedItemNS(attr) {
- return (0, algorithm_1.element_setAnAttribute)(attr, this._element);
- }
- /** @inheritdoc */
- removeNamedItem(qualifiedName) {
- /**
- * 1. Let attr be the result of removing an attribute given qualifiedName
- * and element.
- * 2. If attr is null, then throw a "NotFoundError" DOMException.
- * 3. Return attr.
- */
- const attr = (0, algorithm_1.element_removeAnAttributeByName)(qualifiedName, this._element);
- if (attr === null)
- throw new DOMException_1.NotFoundError();
- return attr;
- }
- /** @inheritdoc */
- removeNamedItemNS(namespace, localName) {
- /**
- * 1. Let attr be the result of removing an attribute given namespace,
- * localName, and element.
- * 2. If attr is null, then throw a "NotFoundError" DOMException.
- * 3. Return attr.
- */
- const attr = (0, algorithm_1.element_removeAnAttributeByNamespaceAndLocalName)(namespace || '', localName, this._element);
- if (attr === null)
- throw new DOMException_1.NotFoundError();
- return attr;
- }
- /**
- * Creates a new `NamedNodeMap`.
- *
- * @param element - parent element
- */
- static _create(element) {
- return new NamedNodeMapImpl(element);
- }
-}
-exports.NamedNodeMapImpl = NamedNodeMapImpl;
-//# sourceMappingURL=NamedNodeMapImpl.js.map
-
-/***/ }),
-
-/***/ 4649:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.NodeFilterImpl = void 0;
-const interfaces_1 = __nccwpck_require__(9454);
-const WebIDLAlgorithm_1 = __nccwpck_require__(4239);
-/**
- * Represents a node filter.
- */
-class NodeFilterImpl {
- static FILTER_ACCEPT = 1;
- static FILTER_REJECT = 2;
- static FILTER_SKIP = 3;
- static SHOW_ALL = 0xffffffff;
- static SHOW_ELEMENT = 0x1;
- static SHOW_ATTRIBUTE = 0x2;
- static SHOW_TEXT = 0x4;
- static SHOW_CDATA_SECTION = 0x8;
- static SHOW_ENTITY_REFERENCE = 0x10;
- static SHOW_ENTITY = 0x20;
- static SHOW_PROCESSING_INSTRUCTION = 0x40;
- static SHOW_COMMENT = 0x80;
- static SHOW_DOCUMENT = 0x100;
- static SHOW_DOCUMENT_TYPE = 0x200;
- static SHOW_DOCUMENT_FRAGMENT = 0x400;
- static SHOW_NOTATION = 0x800;
- FILTER_ACCEPT = 1;
- FILTER_REJECT = 2;
- FILTER_SKIP = 3;
- SHOW_ALL = 0xffffffff;
- SHOW_ELEMENT = 0x1;
- SHOW_ATTRIBUTE = 0x2;
- SHOW_TEXT = 0x4;
- SHOW_CDATA_SECTION = 0x8;
- SHOW_ENTITY_REFERENCE = 0x10;
- SHOW_ENTITY = 0x20;
- SHOW_PROCESSING_INSTRUCTION = 0x40;
- SHOW_COMMENT = 0x80;
- SHOW_DOCUMENT = 0x100;
- SHOW_DOCUMENT_TYPE = 0x200;
- SHOW_DOCUMENT_FRAGMENT = 0x400;
- SHOW_NOTATION = 0x800;
- /**
- * Initializes a new instance of `NodeFilter`.
- */
- constructor() {
- }
- /**
- * Callback function.
- */
- acceptNode(node) {
- return interfaces_1.FilterResult.Accept;
- }
- /**
- * Creates a new `NodeFilter`.
- */
- static _create() {
- return new NodeFilterImpl();
- }
-}
-exports.NodeFilterImpl = NodeFilterImpl;
-/**
- * Define constants on prototype.
- */
-(0, WebIDLAlgorithm_1.idl_defineConst)(NodeFilterImpl.prototype, "FILTER_ACCEPT", 1);
-(0, WebIDLAlgorithm_1.idl_defineConst)(NodeFilterImpl.prototype, "FILTER_REJECT", 2);
-(0, WebIDLAlgorithm_1.idl_defineConst)(NodeFilterImpl.prototype, "FILTER_SKIP", 3);
-(0, WebIDLAlgorithm_1.idl_defineConst)(NodeFilterImpl.prototype, "SHOW_ALL", 0xffffffff);
-(0, WebIDLAlgorithm_1.idl_defineConst)(NodeFilterImpl.prototype, "SHOW_ELEMENT", 0x1);
-(0, WebIDLAlgorithm_1.idl_defineConst)(NodeFilterImpl.prototype, "SHOW_ATTRIBUTE", 0x2);
-(0, WebIDLAlgorithm_1.idl_defineConst)(NodeFilterImpl.prototype, "SHOW_TEXT", 0x4);
-(0, WebIDLAlgorithm_1.idl_defineConst)(NodeFilterImpl.prototype, "SHOW_CDATA_SECTION", 0x8);
-(0, WebIDLAlgorithm_1.idl_defineConst)(NodeFilterImpl.prototype, "SHOW_ENTITY_REFERENCE", 0x10);
-(0, WebIDLAlgorithm_1.idl_defineConst)(NodeFilterImpl.prototype, "SHOW_ENTITY", 0x20);
-(0, WebIDLAlgorithm_1.idl_defineConst)(NodeFilterImpl.prototype, "SHOW_PROCESSING_INSTRUCTION", 0x40);
-(0, WebIDLAlgorithm_1.idl_defineConst)(NodeFilterImpl.prototype, "SHOW_COMMENT", 0x80);
-(0, WebIDLAlgorithm_1.idl_defineConst)(NodeFilterImpl.prototype, "SHOW_DOCUMENT", 0x100);
-(0, WebIDLAlgorithm_1.idl_defineConst)(NodeFilterImpl.prototype, "SHOW_DOCUMENT_TYPE", 0x200);
-(0, WebIDLAlgorithm_1.idl_defineConst)(NodeFilterImpl.prototype, "SHOW_DOCUMENT_FRAGMENT", 0x400);
-(0, WebIDLAlgorithm_1.idl_defineConst)(NodeFilterImpl.prototype, "SHOW_NOTATION", 0x800);
-//# sourceMappingURL=NodeFilterImpl.js.map
-
-/***/ }),
-
-/***/ 2280:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.NodeImpl = void 0;
-const DOMImpl_1 = __nccwpck_require__(698);
-const interfaces_1 = __nccwpck_require__(9454);
-const EventTargetImpl_1 = __nccwpck_require__(3611);
-const util_1 = __nccwpck_require__(8247);
-const DOMException_1 = __nccwpck_require__(7175);
-const algorithm_1 = __nccwpck_require__(6573);
-const URLAlgorithm_1 = __nccwpck_require__(3650);
-const WebIDLAlgorithm_1 = __nccwpck_require__(4239);
-/**
- * Represents a generic XML node.
- */
-class NodeImpl extends EventTargetImpl_1.EventTargetImpl {
- static ELEMENT_NODE = 1;
- static ATTRIBUTE_NODE = 2;
- static TEXT_NODE = 3;
- static CDATA_SECTION_NODE = 4;
- static ENTITY_REFERENCE_NODE = 5;
- static ENTITY_NODE = 6;
- static PROCESSING_INSTRUCTION_NODE = 7;
- static COMMENT_NODE = 8;
- static DOCUMENT_NODE = 9;
- static DOCUMENT_TYPE_NODE = 10;
- static DOCUMENT_FRAGMENT_NODE = 11;
- static NOTATION_NODE = 12;
- static DOCUMENT_POSITION_DISCONNECTED = 0x01;
- static DOCUMENT_POSITION_PRECEDING = 0x02;
- static DOCUMENT_POSITION_FOLLOWING = 0x04;
- static DOCUMENT_POSITION_CONTAINS = 0x08;
- static DOCUMENT_POSITION_CONTAINED_BY = 0x10;
- static DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC = 0x20;
- ELEMENT_NODE = 1;
- ATTRIBUTE_NODE = 2;
- TEXT_NODE = 3;
- CDATA_SECTION_NODE = 4;
- ENTITY_REFERENCE_NODE = 5;
- ENTITY_NODE = 6;
- PROCESSING_INSTRUCTION_NODE = 7;
- COMMENT_NODE = 8;
- DOCUMENT_NODE = 9;
- DOCUMENT_TYPE_NODE = 10;
- DOCUMENT_FRAGMENT_NODE = 11;
- NOTATION_NODE = 12;
- DOCUMENT_POSITION_DISCONNECTED = 0x01;
- DOCUMENT_POSITION_PRECEDING = 0x02;
- DOCUMENT_POSITION_FOLLOWING = 0x04;
- DOCUMENT_POSITION_CONTAINS = 0x08;
- DOCUMENT_POSITION_CONTAINED_BY = 0x10;
- DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC = 0x20;
- __childNodes;
- get _childNodes() {
- return this.__childNodes || (this.__childNodes = (0, algorithm_1.create_nodeList)(this));
- }
- _nodeDocumentOverride;
- get _nodeDocument() { return this._nodeDocumentOverride || DOMImpl_1.dom.window._associatedDocument; }
- set _nodeDocument(val) { this._nodeDocumentOverride = val; }
- __registeredObserverList;
- get _registeredObserverList() {
- return this.__registeredObserverList || (this.__registeredObserverList = []);
- }
- _parent = null;
- _children = new util_1.EmptySet;
- _firstChild = null;
- _lastChild = null;
- _previousSibling = null;
- _nextSibling = null;
- /**
- * Initializes a new instance of `Node`.
- */
- constructor() {
- super();
- }
- /** @inheritdoc */
- get nodeType() { return this._nodeType; }
- /**
- * Returns a string appropriate for the type of node.
- */
- get nodeName() {
- if (util_1.Guard.isElementNode(this)) {
- return this._htmlUppercasedQualifiedName;
- }
- else if (util_1.Guard.isAttrNode(this)) {
- return this._qualifiedName;
- }
- else if (util_1.Guard.isExclusiveTextNode(this)) {
- return "#text";
- }
- else if (util_1.Guard.isCDATASectionNode(this)) {
- return "#cdata-section";
- }
- else if (util_1.Guard.isProcessingInstructionNode(this)) {
- return this._target;
- }
- else if (util_1.Guard.isCommentNode(this)) {
- return "#comment";
- }
- else if (util_1.Guard.isDocumentNode(this)) {
- return "#document";
- }
- else if (util_1.Guard.isDocumentTypeNode(this)) {
- return this._name;
- }
- else if (util_1.Guard.isDocumentFragmentNode(this)) {
- return "#document-fragment";
- }
- else {
- return "";
- }
- }
- /**
- * Gets the absolute base URL of the node.
- */
- get baseURI() {
- /**
- * The baseURI attribute’s getter must return node document’s document
- * base URL, serialized.
- * TODO: Implement in HTML DOM
- * https://html.spec.whatwg.org/multipage/urls-and-fetching.html#document-base-url
- */
- return (0, URLAlgorithm_1.urlSerializer)(this._nodeDocument._URL);
- }
- /**
- * Returns whether the node is rooted to a document node.
- */
- get isConnected() {
- /**
- * The isConnected attribute’s getter must return true, if context object
- * is connected, and false otherwise.
- */
- return util_1.Guard.isElementNode(this) && (0, algorithm_1.shadowTree_isConnected)(this);
- }
- /**
- * Returns the parent document.
- */
- get ownerDocument() {
- /**
- * The ownerDocument attribute’s getter must return null, if the context
- * object is a document, and the context object’s node document otherwise.
- * _Note:_ The node document of a document is that document itself. All
- * nodes have a node document at all times.
- */
- if (this._nodeType === interfaces_1.NodeType.Document)
- return null;
- else
- return this._nodeDocument;
- }
- /**
- * Returns the root node.
- *
- * @param options - if options has `composed = true` this function
- * returns the node's shadow-including root, otherwise it returns
- * the node's root node.
- */
- getRootNode(options) {
- /**
- * The getRootNode(options) method, when invoked, must return context
- * object’s shadow-including root if options’s composed is true,
- * and context object’s root otherwise.
- */
- return (0, algorithm_1.tree_rootNode)(this, !!options && options.composed);
- }
- /**
- * Returns the parent node.
- */
- get parentNode() {
- /**
- * The parentNode attribute’s getter must return the context object’s parent.
- * _Note:_ An Attr node has no parent.
- */
- if (this._nodeType === interfaces_1.NodeType.Attribute) {
- return null;
- }
- else {
- return this._parent;
- }
- }
- /**
- * Returns the parent element.
- */
- get parentElement() {
- /**
- * The parentElement attribute’s getter must return the context object’s
- * parent element.
- */
- if (this._parent && util_1.Guard.isElementNode(this._parent)) {
- return this._parent;
- }
- else {
- return null;
- }
- }
- /**
- * Determines whether a node has any children.
- */
- hasChildNodes() {
- /**
- * The hasChildNodes() method, when invoked, must return true if the context
- * object has children, and false otherwise.
- */
- return (this._firstChild !== null);
- }
- /**
- * Returns a {@link NodeList} of child nodes.
- */
- get childNodes() {
- /**
- * The childNodes attribute’s getter must return a NodeList rooted at the
- * context object matching only children.
- */
- return this._childNodes;
- }
- /**
- * Returns the first child node.
- */
- get firstChild() {
- /**
- * The firstChild attribute’s getter must return the context object’s first
- * child.
- */
- return this._firstChild;
- }
- /**
- * Returns the last child node.
- */
- get lastChild() {
- /**
- * The lastChild attribute’s getter must return the context object’s last
- * child.
- */
- return this._lastChild;
- }
- /**
- * Returns the previous sibling node.
- */
- get previousSibling() {
- /**
- * The previousSibling attribute’s getter must return the context object’s
- * previous sibling.
- * _Note:_ An Attr node has no siblings.
- */
- return this._previousSibling;
- }
- /**
- * Returns the next sibling node.
- */
- get nextSibling() {
- /**
- * The nextSibling attribute’s getter must return the context object’s
- * next sibling.
- */
- return this._nextSibling;
- }
- /**
- * Gets or sets the data associated with a {@link CharacterData} node or the
- * value of an {@link @Attr} node. For other node types returns `null`.
- */
- get nodeValue() {
- if (util_1.Guard.isAttrNode(this)) {
- return this._value;
- }
- else if (util_1.Guard.isCharacterDataNode(this)) {
- return this._data;
- }
- else {
- return null;
- }
- }
- set nodeValue(value) {
- if (value === null) {
- value = '';
- }
- if (util_1.Guard.isAttrNode(this)) {
- (0, algorithm_1.attr_setAnExistingAttributeValue)(this, value);
- }
- else if (util_1.Guard.isCharacterDataNode(this)) {
- (0, algorithm_1.characterData_replaceData)(this, 0, this._data.length, value);
- }
- }
- /**
- * Returns the concatenation of data of all the {@link Text}
- * node descendants in tree order. When set, replaces the text
- * contents of the node with the given value.
- */
- get textContent() {
- if (util_1.Guard.isDocumentFragmentNode(this) || util_1.Guard.isElementNode(this)) {
- return (0, algorithm_1.text_descendantTextContent)(this);
- }
- else if (util_1.Guard.isAttrNode(this)) {
- return this._value;
- }
- else if (util_1.Guard.isCharacterDataNode(this)) {
- return this._data;
- }
- else {
- return null;
- }
- }
- set textContent(value) {
- if (value === null) {
- value = '';
- }
- if (util_1.Guard.isDocumentFragmentNode(this) || util_1.Guard.isElementNode(this)) {
- (0, algorithm_1.node_stringReplaceAll)(value, this);
- }
- else if (util_1.Guard.isAttrNode(this)) {
- (0, algorithm_1.attr_setAnExistingAttributeValue)(this, value);
- }
- else if (util_1.Guard.isCharacterDataNode(this)) {
- (0, algorithm_1.characterData_replaceData)(this, 0, (0, algorithm_1.tree_nodeLength)(this), value);
- }
- }
- /**
- * Puts all {@link Text} nodes in the full depth of the sub-tree
- * underneath this node into a "normal" form where only markup
- * (e.g., tags, comments, processing instructions, CDATA sections,
- * and entity references) separates {@link Text} nodes, i.e., there
- * are no adjacent Text nodes.
- */
- normalize() {
- /**
- * The normalize() method, when invoked, must run these steps for each
- * descendant exclusive Text node node of context object:
- */
- const descendantNodes = [];
- let node = (0, algorithm_1.tree_getFirstDescendantNode)(this, false, false, (e) => util_1.Guard.isExclusiveTextNode(e));
- while (node !== null) {
- descendantNodes.push(node);
- node = (0, algorithm_1.tree_getNextDescendantNode)(this, node, false, false, (e) => util_1.Guard.isExclusiveTextNode(e));
- }
- for (let i = 0; i < descendantNodes.length; i++) {
- const node = descendantNodes[i];
- if (node._parent === null)
- continue;
- /**
- * 1. Let length be node’s length.
- * 2. If length is zero, then remove node and continue with the next
- * exclusive Text node, if any.
- */
- let length = (0, algorithm_1.tree_nodeLength)(node);
- if (length === 0) {
- (0, algorithm_1.mutation_remove)(node, node._parent);
- continue;
- }
- /**
- * 3. Let data be the concatenation of the data of node’s contiguous
- * exclusive Text nodes (excluding itself), in tree order.
- */
- const textSiblings = [];
- let data = '';
- for (const sibling of (0, algorithm_1.text_contiguousExclusiveTextNodes)(node)) {
- textSiblings.push(sibling);
- data += sibling._data;
- }
- /**
- * 4. Replace data with node node, offset length, count 0, and data data.
- */
- (0, algorithm_1.characterData_replaceData)(node, length, 0, data);
- /**
- * 5. Let currentNode be node’s next sibling.
- * 6. While currentNode is an exclusive Text node:
- */
- if (DOMImpl_1.dom.rangeList.size !== 0) {
- let currentNode = node._nextSibling;
- while (currentNode !== null && util_1.Guard.isExclusiveTextNode(currentNode)) {
- /**
- * 6.1. For each live range whose start node is currentNode, add length
- * to its start offset and set its start node to node.
- * 6.2. For each live range whose end node is currentNode, add length to
- * its end offset and set its end node to node.
- * 6.3. For each live range whose start node is currentNode’s parent and
- * start offset is currentNode’s index, set its start node to node and
- * its start offset to length.
- * 6.4. For each live range whose end node is currentNode’s parent and
- * end offset is currentNode’s index, set its end node to node and its
- * end offset to length.
- */
- const cn = currentNode;
- const index = (0, algorithm_1.tree_index)(cn);
- for (const range of DOMImpl_1.dom.rangeList) {
- if (range._start[0] === cn) {
- range._start[0] = node;
- range._start[1] += length;
- }
- if (range._end[0] === cn) {
- range._end[0] = node;
- range._end[1] += length;
- }
- if (range._start[0] === cn._parent && range._start[1] === index) {
- range._start[0] = node;
- range._start[1] = length;
- }
- if (range._end[0] === cn._parent && range._end[1] === index) {
- range._end[0] = node;
- range._end[1] = length;
- }
- }
- /**
- * 6.5. Add currentNode’s length to length.
- * 6.6. Set currentNode to its next sibling.
- */
- length += (0, algorithm_1.tree_nodeLength)(currentNode);
- currentNode = currentNode._nextSibling;
- }
- }
- /**
- * 7. Remove node’s contiguous exclusive Text nodes (excluding itself),
- * in tree order.
- */
- for (let i = 0; i < textSiblings.length; i++) {
- const sibling = textSiblings[i];
- if (sibling._parent === null)
- continue;
- (0, algorithm_1.mutation_remove)(sibling, sibling._parent);
- }
- }
- }
- /**
- * Returns a duplicate of this node, i.e., serves as a generic copy
- * constructor for nodes. The duplicate node has no parent
- * ({@link parentNode} returns `null`).
- *
- * @param deep - if `true`, recursively clone the subtree under the
- * specified node. If `false`, clone only the node itself (and its
- * attributes, if it is an {@link Element}).
- */
- cloneNode(deep = false) {
- /**
- * 1. If context object is a shadow root, then throw a "NotSupportedError"
- * DOMException.
- * 2. Return a clone of the context object, with the clone children flag set
- * if deep is true.
- */
- if (util_1.Guard.isShadowRoot(this))
- throw new DOMException_1.NotSupportedError();
- return (0, algorithm_1.node_clone)(this, null, deep);
- }
- /**
- * Determines if the given node is equal to this one.
- *
- * @param node - the node to compare with
- */
- isEqualNode(node = null) {
- /**
- * The isEqualNode(otherNode) method, when invoked, must return true if
- * otherNode is non-null and context object equals otherNode, and false
- * otherwise.
- */
- return (node !== null && (0, algorithm_1.node_equals)(this, node));
- }
- /**
- * Determines if the given node is reference equal to this one.
- *
- * @param node - the node to compare with
- */
- isSameNode(node = null) {
- /**
- * The isSameNode(otherNode) method, when invoked, must return true if
- * otherNode is context object, and false otherwise.
- */
- return (this === node);
- }
- /**
- * Returns a bitmask indicating the position of the given `node`
- * relative to this node.
- */
- compareDocumentPosition(other) {
- /**
- * 1. If context object is other, then return zero.
- * 2. Let node1 be other and node2 be context object.
- * 3. Let attr1 and attr2 be null.
- * attr1’s element.
- */
- if (other === this)
- return interfaces_1.Position.SameNode;
- let node1 = other;
- let node2 = this;
- let attr1 = null;
- let attr2 = null;
- /**
- * 4. If node1 is an attribute, then set attr1 to node1 and node1 to
- * attr1’s element.
- */
- if (util_1.Guard.isAttrNode(node1)) {
- attr1 = node1;
- node1 = attr1._element;
- }
- /**
- * 5. If node2 is an attribute, then:
- */
- if (util_1.Guard.isAttrNode(node2)) {
- /**
- * 5.1. Set attr2 to node2 and node2 to attr2’s element.
- */
- attr2 = node2;
- node2 = attr2._element;
- /**
- * 5.2. If attr1 and node1 are non-null, and node2 is node1, then:
- */
- if (attr1 && node1 && (node1 === node2)) {
- /**
- * 5.2. For each attr in node2’s attribute list:
- */
- for (let i = 0; i < node2._attributeList.length; i++) {
- const attr = node2._attributeList[i];
- /**
- * 5.2.1. If attr equals attr1, then return the result of adding
- * DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC and
- * DOCUMENT_POSITION_PRECEDING.
- * 5.2.2. If attr equals attr2, then return the result of adding
- * DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC and
- * DOCUMENT_POSITION_FOLLOWING.
- */
- if ((0, algorithm_1.node_equals)(attr, attr1)) {
- return interfaces_1.Position.ImplementationSpecific | interfaces_1.Position.Preceding;
- }
- else if ((0, algorithm_1.node_equals)(attr, attr2)) {
- return interfaces_1.Position.ImplementationSpecific | interfaces_1.Position.Following;
- }
- }
- }
- }
- /**
- * 6. If node1 or node2 is null, or node1’s root is not node2’s root, then
- * return the result of adding DOCUMENT_POSITION_DISCONNECTED,
- * DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC, and either
- * DOCUMENT_POSITION_PRECEDING or DOCUMENT_POSITION_FOLLOWING,
- * with the constraint that this is to be consistent, together.
- */
- if (node1 === null || node2 === null ||
- (0, algorithm_1.tree_rootNode)(node1) !== (0, algorithm_1.tree_rootNode)(node2)) {
- // nodes are disconnected
- // return a random result but cache the value for consistency
- return interfaces_1.Position.Disconnected | interfaces_1.Position.ImplementationSpecific |
- (DOMImpl_1.dom.compareCache.check(this, other) ? interfaces_1.Position.Preceding : interfaces_1.Position.Following);
- }
- /**
- * 7. If node1 is an ancestor of node2 and attr1 is null, or node1 is node2
- * and attr2 is non-null, then return the result of adding
- * DOCUMENT_POSITION_CONTAINS to DOCUMENT_POSITION_PRECEDING.
- */
- if ((!attr1 && (0, algorithm_1.tree_isAncestorOf)(node2, node1)) ||
- (attr2 && (node1 === node2))) {
- return interfaces_1.Position.Contains | interfaces_1.Position.Preceding;
- }
- /**
- * 8. If node1 is a descendant of node2 and attr2 is null, or node1 is node2
- * and attr1 is non-null, then return the result of adding
- * DOCUMENT_POSITION_CONTAINED_BY to DOCUMENT_POSITION_FOLLOWING.
- */
- if ((!attr2 && (0, algorithm_1.tree_isDescendantOf)(node2, node1)) ||
- (attr1 && (node1 === node2))) {
- return interfaces_1.Position.ContainedBy | interfaces_1.Position.Following;
- }
- /**
- * 9. If node1 is preceding node2, then return DOCUMENT_POSITION_PRECEDING.
- */
- if ((0, algorithm_1.tree_isPreceding)(node2, node1))
- return interfaces_1.Position.Preceding;
- /**
- * 10. Return DOCUMENT_POSITION_FOLLOWING.
- */
- return interfaces_1.Position.Following;
- }
- /**
- * Returns `true` if given node is an inclusive descendant of this
- * node, and `false` otherwise (including when other node is `null`).
- *
- * @param other - the node to check
- */
- contains(other) {
- /**
- * The contains(other) method, when invoked, must return true if other is an
- * inclusive descendant of context object, and false otherwise (including
- * when other is null).
- */
- if (other === null)
- return false;
- return (0, algorithm_1.tree_isDescendantOf)(this, other, true);
- }
- /**
- * Returns the prefix for a given namespace URI, if present, and
- * `null` if not.
- *
- * @param namespace - the namespace to search
- */
- lookupPrefix(namespace) {
- /**
- * 1. If namespace is null or the empty string, then return null.
- * 2. Switch on the context object:
- */
- if (!namespace)
- return null;
- if (util_1.Guard.isElementNode(this)) {
- /**
- * Return the result of locating a namespace prefix for it using
- * namespace.
- */
- return (0, algorithm_1.node_locateANamespacePrefix)(this, namespace);
- }
- else if (util_1.Guard.isDocumentNode(this)) {
- /**
- * Return the result of locating a namespace prefix for its document
- * element, if its document element is non-null, and null otherwise.
- */
- if (this.documentElement === null) {
- return null;
- }
- else {
- return (0, algorithm_1.node_locateANamespacePrefix)(this.documentElement, namespace);
- }
- }
- else if (util_1.Guard.isDocumentTypeNode(this) || util_1.Guard.isDocumentFragmentNode(this)) {
- return null;
- }
- else if (util_1.Guard.isAttrNode(this)) {
- /**
- * Return the result of locating a namespace prefix for its element,
- * if its element is non-null, and null otherwise.
- */
- if (this._element === null) {
- return null;
- }
- else {
- return (0, algorithm_1.node_locateANamespacePrefix)(this._element, namespace);
- }
- }
- else {
- /**
- * Return the result of locating a namespace prefix for its parent
- * element, if its parent element is non-null, and null otherwise.
- */
- if (this._parent !== null && util_1.Guard.isElementNode(this._parent)) {
- return (0, algorithm_1.node_locateANamespacePrefix)(this._parent, namespace);
- }
- else {
- return null;
- }
- }
- }
- /**
- * Returns the namespace URI for a given prefix if present, and `null`
- * if not.
- *
- * @param prefix - the prefix to search
- */
- lookupNamespaceURI(prefix) {
- /**
- * 1. If prefix is the empty string, then set it to null.
- * 2. Return the result of running locate a namespace for the context object
- * using prefix.
- */
- return (0, algorithm_1.node_locateANamespace)(this, prefix || null);
- }
- /**
- * Returns `true` if the namespace is the default namespace on this
- * node or `false` if not.
- *
- * @param namespace - the namespace to check
- */
- isDefaultNamespace(namespace) {
- /**
- * 1. If namespace is the empty string, then set it to null.
- * 2. Let defaultNamespace be the result of running locate a namespace for
- * context object using null.
- * 3. Return true if defaultNamespace is the same as namespace, and false otherwise.
- */
- if (!namespace)
- namespace = null;
- const defaultNamespace = (0, algorithm_1.node_locateANamespace)(this, null);
- return (defaultNamespace === namespace);
- }
- /**
- * Inserts the node `newChild` before the existing child node
- * `refChild`. If `refChild` is `null`, inserts `newChild` at the end
- * of the list of children.
- *
- * If `newChild` is a {@link DocumentFragment} object, all of its
- * children are inserted, in the same order, before `refChild`.
- *
- * If `newChild` is already in the tree, it is first removed.
- *
- * @param newChild - the node to insert
- * @param refChild - the node before which the new node must be
- * inserted
- *
- * @returns the newly inserted child node
- */
- insertBefore(newChild, refChild) {
- /**
- * The insertBefore(node, child) method, when invoked, must return the
- * result of pre-inserting node into context object before child.
- */
- return (0, algorithm_1.mutation_preInsert)(newChild, this, refChild);
- }
- /**
- * Adds the node `newChild` to the end of the list of children of this
- * node, and returns it. If `newChild` is already in the tree, it is
- * first removed.
- *
- * If `newChild` is a {@link DocumentFragment} object, the entire
- * contents of the document fragment are moved into the child list of
- * this node.
- *
- * @param newChild - the node to add
- *
- * @returns the newly inserted child node
- */
- appendChild(newChild) {
- /**
- * The appendChild(node) method, when invoked, must return the result of
- * appending node to context object.
- */
- return (0, algorithm_1.mutation_append)(newChild, this);
- }
- /**
- * Replaces the child node `oldChild` with `newChild` in the list of
- * children, and returns the `oldChild` node. If `newChild` is already
- * in the tree, it is first removed.
- *
- * @param newChild - the new node to put in the child list
- * @param oldChild - the node being replaced in the list
- *
- * @returns the removed child node
- */
- replaceChild(newChild, oldChild) {
- /**
- * The replaceChild(node, child) method, when invoked, must return the
- * result of replacing child with node within context object.
- */
- return (0, algorithm_1.mutation_replace)(oldChild, newChild, this);
- }
- /**
- * Removes the child node indicated by `oldChild` from the list of
- * children, and returns it.
- *
- * @param oldChild - the node being removed from the list
- *
- * @returns the removed child node
- */
- removeChild(oldChild) {
- /**
- * The removeChild(child) method, when invoked, must return the result of
- * pre-removing child from context object.
- */
- return (0, algorithm_1.mutation_preRemove)(oldChild, this);
- }
- /**
- * Gets the parent event target for the given event.
- *
- * @param event - an event
- */
- _getTheParent(event) {
- /**
- * A node’s get the parent algorithm, given an event, returns the node’s
- * assigned slot, if node is assigned, and node’s parent otherwise.
- */
- if (util_1.Guard.isSlotable(this) && (0, algorithm_1.shadowTree_isAssigned)(this)) {
- return this._assignedSlot;
- }
- else {
- return this._parent;
- }
- }
-}
-exports.NodeImpl = NodeImpl;
-/**
- * A performance tweak to share an empty set between all node classes. This will
- * be overwritten by element, document and document fragment nodes to supply an
- * actual set of nodes.
- */
-NodeImpl.prototype._children = new util_1.EmptySet();
-/**
- * Define constants on prototype.
- */
-(0, WebIDLAlgorithm_1.idl_defineConst)(NodeImpl.prototype, "ELEMENT_NODE", 1);
-(0, WebIDLAlgorithm_1.idl_defineConst)(NodeImpl.prototype, "ATTRIBUTE_NODE", 2);
-(0, WebIDLAlgorithm_1.idl_defineConst)(NodeImpl.prototype, "TEXT_NODE", 3);
-(0, WebIDLAlgorithm_1.idl_defineConst)(NodeImpl.prototype, "CDATA_SECTION_NODE", 4);
-(0, WebIDLAlgorithm_1.idl_defineConst)(NodeImpl.prototype, "ENTITY_REFERENCE_NODE", 5);
-(0, WebIDLAlgorithm_1.idl_defineConst)(NodeImpl.prototype, "ENTITY_NODE", 6);
-(0, WebIDLAlgorithm_1.idl_defineConst)(NodeImpl.prototype, "PROCESSING_INSTRUCTION_NODE", 7);
-(0, WebIDLAlgorithm_1.idl_defineConst)(NodeImpl.prototype, "COMMENT_NODE", 8);
-(0, WebIDLAlgorithm_1.idl_defineConst)(NodeImpl.prototype, "DOCUMENT_NODE", 9);
-(0, WebIDLAlgorithm_1.idl_defineConst)(NodeImpl.prototype, "DOCUMENT_TYPE_NODE", 10);
-(0, WebIDLAlgorithm_1.idl_defineConst)(NodeImpl.prototype, "DOCUMENT_FRAGMENT_NODE", 11);
-(0, WebIDLAlgorithm_1.idl_defineConst)(NodeImpl.prototype, "NOTATION_NODE", 12);
-(0, WebIDLAlgorithm_1.idl_defineConst)(NodeImpl.prototype, "DOCUMENT_POSITION_DISCONNECTED", 0x01);
-(0, WebIDLAlgorithm_1.idl_defineConst)(NodeImpl.prototype, "DOCUMENT_POSITION_PRECEDING", 0x02);
-(0, WebIDLAlgorithm_1.idl_defineConst)(NodeImpl.prototype, "DOCUMENT_POSITION_FOLLOWING", 0x04);
-(0, WebIDLAlgorithm_1.idl_defineConst)(NodeImpl.prototype, "DOCUMENT_POSITION_CONTAINS", 0x08);
-(0, WebIDLAlgorithm_1.idl_defineConst)(NodeImpl.prototype, "DOCUMENT_POSITION_CONTAINED_BY", 0x10);
-(0, WebIDLAlgorithm_1.idl_defineConst)(NodeImpl.prototype, "DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC", 0x20);
-//# sourceMappingURL=NodeImpl.js.map
-
-/***/ }),
-
-/***/ 4142:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.NodeIteratorImpl = void 0;
-const TraverserImpl_1 = __nccwpck_require__(8506);
-const algorithm_1 = __nccwpck_require__(6573);
-/**
- * Represents an object which can be used to iterate through the nodes
- * of a subtree.
- */
-class NodeIteratorImpl extends TraverserImpl_1.TraverserImpl {
- _iteratorCollection;
- _reference;
- _pointerBeforeReference;
- /**
- * Initializes a new instance of `NodeIterator`.
- */
- constructor(root, reference, pointerBeforeReference) {
- super(root);
- this._iteratorCollection = undefined;
- this._reference = reference;
- this._pointerBeforeReference = pointerBeforeReference;
- (0, algorithm_1.nodeIterator_iteratorList)().add(this);
- }
- /** @inheritdoc */
- get referenceNode() { return this._reference; }
- /** @inheritdoc */
- get pointerBeforeReferenceNode() { return this._pointerBeforeReference; }
- /** @inheritdoc */
- nextNode() {
- /**
- * The nextNode() method, when invoked, must return the result of
- * traversing with the context object and next.
- */
- return (0, algorithm_1.nodeIterator_traverse)(this, true);
- }
- /** @inheritdoc */
- previousNode() {
- /**
- * The previousNode() method, when invoked, must return the result of
- * traversing with the context object and previous.
- */
- return (0, algorithm_1.nodeIterator_traverse)(this, false);
- }
- /** @inheritdoc */
- detach() {
- /**
- * The detach() method, when invoked, must do nothing.
- *
- * since JS lacks weak references, we still use detach
- */
- (0, algorithm_1.nodeIterator_iteratorList)().delete(this);
- }
- /**
- * Creates a new `NodeIterator`.
- *
- * @param root - iterator's root node
- * @param reference - reference node
- * @param pointerBeforeReference - whether the iterator is before or after the
- * reference node
- */
- static _create(root, reference, pointerBeforeReference) {
- return new NodeIteratorImpl(root, reference, pointerBeforeReference);
- }
-}
-exports.NodeIteratorImpl = NodeIteratorImpl;
-//# sourceMappingURL=NodeIteratorImpl.js.map
-
-/***/ }),
-
-/***/ 5788:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.NodeListImpl = void 0;
-const DOMImpl_1 = __nccwpck_require__(698);
-const util_1 = __nccwpck_require__(7061);
-const algorithm_1 = __nccwpck_require__(6573);
-/**
- * Represents an ordered set of nodes.
- */
-class NodeListImpl {
- _live = true;
- _root;
- _filter = null;
- _length = 0;
- /**
- * Initializes a new instance of `NodeList`.
- *
- * @param root - root node
- */
- constructor(root) {
- this._root = root;
- return new Proxy(this, this);
- }
- /** @inheritdoc */
- get length() {
- /**
- * The length attribute must return the number of nodes represented
- * by the collection.
- */
- return this._root._children.size;
- }
- /** @inheritdoc */
- item(index) {
- /**
- * The item(index) method must return the indexth node in the collection.
- * If there is no indexth node in the collection, then the method must
- * return null.
- */
- if (index < 0 || index > this.length - 1)
- return null;
- if (index < this.length / 2) {
- let i = 0;
- let node = this._root._firstChild;
- while (node !== null && i !== index) {
- node = node._nextSibling;
- i++;
- }
- return node;
- }
- else {
- let i = this.length - 1;
- let node = this._root._lastChild;
- while (node !== null && i !== index) {
- node = node._previousSibling;
- i--;
- }
- return node;
- }
- }
- /** @inheritdoc */
- keys() {
- return {
- [Symbol.iterator]: function () {
- let index = 0;
- return {
- next: function () {
- if (index === this.length) {
- return { done: true, value: null };
- }
- else {
- return { done: false, value: index++ };
- }
- }.bind(this)
- };
- }.bind(this)
- };
- }
- /** @inheritdoc */
- values() {
- return {
- [Symbol.iterator]: function () {
- const it = this[Symbol.iterator]();
- return {
- next() {
- return it.next();
- }
- };
- }.bind(this)
- };
- }
- /** @inheritdoc */
- entries() {
- return {
- [Symbol.iterator]: function () {
- const it = this[Symbol.iterator]();
- let index = 0;
- return {
- next() {
- const itResult = it.next();
- if (itResult.done) {
- return { done: true, value: null };
- }
- else {
- return { done: false, value: [index++, itResult.value] };
- }
- }
- };
- }.bind(this)
- };
- }
- /** @inheritdoc */
- [Symbol.iterator]() {
- return this._root._children[Symbol.iterator]();
- }
- /** @inheritdoc */
- forEach(callback, thisArg) {
- if (thisArg === undefined) {
- thisArg = DOMImpl_1.dom.window;
- }
- let index = 0;
- for (const node of this._root._children) {
- callback.call(thisArg, node, index++, this);
- }
- }
- /**
- * Implements a proxy get trap to provide array-like access.
- */
- get(target, key, receiver) {
- if (!(0, util_1.isString)(key)) {
- return Reflect.get(target, key, receiver);
- }
- const index = Number(key);
- if (isNaN(index)) {
- return Reflect.get(target, key, receiver);
- }
- return target.item(index) || undefined;
- }
- /**
- * Implements a proxy set trap to provide array-like access.
- */
- set(target, key, value, receiver) {
- if (!(0, util_1.isString)(key)) {
- return Reflect.set(target, key, value, receiver);
- }
- const index = Number(key);
- if (isNaN(index)) {
- return Reflect.set(target, key, value, receiver);
- }
- const node = target.item(index) || undefined;
- if (!node)
- return false;
- if (node._parent) {
- (0, algorithm_1.mutation_replace)(node, value, node._parent);
- return true;
- }
- else {
- return false;
- }
- }
- /**
- * Creates a new `NodeList`.
- *
- * @param root - root node
- */
- static _create(root) {
- return new NodeListImpl(root);
- }
-}
-exports.NodeListImpl = NodeListImpl;
-//# sourceMappingURL=NodeListImpl.js.map
-
-/***/ }),
-
-/***/ 7654:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.NodeListStaticImpl = void 0;
-const DOMImpl_1 = __nccwpck_require__(698);
-const util_1 = __nccwpck_require__(7061);
-/**
- * Represents an ordered list of nodes.
- * This is a static implementation of `NodeList`.
- */
-class NodeListStaticImpl {
- _live = false;
- _root;
- _filter;
- _items = [];
- _length = 0;
- /**
- * Initializes a new instance of `NodeList`.
- *
- * @param root - root node
- */
- constructor(root) {
- this._root = root;
- this._items = [];
- this._filter = function (node) { return true; };
- return new Proxy(this, this);
- }
- /** @inheritdoc */
- get length() {
- /**
- * The length attribute must return the number of nodes represented by
- * the collection.
- */
- return this._items.length;
- }
- /** @inheritdoc */
- item(index) {
- /**
- * The item(index) method must return the indexth node in the collection.
- * If there is no indexth node in the collection, then the method must
- * return null.
- */
- if (index < 0 || index > this.length - 1)
- return null;
- return this._items[index];
- }
- /** @inheritdoc */
- keys() {
- return {
- [Symbol.iterator]: function () {
- let index = 0;
- return {
- next: function () {
- if (index === this.length) {
- return { done: true, value: null };
- }
- else {
- return { done: false, value: index++ };
- }
- }.bind(this)
- };
- }.bind(this)
- };
- }
- /** @inheritdoc */
- values() {
- return {
- [Symbol.iterator]: function () {
- const it = this[Symbol.iterator]();
- return {
- next() {
- return it.next();
- }
- };
- }.bind(this)
- };
- }
- /** @inheritdoc */
- entries() {
- return {
- [Symbol.iterator]: function () {
- const it = this[Symbol.iterator]();
- let index = 0;
- return {
- next() {
- const itResult = it.next();
- if (itResult.done) {
- return { done: true, value: null };
- }
- else {
- return { done: false, value: [index++, itResult.value] };
- }
- }
- };
- }.bind(this)
- };
- }
- /** @inheritdoc */
- [Symbol.iterator]() {
- const it = this._items[Symbol.iterator]();
- return {
- next() {
- return it.next();
- }
- };
- }
- /** @inheritdoc */
- forEach(callback, thisArg) {
- if (thisArg === undefined) {
- thisArg = DOMImpl_1.dom.window;
- }
- let index = 0;
- for (const node of this._items) {
- callback.call(thisArg, node, index++, this);
- }
- }
- /**
- * Implements a proxy get trap to provide array-like access.
- */
- get(target, key, receiver) {
- if (!(0, util_1.isString)(key)) {
- return Reflect.get(target, key, receiver);
- }
- const index = Number(key);
- if (isNaN(index)) {
- return Reflect.get(target, key, receiver);
- }
- return target._items[index] || undefined;
- }
- /**
- * Implements a proxy set trap to provide array-like access.
- */
- set(target, key, value, receiver) {
- if (!(0, util_1.isString)(key)) {
- return Reflect.set(target, key, value, receiver);
- }
- const index = Number(key);
- if (isNaN(index)) {
- return Reflect.set(target, key, value, receiver);
- }
- if (index >= 0 && index < target._items.length) {
- target._items[index] = value;
- return true;
- }
- else {
- return false;
- }
- }
- /**
- * Creates a new `NodeList`.
- *
- * @param root - root node
- * @param items - a list of items to initialize the list
- */
- static _create(root, items) {
- const list = new NodeListStaticImpl(root);
- list._items = items;
- return list;
- }
-}
-exports.NodeListStaticImpl = NodeListStaticImpl;
-//# sourceMappingURL=NodeListStaticImpl.js.map
-
-/***/ }),
-
-/***/ 2256:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.NonDocumentTypeChildNodeImpl = void 0;
-const util_1 = __nccwpck_require__(8247);
-/**
- * Represents a mixin that extends child nodes that can have siblings
- * other than doctypes. This mixin is implemented by {@link Element} and
- * {@link CharacterData}.
- */
-class NonDocumentTypeChildNodeImpl {
- /** @inheritdoc */
- get previousElementSibling() {
- /**
- * The previousElementSibling attribute’s getter must return the first
- * preceding sibling that is an element, and null otherwise.
- */
- let node = util_1.Cast.asNode(this)._previousSibling;
- while (node) {
- if (util_1.Guard.isElementNode(node))
- return node;
- else
- node = node._previousSibling;
- }
- return null;
- }
- /** @inheritdoc */
- get nextElementSibling() {
- /**
- * The nextElementSibling attribute’s getter must return the first
- * following sibling that is an element, and null otherwise.
- */
- let node = util_1.Cast.asNode(this)._nextSibling;
- while (node) {
- if (util_1.Guard.isElementNode(node))
- return node;
- else
- node = node._nextSibling;
- }
- return null;
- }
-}
-exports.NonDocumentTypeChildNodeImpl = NonDocumentTypeChildNodeImpl;
-//# sourceMappingURL=NonDocumentTypeChildNodeImpl.js.map
-
-/***/ }),
-
-/***/ 5325:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.NonElementParentNodeImpl = void 0;
-const util_1 = __nccwpck_require__(8247);
-const algorithm_1 = __nccwpck_require__(6573);
-/**
- * Represents a mixin that extends non-element parent nodes. This mixin
- * is implemented by {@link Document} and {@link DocumentFragment}.
- */
-class NonElementParentNodeImpl {
- /** @inheritdoc */
- getElementById(id) {
- /**
- * The getElementById(elementId) method, when invoked, must return the first
- * element, in tree order, within the context object’s descendants,
- * whose ID is elementId, and null if there is no such element otherwise.
- */
- let ele = (0, algorithm_1.tree_getFirstDescendantNode)(util_1.Cast.asNode(this), false, false, (e) => util_1.Guard.isElementNode(e));
- while (ele !== null) {
- if (ele._uniqueIdentifier === id) {
- return ele;
- }
- ele = (0, algorithm_1.tree_getNextDescendantNode)(util_1.Cast.asNode(this), ele, false, false, (e) => util_1.Guard.isElementNode(e));
- }
- return null;
- }
-}
-exports.NonElementParentNodeImpl = NonElementParentNodeImpl;
-//# sourceMappingURL=NonElementParentNodeImpl.js.map
-
-/***/ }),
-
-/***/ 1824:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.ParentNodeImpl = void 0;
-const util_1 = __nccwpck_require__(8247);
-const algorithm_1 = __nccwpck_require__(6573);
-/**
- * Represents a mixin that extends parent nodes that can have children.
- * This mixin is implemented by {@link Element}, {@link Document} and
- * {@link DocumentFragment}.
- */
-class ParentNodeImpl {
- /** @inheritdoc */
- get children() {
- /**
- * The children attribute’s getter must return an HTMLCollection collection
- * rooted at context object matching only element children.
- */
- return (0, algorithm_1.create_htmlCollection)(util_1.Cast.asNode(this));
- }
- /** @inheritdoc */
- get firstElementChild() {
- /**
- * The firstElementChild attribute’s getter must return the first child
- * that is an element, and null otherwise.
- */
- let node = util_1.Cast.asNode(this)._firstChild;
- while (node) {
- if (util_1.Guard.isElementNode(node))
- return node;
- else
- node = node._nextSibling;
- }
- return null;
- }
- /** @inheritdoc */
- get lastElementChild() {
- /**
- * The lastElementChild attribute’s getter must return the last child that
- * is an element, and null otherwise.
- */
- let node = util_1.Cast.asNode(this)._lastChild;
- while (node) {
- if (util_1.Guard.isElementNode(node))
- return node;
- else
- node = node._previousSibling;
- }
- return null;
- }
- /** @inheritdoc */
- get childElementCount() {
- /**
- * The childElementCount attribute’s getter must return the number of
- * children of context object that are elements.
- */
- let count = 0;
- for (const childNode of util_1.Cast.asNode(this)._children) {
- if (util_1.Guard.isElementNode(childNode))
- count++;
- }
- return count;
- }
- /** @inheritdoc */
- prepend(...nodes) {
- /**
- * 1. Let node be the result of converting nodes into a node given nodes
- * and context object’s node document.
- * 2. Pre-insert node into context object before the context object’s first
- * child.
- */
- const node = util_1.Cast.asNode(this);
- const childNode = (0, algorithm_1.parentNode_convertNodesIntoANode)(nodes, node._nodeDocument);
- (0, algorithm_1.mutation_preInsert)(childNode, node, node._firstChild);
- }
- /** @inheritdoc */
- append(...nodes) {
- /**
- * 1. Let node be the result of converting nodes into a node given nodes
- * and context object’s node document.
- * 2. Append node to context object.
- */
- const node = util_1.Cast.asNode(this);
- const childNode = (0, algorithm_1.parentNode_convertNodesIntoANode)(nodes, node._nodeDocument);
- (0, algorithm_1.mutation_append)(childNode, node);
- }
- /** @inheritdoc */
- querySelector(selectors) {
- /**
- * The querySelector(selectors) method, when invoked, must return the first
- * result of running scope-match a selectors string selectors against
- * context object, if the result is not an empty list, and null otherwise.
- */
- const node = util_1.Cast.asNode(this);
- const result = (0, algorithm_1.selectors_scopeMatchASelectorsString)(selectors, node);
- return (result.length === 0 ? null : result[0]);
- }
- /** @inheritdoc */
- querySelectorAll(selectors) {
- /**
- * The querySelectorAll(selectors) method, when invoked, must return the
- * static result of running scope-match a selectors string selectors against
- * context object.
- */
- const node = util_1.Cast.asNode(this);
- const result = (0, algorithm_1.selectors_scopeMatchASelectorsString)(selectors, node);
- return (0, algorithm_1.create_nodeListStatic)(node, result);
- }
-}
-exports.ParentNodeImpl = ParentNodeImpl;
-//# sourceMappingURL=ParentNodeImpl.js.map
-
-/***/ }),
-
-/***/ 2755:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.ProcessingInstructionImpl = void 0;
-const interfaces_1 = __nccwpck_require__(9454);
-const CharacterDataImpl_1 = __nccwpck_require__(765);
-const WebIDLAlgorithm_1 = __nccwpck_require__(4239);
-/**
- * Represents a processing instruction node.
- */
-class ProcessingInstructionImpl extends CharacterDataImpl_1.CharacterDataImpl {
- _nodeType = interfaces_1.NodeType.ProcessingInstruction;
- _target;
- /**
- * Initializes a new instance of `ProcessingInstruction`.
- */
- constructor(target, data) {
- super(data);
- this._target = target;
- }
- /**
- * Gets the target of the {@link ProcessingInstruction} node.
- */
- get target() { return this._target; }
- /**
- * Creates a new `ProcessingInstruction`.
- *
- * @param document - owner document
- * @param target - instruction target
- * @param data - node contents
- */
- static _create(document, target, data) {
- const node = new ProcessingInstructionImpl(target, data);
- node._nodeDocument = document;
- return node;
- }
-}
-exports.ProcessingInstructionImpl = ProcessingInstructionImpl;
-/**
- * Initialize prototype properties
- */
-(0, WebIDLAlgorithm_1.idl_defineConst)(ProcessingInstructionImpl.prototype, "_nodeType", interfaces_1.NodeType.ProcessingInstruction);
-//# sourceMappingURL=ProcessingInstructionImpl.js.map
-
-/***/ }),
-
-/***/ 3691:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.RangeImpl = void 0;
-const DOMImpl_1 = __nccwpck_require__(698);
-const interfaces_1 = __nccwpck_require__(9454);
-const AbstractRangeImpl_1 = __nccwpck_require__(3773);
-const DOMException_1 = __nccwpck_require__(7175);
-const algorithm_1 = __nccwpck_require__(6573);
-const WebIDLAlgorithm_1 = __nccwpck_require__(4239);
-const util_1 = __nccwpck_require__(8247);
-/**
- * Represents a live range.
- */
-class RangeImpl extends AbstractRangeImpl_1.AbstractRangeImpl {
- static START_TO_START = 0;
- static START_TO_END = 1;
- static END_TO_END = 2;
- static END_TO_START = 3;
- START_TO_START = 0;
- START_TO_END = 1;
- END_TO_END = 2;
- END_TO_START = 3;
- _start;
- _end;
- /**
- * Initializes a new instance of `Range`.
- */
- constructor() {
- super();
- /**
- * The Range() constructor, when invoked, must return a new live range with
- * (current global object’s associated Document, 0) as its start and end.
- */
- const doc = DOMImpl_1.dom.window._associatedDocument;
- this._start = [doc, 0];
- this._end = [doc, 0];
- DOMImpl_1.dom.rangeList.add(this);
- }
- /** @inheritdoc */
- get commonAncestorContainer() {
- /**
- * 1. Let container be start node.
- * 2. While container is not an inclusive ancestor of end node, let
- * container be container’s parent.
- * 3. Return container.
- */
- let container = this._start[0];
- while (!(0, algorithm_1.tree_isAncestorOf)(this._end[0], container, true)) {
- if (container._parent === null) {
- throw new Error("Parent node is null.");
- }
- container = container._parent;
- }
- return container;
- }
- /** @inheritdoc */
- setStart(node, offset) {
- /**
- * The setStart(node, offset) method, when invoked, must set the start of
- * context object to boundary point (node, offset).
- */
- (0, algorithm_1.range_setTheStart)(this, node, offset);
- }
- /** @inheritdoc */
- setEnd(node, offset) {
- /**
- * The setEnd(node, offset) method, when invoked, must set the end of
- * context object to boundary point (node, offset).
- */
- (0, algorithm_1.range_setTheEnd)(this, node, offset);
- }
- /** @inheritdoc */
- setStartBefore(node) {
- /**
- * 1. Let parent be node’s parent.
- * 2. If parent is null, then throw an "InvalidNodeTypeError" DOMException.
- * 3. Set the start of the context object to boundary point
- * (parent, node’s index).
- */
- let parent = node._parent;
- if (parent === null)
- throw new DOMException_1.InvalidNodeTypeError();
- (0, algorithm_1.range_setTheStart)(this, parent, (0, algorithm_1.tree_index)(node));
- }
- /** @inheritdoc */
- setStartAfter(node) {
- /**
- * 1. Let parent be node’s parent.
- * 2. If parent is null, then throw an "InvalidNodeTypeError" DOMException.
- * 3. Set the start of the context object to boundary point
- * (parent, node’s index plus 1).
- */
- let parent = node._parent;
- if (parent === null)
- throw new DOMException_1.InvalidNodeTypeError();
- (0, algorithm_1.range_setTheStart)(this, parent, (0, algorithm_1.tree_index)(node) + 1);
- }
- /** @inheritdoc */
- setEndBefore(node) {
- /**
- * 1. Let parent be node’s parent.
- * 2. If parent is null, then throw an "InvalidNodeTypeError" DOMException.
- * 3. Set the end of the context object to boundary point
- * (parent, node’s index).
- */
- let parent = node._parent;
- if (parent === null)
- throw new DOMException_1.InvalidNodeTypeError();
- (0, algorithm_1.range_setTheEnd)(this, parent, (0, algorithm_1.tree_index)(node));
- }
- /** @inheritdoc */
- setEndAfter(node) {
- /**
- * 1. Let parent be node’s parent.
- * 2. If parent is null, then throw an "InvalidNodeTypeError" DOMException.
- * 3. Set the end of the context object to boundary point
- * (parent, node’s index plus 1).
- */
- let parent = node._parent;
- if (parent === null)
- throw new DOMException_1.InvalidNodeTypeError();
- (0, algorithm_1.range_setTheEnd)(this, parent, (0, algorithm_1.tree_index)(node) + 1);
- }
- /** @inheritdoc */
- collapse(toStart) {
- /**
- * The collapse(toStart) method, when invoked, must if toStart is true,
- * set end to start, and set start to end otherwise.
- */
- if (toStart) {
- this._end = this._start;
- }
- else {
- this._start = this._end;
- }
- }
- /** @inheritdoc */
- selectNode(node) {
- /**
- * The selectNode(node) method, when invoked, must select node within
- * context object.
- */
- (0, algorithm_1.range_select)(node, this);
- }
- /** @inheritdoc */
- selectNodeContents(node) {
- /**
- * 1. If node is a doctype, throw an "InvalidNodeTypeError" DOMException.
- * 2. Let length be the length of node.
- * 3. Set start to the boundary point (node, 0).
- * 4. Set end to the boundary point (node, length).
- */
- if (util_1.Guard.isDocumentTypeNode(node))
- throw new DOMException_1.InvalidNodeTypeError();
- const length = (0, algorithm_1.tree_nodeLength)(node);
- this._start = [node, 0];
- this._end = [node, length];
- }
- /** @inheritdoc */
- compareBoundaryPoints(how, sourceRange) {
- /**
- * 1. If how is not one of
- * - START_TO_START,
- * - START_TO_END,
- * - END_TO_END, and
- * - END_TO_START,
- * then throw a "NotSupportedError" DOMException.
- */
- if (how !== interfaces_1.HowToCompare.StartToStart && how !== interfaces_1.HowToCompare.StartToEnd &&
- how !== interfaces_1.HowToCompare.EndToEnd && how !== interfaces_1.HowToCompare.EndToStart)
- throw new DOMException_1.NotSupportedError();
- /**
- * 2. If context object’s root is not the same as sourceRange’s root,
- * then throw a "WrongDocumentError" DOMException.
- */
- if ((0, algorithm_1.range_root)(this) !== (0, algorithm_1.range_root)(sourceRange))
- throw new DOMException_1.WrongDocumentError();
- /**
- * 3. If how is:
- * - START_TO_START:
- * Let this point be the context object’s start. Let other point be
- * sourceRange’s start.
- * - START_TO_END:
- * Let this point be the context object’s end. Let other point be
- * sourceRange’s start.
- * - END_TO_END:
- * Let this point be the context object’s end. Let other point be
- * sourceRange’s end.
- * - END_TO_START:
- * Let this point be the context object’s start. Let other point be
- * sourceRange’s end.
- */
- let thisPoint;
- let otherPoint;
- switch (how) {
- case interfaces_1.HowToCompare.StartToStart:
- thisPoint = this._start;
- otherPoint = sourceRange._start;
- break;
- case interfaces_1.HowToCompare.StartToEnd:
- thisPoint = this._end;
- otherPoint = sourceRange._start;
- break;
- case interfaces_1.HowToCompare.EndToEnd:
- thisPoint = this._end;
- otherPoint = sourceRange._end;
- break;
- case interfaces_1.HowToCompare.EndToStart:
- thisPoint = this._start;
- otherPoint = sourceRange._end;
- break;
- /* istanbul ignore next */
- default:
- throw new DOMException_1.NotSupportedError();
- }
- /**
- * 4. If the position of this point relative to other point is
- * - before
- * Return −1.
- * - equal
- * Return 0.
- * - after
- * Return 1.
- */
- const position = (0, algorithm_1.boundaryPoint_position)(thisPoint, otherPoint);
- if (position === interfaces_1.BoundaryPosition.Before) {
- return -1;
- }
- else if (position === interfaces_1.BoundaryPosition.After) {
- return 1;
- }
- else {
- return 0;
- }
- }
- /** @inheritdoc */
- deleteContents() {
- /**
- * 1. If the context object is collapsed, then return.
- * 2. Let original start node, original start offset, original end node,
- * and original end offset be the context object’s start node,
- * start offset, end node, and end offset, respectively.
- */
- if ((0, algorithm_1.range_collapsed)(this))
- return;
- const originalStartNode = this._startNode;
- const originalStartOffset = this._startOffset;
- const originalEndNode = this._endNode;
- const originalEndOffset = this._endOffset;
- /**
- * 3. If original start node and original end node are the same, and they
- * are a Text, ProcessingInstruction, or Comment node, replace data with
- * node original start node, offset original start offset, count original
- * end offset minus original start offset, and data the empty string,
- * and then return.
- */
- if (originalStartNode === originalEndNode &&
- util_1.Guard.isCharacterDataNode(originalStartNode)) {
- (0, algorithm_1.characterData_replaceData)(originalStartNode, originalStartOffset, originalEndOffset - originalStartOffset, '');
- return;
- }
- /**
- * 4. Let nodes to remove be a list of all the nodes that are contained in
- * the context object, in tree order, omitting any node whose parent is also
- * contained in the context object.
- */
- const nodesToRemove = [];
- for (const node of (0, algorithm_1.range_getContainedNodes)(this)) {
- const parent = node._parent;
- if (parent !== null && (0, algorithm_1.range_isContained)(parent, this)) {
- continue;
- }
- nodesToRemove.push(node);
- }
- let newNode;
- let newOffset;
- if ((0, algorithm_1.tree_isAncestorOf)(originalEndNode, originalStartNode, true)) {
- /**
- * 5. If original start node is an inclusive ancestor of original end
- * node, set new node to original start node and new offset to original
- * start offset.
- */
- newNode = originalStartNode;
- newOffset = originalStartOffset;
- }
- else {
- /**
- * 6. Otherwise:
- * 6.1. Let reference node equal original start node.
- * 6.2. While reference node’s parent is not null and is not an inclusive
- * ancestor of original end node, set reference node to its parent.
- * 6.3. Set new node to the parent of reference node, and new offset to
- * one plus the index of reference node.
- */
- let referenceNode = originalStartNode;
- while (referenceNode._parent !== null &&
- !(0, algorithm_1.tree_isAncestorOf)(originalEndNode, referenceNode._parent, true)) {
- referenceNode = referenceNode._parent;
- }
- /* istanbul ignore next */
- if (referenceNode._parent === null) {
- throw new Error("Parent node is null.");
- }
- newNode = referenceNode._parent;
- newOffset = (0, algorithm_1.tree_index)(referenceNode) + 1;
- }
- /**
- * 7. If original start node is a Text, ProcessingInstruction, or Comment
- * node, replace data with node original start node, offset original start
- * offset, count original start node’s length minus original start offset,
- * data the empty string.
- */
- if (util_1.Guard.isCharacterDataNode(originalStartNode)) {
- (0, algorithm_1.characterData_replaceData)(originalStartNode, originalStartOffset, (0, algorithm_1.tree_nodeLength)(originalStartNode) - originalStartOffset, '');
- }
- /**
- * 8. For each node in nodes to remove, in tree order, remove node from its
- * parent.
- */
- for (const node of nodesToRemove) {
- /* istanbul ignore else */
- if (node._parent) {
- (0, algorithm_1.mutation_remove)(node, node._parent);
- }
- }
- /**
- * 9. If original end node is a Text, ProcessingInstruction, or Comment
- * node, replace data with node original end node, offset 0, count original
- * end offset and data the empty string.
- */
- if (util_1.Guard.isCharacterDataNode(originalEndNode)) {
- (0, algorithm_1.characterData_replaceData)(originalEndNode, 0, originalEndOffset, '');
- }
- /**
- * 10. Set start and end to (new node, new offset).
- */
- this._start = [newNode, newOffset];
- this._end = [newNode, newOffset];
- }
- /** @inheritdoc */
- extractContents() {
- /**
- * The extractContents() method, when invoked, must return the result of
- * extracting the context object.
- */
- return (0, algorithm_1.range_extract)(this);
- }
- /** @inheritdoc */
- cloneContents() {
- /**
- * The cloneContents() method, when invoked, must return the result of
- * cloning the contents of the context object.
- */
- return (0, algorithm_1.range_cloneTheContents)(this);
- }
- /** @inheritdoc */
- insertNode(node) {
- /**
- * The insertNode(node) method, when invoked, must insert node into the
- * context object.
- */
- return (0, algorithm_1.range_insert)(node, this);
- }
- /** @inheritdoc */
- surroundContents(newParent) {
- /**
- * 1. If a non-Text node is partially contained in the context object, then
- * throw an "InvalidStateError" DOMException.
- */
- for (const node of (0, algorithm_1.range_getPartiallyContainedNodes)(this)) {
- if (!util_1.Guard.isTextNode(node)) {
- throw new DOMException_1.InvalidStateError();
- }
- }
- /**
- * 2. If newParent is a Document, DocumentType, or DocumentFragment node,
- * then throw an "InvalidNodeTypeError" DOMException.
- */
- if (util_1.Guard.isDocumentNode(newParent) ||
- util_1.Guard.isDocumentTypeNode(newParent) ||
- util_1.Guard.isDocumentFragmentNode(newParent)) {
- throw new DOMException_1.InvalidNodeTypeError();
- }
- /**
- * 3. Let fragment be the result of extracting the context object.
- */
- const fragment = (0, algorithm_1.range_extract)(this);
- /**
- * 4. If newParent has children, then replace all with null within newParent.
- */
- if ((newParent)._children.size !== 0) {
- (0, algorithm_1.mutation_replaceAll)(null, newParent);
- }
- /**
- * 5. Insert newParent into the context object.
- * 6. Append fragment to newParent.
- */
- (0, algorithm_1.range_insert)(newParent, this);
- (0, algorithm_1.mutation_append)(fragment, newParent);
- /**
- * 7. Select newParent within the context object.
- */
- (0, algorithm_1.range_select)(newParent, this);
- }
- /** @inheritdoc */
- cloneRange() {
- /**
- * The cloneRange() method, when invoked, must return a new live range with
- * the same start and end as the context object.
- */
- return (0, algorithm_1.create_range)(this._start, this._end);
- }
- /** @inheritdoc */
- detach() {
- /**
- * The detach() method, when invoked, must do nothing.
- *
- * since JS lacks weak references, we still use detach
- */
- DOMImpl_1.dom.rangeList.delete(this);
- }
- /** @inheritdoc */
- isPointInRange(node, offset) {
- /**
- * 1. If node’s root is different from the context object’s root, return false.
- */
- if ((0, algorithm_1.tree_rootNode)(node) !== (0, algorithm_1.range_root)(this)) {
- return false;
- }
- /**
- * 2. If node is a doctype, then throw an "InvalidNodeTypeError" DOMException.
- * 3. If offset is greater than node’s length, then throw an
- * "IndexSizeError" DOMException.
- */
- if (util_1.Guard.isDocumentTypeNode(node))
- throw new DOMException_1.InvalidNodeTypeError();
- if (offset > (0, algorithm_1.tree_nodeLength)(node))
- throw new DOMException_1.IndexSizeError();
- /**
- * 4. If (node, offset) is before start or after end, return false.
- */
- const bp = [node, offset];
- if ((0, algorithm_1.boundaryPoint_position)(bp, this._start) === interfaces_1.BoundaryPosition.Before ||
- (0, algorithm_1.boundaryPoint_position)(bp, this._end) === interfaces_1.BoundaryPosition.After) {
- return false;
- }
- /**
- * 5. Return true.
- */
- return true;
- }
- /** @inheritdoc */
- comparePoint(node, offset) {
- /**
- * 1. If node’s root is different from the context object’s root, then throw
- * a "WrongDocumentError" DOMException.
- * 2. If node is a doctype, then throw an "InvalidNodeTypeError" DOMException.
- * 3. If offset is greater than node’s length, then throw an
- * "IndexSizeError" DOMException.
- */
- if ((0, algorithm_1.tree_rootNode)(node) !== (0, algorithm_1.range_root)(this))
- throw new DOMException_1.WrongDocumentError();
- if (util_1.Guard.isDocumentTypeNode(node))
- throw new DOMException_1.InvalidNodeTypeError();
- if (offset > (0, algorithm_1.tree_nodeLength)(node))
- throw new DOMException_1.IndexSizeError();
- /**
- * 4. If (node, offset) is before start, return −1.
- * 5. If (node, offset) is after end, return 1.
- * 6. Return 0.
- */
- const bp = [node, offset];
- if ((0, algorithm_1.boundaryPoint_position)(bp, this._start) === interfaces_1.BoundaryPosition.Before) {
- return -1;
- }
- else if ((0, algorithm_1.boundaryPoint_position)(bp, this._end) === interfaces_1.BoundaryPosition.After) {
- return 1;
- }
- else {
- return 0;
- }
- }
- /** @inheritdoc */
- intersectsNode(node) {
- /**
- * 1. If node’s root is different from the context object’s root, return false.
- */
- if ((0, algorithm_1.tree_rootNode)(node) !== (0, algorithm_1.range_root)(this)) {
- return false;
- }
- /**
- * 2. Let parent be node’s parent.
- * 3. If parent is null, return true.
- */
- const parent = node._parent;
- if (parent === null)
- return true;
- /**
- * 4. Let offset be node’s index.
- */
- const offset = (0, algorithm_1.tree_index)(node);
- /**
- * 5. If (parent, offset) is before end and (parent, offset plus 1) is
- * after start, return true.
- */
- if ((0, algorithm_1.boundaryPoint_position)([parent, offset], this._end) === interfaces_1.BoundaryPosition.Before &&
- (0, algorithm_1.boundaryPoint_position)([parent, offset + 1], this._start) === interfaces_1.BoundaryPosition.After) {
- return true;
- }
- /**
- * 6. Return false.
- */
- return false;
- }
- toString() {
- /**
- * 1. Let s be the empty string.
- */
- let s = '';
- /**
- * 2. If the context object’s start node is the context object’s end node
- * and it is a Text node, then return the substring of that Text node’s data
- * beginning at the context object’s start offset and ending at the context
- * object’s end offset.
- */
- if (this._startNode === this._endNode && util_1.Guard.isTextNode(this._startNode)) {
- return this._startNode._data.substring(this._startOffset, this._endOffset);
- }
- /**
- * 3. If the context object’s start node is a Text node, then append the
- * substring of that node’s data from the context object’s start offset
- * until the end to s.
- */
- if (util_1.Guard.isTextNode(this._startNode)) {
- s += this._startNode._data.substring(this._startOffset);
- }
- /**
- * 4. Append the concatenation of the data of all Text nodes that are
- * contained in the context object, in tree order, to s.
- */
- for (const child of (0, algorithm_1.range_getContainedNodes)(this)) {
- if (util_1.Guard.isTextNode(child)) {
- s += child._data;
- }
- }
- /**
- * 5. If the context object’s end node is a Text node, then append the
- * substring of that node’s data from its start until the context object’s
- * end offset to s.
- */
- if (util_1.Guard.isTextNode(this._endNode)) {
- s += this._endNode._data.substring(0, this._endOffset);
- }
- /**
- * 6. Return s.
- */
- return s;
- }
- /**
- * Creates a new `Range`.
- *
- * @param start - start point
- * @param end - end point
- */
- static _create(start, end) {
- const range = new RangeImpl();
- if (start)
- range._start = start;
- if (end)
- range._end = end;
- return range;
- }
-}
-exports.RangeImpl = RangeImpl;
-/**
- * Define constants on prototype.
- */
-(0, WebIDLAlgorithm_1.idl_defineConst)(RangeImpl.prototype, "START_TO_START", 0);
-(0, WebIDLAlgorithm_1.idl_defineConst)(RangeImpl.prototype, "START_TO_END", 1);
-(0, WebIDLAlgorithm_1.idl_defineConst)(RangeImpl.prototype, "END_TO_END", 2);
-(0, WebIDLAlgorithm_1.idl_defineConst)(RangeImpl.prototype, "END_TO_START", 3);
-//# sourceMappingURL=RangeImpl.js.map
-
-/***/ }),
-
-/***/ 6092:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.ShadowRootImpl = void 0;
-const DocumentFragmentImpl_1 = __nccwpck_require__(9793);
-const util_1 = __nccwpck_require__(7061);
-const algorithm_1 = __nccwpck_require__(6573);
-/**
- * Represents a shadow root.
- */
-class ShadowRootImpl extends DocumentFragmentImpl_1.DocumentFragmentImpl {
- _host;
- _mode;
- /**
- * Initializes a new instance of `ShadowRoot`.
- *
- * @param host - shadow root's host element
- * @param mode - shadow root's mode
- */
- constructor(host, mode) {
- super();
- this._host = host;
- this._mode = mode;
- }
- /** @inheritdoc */
- get mode() { return this._mode; }
- /** @inheritdoc */
- get host() { return this._host; }
- /**
- * Gets the parent event target for the given event.
- *
- * @param event - an event
- */
- _getTheParent(event) {
- /**
- * A shadow root’s get the parent algorithm, given an event, returns null
- * if event’s composed flag is unset and shadow root is the root of
- * event’s path’s first struct’s invocation target, and shadow root’s host
- * otherwise.
- */
- if (!event._composedFlag && !(0, util_1.isEmpty)(event._path) &&
- (0, algorithm_1.tree_rootNode)(event._path[0].invocationTarget) === this) {
- return null;
- }
- else {
- return this._host;
- }
- }
- // MIXIN: DocumentOrShadowRoot
- // No elements
- /**
- * Creates a new `ShadowRoot`.
- *
- * @param document - owner document
- * @param host - shadow root's host element
- */
- static _create(document, host) {
- return new ShadowRootImpl(host, "closed");
- }
-}
-exports.ShadowRootImpl = ShadowRootImpl;
-//# sourceMappingURL=ShadowRootImpl.js.map
-
-/***/ }),
-
-/***/ 3940:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.SlotableImpl = void 0;
-const algorithm_1 = __nccwpck_require__(6573);
-/**
- * Represents a mixin that allows nodes to become the contents of
- * a element. This mixin is implemented by {@link Element} and
- * {@link Text}.
- */
-class SlotableImpl {
- __name;
- __assignedSlot;
- get _name() { return this.__name || ''; }
- set _name(val) { this.__name = val; }
- get _assignedSlot() { return this.__assignedSlot || null; }
- set _assignedSlot(val) { this.__assignedSlot = val; }
- /** @inheritdoc */
- get assignedSlot() {
- return (0, algorithm_1.shadowTree_findASlot)(this, true);
- }
-}
-exports.SlotableImpl = SlotableImpl;
-//# sourceMappingURL=SlotableImpl.js.map
-
-/***/ }),
-
-/***/ 7685:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.StaticRangeImpl = void 0;
-const AbstractRangeImpl_1 = __nccwpck_require__(3773);
-const DOMException_1 = __nccwpck_require__(7175);
-const util_1 = __nccwpck_require__(8247);
-/**
- * Represents a static range.
- */
-class StaticRangeImpl extends AbstractRangeImpl_1.AbstractRangeImpl {
- _start;
- _end;
- /**
- * Initializes a new instance of `StaticRange`.
- */
- constructor(init) {
- super();
- /**
- * 1. If init’s startContainer or endContainer is a DocumentType or Attr
- * node, then throw an "InvalidNodeTypeError" DOMException.
- * 2. Let staticRange be a new StaticRange object.
- * 3. Set staticRange’s start to (init’s startContainer, init’s startOffset)
- * and end to (init’s endContainer, init’s endOffset).
- * 4. Return staticRange.
- */
- if (util_1.Guard.isDocumentTypeNode(init.startContainer) || util_1.Guard.isAttrNode(init.startContainer) ||
- util_1.Guard.isDocumentTypeNode(init.endContainer) || util_1.Guard.isAttrNode(init.endContainer)) {
- throw new DOMException_1.InvalidNodeTypeError();
- }
- this._start = [init.startContainer, init.startOffset];
- this._end = [init.endContainer, init.endOffset];
- }
-}
-exports.StaticRangeImpl = StaticRangeImpl;
-//# sourceMappingURL=StaticRangeImpl.js.map
-
-/***/ }),
-
-/***/ 4063:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.TextImpl = void 0;
-const interfaces_1 = __nccwpck_require__(9454);
-const CharacterDataImpl_1 = __nccwpck_require__(765);
-const algorithm_1 = __nccwpck_require__(6573);
-const WebIDLAlgorithm_1 = __nccwpck_require__(4239);
-/**
- * Represents a text node.
- */
-class TextImpl extends CharacterDataImpl_1.CharacterDataImpl {
- _nodeType = interfaces_1.NodeType.Text;
- _name = '';
- _assignedSlot = null;
- /**
- * Initializes a new instance of `Text`.
- *
- * @param data - the text content
- */
- constructor(data = '') {
- super(data);
- }
- /** @inheritdoc */
- get wholeText() {
- /**
- * The wholeText attribute’s getter must return the concatenation of the
- * data of the contiguous Text nodes of the context object, in tree order.
- */
- let text = '';
- for (const node of (0, algorithm_1.text_contiguousTextNodes)(this, true)) {
- text = text + node._data;
- }
- return text;
- }
- /** @inheritdoc */
- splitText(offset) {
- /**
- * The splitText(offset) method, when invoked, must split context object
- * with offset offset.
- */
- return (0, algorithm_1.text_split)(this, offset);
- }
- // MIXIN: Slotable
- /* istanbul ignore next */
- get assignedSlot() { throw new Error("Mixin: Slotable not implemented."); }
- /**
- * Creates a `Text`.
- *
- * @param document - owner document
- * @param data - the text content
- */
- static _create(document, data = '') {
- const node = new TextImpl(data);
- node._nodeDocument = document;
- return node;
- }
-}
-exports.TextImpl = TextImpl;
-/**
- * Initialize prototype properties
- */
-(0, WebIDLAlgorithm_1.idl_defineConst)(TextImpl.prototype, "_nodeType", interfaces_1.NodeType.Text);
-//# sourceMappingURL=TextImpl.js.map
-
-/***/ }),
-
-/***/ 8506:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.TraverserImpl = void 0;
-const interfaces_1 = __nccwpck_require__(9454);
-/**
- * Represents an object which can be used to iterate through the nodes
- * of a subtree.
- */
-class TraverserImpl {
- _activeFlag;
- _root;
- _whatToShow;
- _filter;
- /**
- * Initializes a new instance of `Traverser`.
- *
- * @param root - root node
- */
- constructor(root) {
- this._activeFlag = false;
- this._root = root;
- this._whatToShow = interfaces_1.WhatToShow.All;
- this._filter = null;
- }
- /** @inheritdoc */
- get root() { return this._root; }
- /** @inheritdoc */
- get whatToShow() { return this._whatToShow; }
- /** @inheritdoc */
- get filter() { return this._filter; }
-}
-exports.TraverserImpl = TraverserImpl;
-//# sourceMappingURL=TraverserImpl.js.map
-
-/***/ }),
-
-/***/ 6254:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.TreeWalkerImpl = void 0;
-const interfaces_1 = __nccwpck_require__(9454);
-const TraverserImpl_1 = __nccwpck_require__(8506);
-const algorithm_1 = __nccwpck_require__(6573);
-/**
- * Represents the nodes of a subtree and a position within them.
- */
-class TreeWalkerImpl extends TraverserImpl_1.TraverserImpl {
- _current;
- /**
- * Initializes a new instance of `TreeWalker`.
- */
- constructor(root, current) {
- super(root);
- this._current = current;
- }
- /** @inheritdoc */
- get currentNode() { return this._current; }
- set currentNode(value) { this._current = value; }
- /** @inheritdoc */
- parentNode() {
- /**
- * 1. Let node be the context object’s current.
- * 2. While node is non-null and is not the context object’s root:
- */
- let node = this._current;
- while (node !== null && node !== this._root) {
- /**
- * 2.1. Set node to node’s parent.
- * 2.2. If node is non-null and filtering node within the context object
- * returns FILTER_ACCEPT, then set the context object’s current to node
- * and return node.
- */
- node = node._parent;
- if (node !== null &&
- (0, algorithm_1.traversal_filter)(this, node) === interfaces_1.FilterResult.Accept) {
- this._current = node;
- return node;
- }
- }
- /**
- * 3. Return null.
- */
- return null;
- }
- /** @inheritdoc */
- firstChild() {
- /**
- * The firstChild() method, when invoked, must traverse children with the
- * context object and first.
- */
- return (0, algorithm_1.treeWalker_traverseChildren)(this, true);
- }
- /** @inheritdoc */
- lastChild() {
- /**
- * The lastChild() method, when invoked, must traverse children with the
- * context object and last.
- */
- return (0, algorithm_1.treeWalker_traverseChildren)(this, false);
- }
- /** @inheritdoc */
- nextSibling() {
- /**
- * The nextSibling() method, when invoked, must traverse siblings with the
- * context object and next.
- */
- return (0, algorithm_1.treeWalker_traverseSiblings)(this, true);
- }
- /** @inheritdoc */
- previousNode() {
- /**
- * 1. Let node be the context object’s current.
- * 2. While node is not the context object’s root:
- */
- let node = this._current;
- while (node !== this._root) {
- /**
- * 2.1. Let sibling be node’s previous sibling.
- * 2.2. While sibling is non-null:
- */
- let sibling = node._previousSibling;
- while (sibling) {
- /**
- * 2.2.1. Set node to sibling.
- * 2.2.2. Let result be the result of filtering node within the context
- * object.
- */
- node = sibling;
- let result = (0, algorithm_1.traversal_filter)(this, node);
- /**
- * 2.2.3. While result is not FILTER_REJECT and node has a child:
- */
- while (result !== interfaces_1.FilterResult.Reject && node._lastChild) {
- /**
- * 2.2.3.1. Set node to node’s last child.
- * 2.2.3.2. Set result to the result of filtering node within the
- * context object.
- */
- node = node._lastChild;
- result = (0, algorithm_1.traversal_filter)(this, node);
- }
- /**
- * 2.2.4. If result is FILTER_ACCEPT, then set the context object’s
- * current to node and return node.
- */
- if (result === interfaces_1.FilterResult.Accept) {
- this._current = node;
- return node;
- }
- /**
- * 2.2.5. Set sibling to node’s previous sibling.
- */
- sibling = node._previousSibling;
- }
- /**
- * 2.3. If node is the context object’s root or node’s parent is null,
- * then return null.
- */
- if (node === this._root || node._parent === null) {
- return null;
- }
- /**
- * 2.4. Set node to node’s parent.
- */
- node = node._parent;
- /**
- * 2.5. If the return value of filtering node within the context object is
- * FILTER_ACCEPT, then set the context object’s current to node and
- * return node.
- */
- if ((0, algorithm_1.traversal_filter)(this, node) === interfaces_1.FilterResult.Accept) {
- this._current = node;
- return node;
- }
- }
- /**
- * 3. Return null.
- */
- return null;
- }
- /** @inheritdoc */
- previousSibling() {
- /**
- * The previousSibling() method, when invoked, must traverse siblings with
- * the context object and previous.
- */
- return (0, algorithm_1.treeWalker_traverseSiblings)(this, false);
- }
- /** @inheritdoc */
- nextNode() {
- /**
- * 1. Let node be the context object’s current.
- * 2. Let result be FILTER_ACCEPT.
- * 3. While true:
- */
- let node = this._current;
- let result = interfaces_1.FilterResult.Accept;
- while (true) {
- /**
- * 3.1. While result is not FILTER_REJECT and node has a child:
- */
- while (result !== interfaces_1.FilterResult.Reject && node._firstChild) {
- /**
- * 3.1.1. Set node to its first child.
- * 3.1.2. Set result to the result of filtering node within the context
- * object.
- * 3.1.3. If result is FILTER_ACCEPT, then set the context object’s
- * current to node and return node.
- */
- node = node._firstChild;
- result = (0, algorithm_1.traversal_filter)(this, node);
- if (result === interfaces_1.FilterResult.Accept) {
- this._current = node;
- return node;
- }
- }
- /**
- * 3.2. Let sibling be null.
- * 3.3. Let temporary be node.
- * 3.4. While temporary is non-null:
- */
- let sibling = null;
- let temporary = node;
- while (temporary !== null) {
- /**
- * 3.4.1. If temporary is the context object’s root, then return null.
- */
- if (temporary === this._root) {
- return null;
- }
- /**
- * 3.4.2. Set sibling to temporary’s next sibling.
- * 3.4.3. If sibling is non-null, then break.
- */
- sibling = temporary._nextSibling;
- if (sibling !== null) {
- node = sibling;
- break;
- }
- /**
- * 3.4.4. Set temporary to temporary’s parent.
- */
- temporary = temporary._parent;
- }
- /**
- * 3.5. Set result to the result of filtering node within the context object.
- * 3.6. If result is FILTER_ACCEPT, then set the context object’s current
- * to node and return node.
- */
- result = (0, algorithm_1.traversal_filter)(this, node);
- if (result === interfaces_1.FilterResult.Accept) {
- this._current = node;
- return node;
- }
- }
- }
- /**
- * Creates a new `TreeWalker`.
- *
- * @param root - iterator's root node
- * @param current - current node
- */
- static _create(root, current) {
- return new TreeWalkerImpl(root, current);
- }
-}
-exports.TreeWalkerImpl = TreeWalkerImpl;
-//# sourceMappingURL=TreeWalkerImpl.js.map
-
-/***/ }),
-
-/***/ 1448:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.WindowImpl = void 0;
-const EventTargetImpl_1 = __nccwpck_require__(3611);
-const util_1 = __nccwpck_require__(7061);
-const algorithm_1 = __nccwpck_require__(6573);
-/**
- * Represents a window containing a DOM document.
- */
-class WindowImpl extends EventTargetImpl_1.EventTargetImpl {
- _currentEvent;
- _signalSlots = new Set();
- _mutationObserverMicrotaskQueued = false;
- _mutationObservers = new Set();
- _associatedDocument;
- _iteratorList = new util_1.FixedSizeSet();
- /**
- * Initializes a new instance of `Window`.
- */
- constructor() {
- super();
- this._associatedDocument = (0, algorithm_1.create_document)();
- }
- /** @inheritdoc */
- get document() { return this._associatedDocument; }
- /** @inheritdoc */
- get event() { return this._currentEvent; }
- /**
- * Creates a new window with a blank document.
- */
- static _create() {
- return new WindowImpl();
- }
-}
-exports.WindowImpl = WindowImpl;
-//# sourceMappingURL=WindowImpl.js.map
-
-/***/ }),
-
-/***/ 4602:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.XMLDocumentImpl = void 0;
-const DocumentImpl_1 = __nccwpck_require__(2113);
-/**
- * Represents an XML document.
- */
-class XMLDocumentImpl extends DocumentImpl_1.DocumentImpl {
- /**
- * Initializes a new instance of `XMLDocument`.
- */
- constructor() {
- super();
- }
-}
-exports.XMLDocumentImpl = XMLDocumentImpl;
-//# sourceMappingURL=XMLDocumentImpl.js.map
-
-/***/ }),
-
-/***/ 4204:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.XMLDocument = exports.Window = exports.TreeWalker = exports.Traverser = exports.Text = exports.StaticRange = exports.ShadowRoot = exports.Range = exports.ProcessingInstruction = exports.NodeListStatic = exports.NodeList = exports.NodeIterator = exports.Node = exports.NodeFilter = exports.NamedNodeMap = exports.MutationRecord = exports.MutationObserver = exports.HTMLCollection = exports.EventTarget = exports.Event = exports.Element = exports.DOMTokenList = exports.DOMImplementation = exports.dom = exports.DocumentType = exports.Document = exports.DocumentFragment = exports.CustomEvent = exports.Comment = exports.CharacterData = exports.CDATASection = exports.Attr = exports.AbstractRange = exports.AbortSignal = exports.AbortController = void 0;
-const util_1 = __nccwpck_require__(7061);
-// Import implementation classes
-const AbortControllerImpl_1 = __nccwpck_require__(7528);
-Object.defineProperty(exports, "AbortController", ({ enumerable: true, get: function () { return AbortControllerImpl_1.AbortControllerImpl; } }));
-const AbortSignalImpl_1 = __nccwpck_require__(4560);
-Object.defineProperty(exports, "AbortSignal", ({ enumerable: true, get: function () { return AbortSignalImpl_1.AbortSignalImpl; } }));
-const AbstractRangeImpl_1 = __nccwpck_require__(3773);
-Object.defineProperty(exports, "AbstractRange", ({ enumerable: true, get: function () { return AbstractRangeImpl_1.AbstractRangeImpl; } }));
-const AttrImpl_1 = __nccwpck_require__(2875);
-Object.defineProperty(exports, "Attr", ({ enumerable: true, get: function () { return AttrImpl_1.AttrImpl; } }));
-const CDATASectionImpl_1 = __nccwpck_require__(4104);
-Object.defineProperty(exports, "CDATASection", ({ enumerable: true, get: function () { return CDATASectionImpl_1.CDATASectionImpl; } }));
-const CharacterDataImpl_1 = __nccwpck_require__(765);
-Object.defineProperty(exports, "CharacterData", ({ enumerable: true, get: function () { return CharacterDataImpl_1.CharacterDataImpl; } }));
-const ChildNodeImpl_1 = __nccwpck_require__(3728);
-const CommentImpl_1 = __nccwpck_require__(8223);
-Object.defineProperty(exports, "Comment", ({ enumerable: true, get: function () { return CommentImpl_1.CommentImpl; } }));
-const CustomEventImpl_1 = __nccwpck_require__(3171);
-Object.defineProperty(exports, "CustomEvent", ({ enumerable: true, get: function () { return CustomEventImpl_1.CustomEventImpl; } }));
-const DocumentFragmentImpl_1 = __nccwpck_require__(9793);
-Object.defineProperty(exports, "DocumentFragment", ({ enumerable: true, get: function () { return DocumentFragmentImpl_1.DocumentFragmentImpl; } }));
-const DocumentImpl_1 = __nccwpck_require__(2113);
-Object.defineProperty(exports, "Document", ({ enumerable: true, get: function () { return DocumentImpl_1.DocumentImpl; } }));
-const DocumentOrShadowRootImpl_1 = __nccwpck_require__(8024);
-const DocumentTypeImpl_1 = __nccwpck_require__(1401);
-Object.defineProperty(exports, "DocumentType", ({ enumerable: true, get: function () { return DocumentTypeImpl_1.DocumentTypeImpl; } }));
-const DOMImpl_1 = __nccwpck_require__(698);
-Object.defineProperty(exports, "dom", ({ enumerable: true, get: function () { return DOMImpl_1.dom; } }));
-const DOMImplementationImpl_1 = __nccwpck_require__(6348);
-Object.defineProperty(exports, "DOMImplementation", ({ enumerable: true, get: function () { return DOMImplementationImpl_1.DOMImplementationImpl; } }));
-const DOMTokenListImpl_1 = __nccwpck_require__(6629);
-Object.defineProperty(exports, "DOMTokenList", ({ enumerable: true, get: function () { return DOMTokenListImpl_1.DOMTokenListImpl; } }));
-const ElementImpl_1 = __nccwpck_require__(1342);
-Object.defineProperty(exports, "Element", ({ enumerable: true, get: function () { return ElementImpl_1.ElementImpl; } }));
-const EventImpl_1 = __nccwpck_require__(2390);
-Object.defineProperty(exports, "Event", ({ enumerable: true, get: function () { return EventImpl_1.EventImpl; } }));
-const EventTargetImpl_1 = __nccwpck_require__(3611);
-Object.defineProperty(exports, "EventTarget", ({ enumerable: true, get: function () { return EventTargetImpl_1.EventTargetImpl; } }));
-const HTMLCollectionImpl_1 = __nccwpck_require__(9065);
-Object.defineProperty(exports, "HTMLCollection", ({ enumerable: true, get: function () { return HTMLCollectionImpl_1.HTMLCollectionImpl; } }));
-const MutationObserverImpl_1 = __nccwpck_require__(9137);
-Object.defineProperty(exports, "MutationObserver", ({ enumerable: true, get: function () { return MutationObserverImpl_1.MutationObserverImpl; } }));
-const MutationRecordImpl_1 = __nccwpck_require__(33);
-Object.defineProperty(exports, "MutationRecord", ({ enumerable: true, get: function () { return MutationRecordImpl_1.MutationRecordImpl; } }));
-const NamedNodeMapImpl_1 = __nccwpck_require__(3145);
-Object.defineProperty(exports, "NamedNodeMap", ({ enumerable: true, get: function () { return NamedNodeMapImpl_1.NamedNodeMapImpl; } }));
-const NodeFilterImpl_1 = __nccwpck_require__(4649);
-Object.defineProperty(exports, "NodeFilter", ({ enumerable: true, get: function () { return NodeFilterImpl_1.NodeFilterImpl; } }));
-const NodeImpl_1 = __nccwpck_require__(2280);
-Object.defineProperty(exports, "Node", ({ enumerable: true, get: function () { return NodeImpl_1.NodeImpl; } }));
-const NodeIteratorImpl_1 = __nccwpck_require__(4142);
-Object.defineProperty(exports, "NodeIterator", ({ enumerable: true, get: function () { return NodeIteratorImpl_1.NodeIteratorImpl; } }));
-const NodeListImpl_1 = __nccwpck_require__(5788);
-Object.defineProperty(exports, "NodeList", ({ enumerable: true, get: function () { return NodeListImpl_1.NodeListImpl; } }));
-const NodeListStaticImpl_1 = __nccwpck_require__(7654);
-Object.defineProperty(exports, "NodeListStatic", ({ enumerable: true, get: function () { return NodeListStaticImpl_1.NodeListStaticImpl; } }));
-const NonDocumentTypeChildNodeImpl_1 = __nccwpck_require__(2256);
-const NonElementParentNodeImpl_1 = __nccwpck_require__(5325);
-const ParentNodeImpl_1 = __nccwpck_require__(1824);
-const ProcessingInstructionImpl_1 = __nccwpck_require__(2755);
-Object.defineProperty(exports, "ProcessingInstruction", ({ enumerable: true, get: function () { return ProcessingInstructionImpl_1.ProcessingInstructionImpl; } }));
-const RangeImpl_1 = __nccwpck_require__(3691);
-Object.defineProperty(exports, "Range", ({ enumerable: true, get: function () { return RangeImpl_1.RangeImpl; } }));
-const ShadowRootImpl_1 = __nccwpck_require__(6092);
-Object.defineProperty(exports, "ShadowRoot", ({ enumerable: true, get: function () { return ShadowRootImpl_1.ShadowRootImpl; } }));
-const SlotableImpl_1 = __nccwpck_require__(3940);
-const StaticRangeImpl_1 = __nccwpck_require__(7685);
-Object.defineProperty(exports, "StaticRange", ({ enumerable: true, get: function () { return StaticRangeImpl_1.StaticRangeImpl; } }));
-const TextImpl_1 = __nccwpck_require__(4063);
-Object.defineProperty(exports, "Text", ({ enumerable: true, get: function () { return TextImpl_1.TextImpl; } }));
-const TraverserImpl_1 = __nccwpck_require__(8506);
-Object.defineProperty(exports, "Traverser", ({ enumerable: true, get: function () { return TraverserImpl_1.TraverserImpl; } }));
-const TreeWalkerImpl_1 = __nccwpck_require__(6254);
-Object.defineProperty(exports, "TreeWalker", ({ enumerable: true, get: function () { return TreeWalkerImpl_1.TreeWalkerImpl; } }));
-const WindowImpl_1 = __nccwpck_require__(1448);
-Object.defineProperty(exports, "Window", ({ enumerable: true, get: function () { return WindowImpl_1.WindowImpl; } }));
-const XMLDocumentImpl_1 = __nccwpck_require__(4602);
-Object.defineProperty(exports, "XMLDocument", ({ enumerable: true, get: function () { return XMLDocumentImpl_1.XMLDocumentImpl; } }));
-// Apply mixins
-// ChildNode
-(0, util_1.applyMixin)(ElementImpl_1.ElementImpl, ChildNodeImpl_1.ChildNodeImpl);
-(0, util_1.applyMixin)(CharacterDataImpl_1.CharacterDataImpl, ChildNodeImpl_1.ChildNodeImpl);
-(0, util_1.applyMixin)(DocumentTypeImpl_1.DocumentTypeImpl, ChildNodeImpl_1.ChildNodeImpl);
-// DocumentOrShadowRoot
-(0, util_1.applyMixin)(DocumentImpl_1.DocumentImpl, DocumentOrShadowRootImpl_1.DocumentOrShadowRootImpl);
-(0, util_1.applyMixin)(ShadowRootImpl_1.ShadowRootImpl, DocumentOrShadowRootImpl_1.DocumentOrShadowRootImpl);
-// NonDocumentTypeChildNode
-(0, util_1.applyMixin)(ElementImpl_1.ElementImpl, NonDocumentTypeChildNodeImpl_1.NonDocumentTypeChildNodeImpl);
-(0, util_1.applyMixin)(CharacterDataImpl_1.CharacterDataImpl, NonDocumentTypeChildNodeImpl_1.NonDocumentTypeChildNodeImpl);
-// NonElementParentNode
-(0, util_1.applyMixin)(DocumentImpl_1.DocumentImpl, NonElementParentNodeImpl_1.NonElementParentNodeImpl);
-(0, util_1.applyMixin)(DocumentFragmentImpl_1.DocumentFragmentImpl, NonElementParentNodeImpl_1.NonElementParentNodeImpl);
-// ParentNode
-(0, util_1.applyMixin)(DocumentImpl_1.DocumentImpl, ParentNodeImpl_1.ParentNodeImpl);
-(0, util_1.applyMixin)(DocumentFragmentImpl_1.DocumentFragmentImpl, ParentNodeImpl_1.ParentNodeImpl);
-(0, util_1.applyMixin)(ElementImpl_1.ElementImpl, ParentNodeImpl_1.ParentNodeImpl);
-// Slotable
-(0, util_1.applyMixin)(TextImpl_1.TextImpl, SlotableImpl_1.SlotableImpl);
-(0, util_1.applyMixin)(ElementImpl_1.ElementImpl, SlotableImpl_1.SlotableImpl);
-//# sourceMappingURL=index.js.map
-
-/***/ }),
-
-/***/ 9454:
-/***/ ((__unused_webpack_module, exports) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.HowToCompare = exports.WhatToShow = exports.FilterResult = exports.Position = exports.NodeType = exports.EventPhase = exports.BoundaryPosition = void 0;
-/**
- * Defines the position of a boundary point relative to another.
- */
-var BoundaryPosition;
-(function (BoundaryPosition) {
- BoundaryPosition[BoundaryPosition["Before"] = 0] = "Before";
- BoundaryPosition[BoundaryPosition["Equal"] = 1] = "Equal";
- BoundaryPosition[BoundaryPosition["After"] = 2] = "After";
-})(BoundaryPosition || (exports.BoundaryPosition = BoundaryPosition = {}));
-/**
- * Defines the event phase.
- */
-var EventPhase;
-(function (EventPhase) {
- EventPhase[EventPhase["None"] = 0] = "None";
- EventPhase[EventPhase["Capturing"] = 1] = "Capturing";
- EventPhase[EventPhase["AtTarget"] = 2] = "AtTarget";
- EventPhase[EventPhase["Bubbling"] = 3] = "Bubbling";
-})(EventPhase || (exports.EventPhase = EventPhase = {}));
-/**
- * Defines the type of a node object.
- */
-var NodeType;
-(function (NodeType) {
- NodeType[NodeType["Element"] = 1] = "Element";
- NodeType[NodeType["Attribute"] = 2] = "Attribute";
- NodeType[NodeType["Text"] = 3] = "Text";
- NodeType[NodeType["CData"] = 4] = "CData";
- NodeType[NodeType["EntityReference"] = 5] = "EntityReference";
- NodeType[NodeType["Entity"] = 6] = "Entity";
- NodeType[NodeType["ProcessingInstruction"] = 7] = "ProcessingInstruction";
- NodeType[NodeType["Comment"] = 8] = "Comment";
- NodeType[NodeType["Document"] = 9] = "Document";
- NodeType[NodeType["DocumentType"] = 10] = "DocumentType";
- NodeType[NodeType["DocumentFragment"] = 11] = "DocumentFragment";
- NodeType[NodeType["Notation"] = 12] = "Notation"; // historical
-})(NodeType || (exports.NodeType = NodeType = {}));
-/**
- * Defines the position of a node in the document relative to another
- * node.
- */
-var Position;
-(function (Position) {
- Position[Position["SameNode"] = 0] = "SameNode";
- Position[Position["Disconnected"] = 1] = "Disconnected";
- Position[Position["Preceding"] = 2] = "Preceding";
- Position[Position["Following"] = 4] = "Following";
- Position[Position["Contains"] = 8] = "Contains";
- Position[Position["ContainedBy"] = 16] = "ContainedBy";
- Position[Position["ImplementationSpecific"] = 32] = "ImplementationSpecific";
-})(Position || (exports.Position = Position = {}));
-/**
- * Defines the return value of a filter callback.
- */
-var FilterResult;
-(function (FilterResult) {
- FilterResult[FilterResult["Accept"] = 1] = "Accept";
- FilterResult[FilterResult["Reject"] = 2] = "Reject";
- FilterResult[FilterResult["Skip"] = 3] = "Skip";
-})(FilterResult || (exports.FilterResult = FilterResult = {}));
-/**
- * Defines what to show in node filter.
- */
-var WhatToShow;
-(function (WhatToShow) {
- WhatToShow[WhatToShow["All"] = 4294967295] = "All";
- WhatToShow[WhatToShow["Element"] = 1] = "Element";
- WhatToShow[WhatToShow["Attribute"] = 2] = "Attribute";
- WhatToShow[WhatToShow["Text"] = 4] = "Text";
- WhatToShow[WhatToShow["CDataSection"] = 8] = "CDataSection";
- WhatToShow[WhatToShow["EntityReference"] = 16] = "EntityReference";
- WhatToShow[WhatToShow["Entity"] = 32] = "Entity";
- WhatToShow[WhatToShow["ProcessingInstruction"] = 64] = "ProcessingInstruction";
- WhatToShow[WhatToShow["Comment"] = 128] = "Comment";
- WhatToShow[WhatToShow["Document"] = 256] = "Document";
- WhatToShow[WhatToShow["DocumentType"] = 512] = "DocumentType";
- WhatToShow[WhatToShow["DocumentFragment"] = 1024] = "DocumentFragment";
- WhatToShow[WhatToShow["Notation"] = 2048] = "Notation";
-})(WhatToShow || (exports.WhatToShow = WhatToShow = {}));
-/**
- * Defines how boundary points are compared.
- */
-var HowToCompare;
-(function (HowToCompare) {
- HowToCompare[HowToCompare["StartToStart"] = 0] = "StartToStart";
- HowToCompare[HowToCompare["StartToEnd"] = 1] = "StartToEnd";
- HowToCompare[HowToCompare["EndToEnd"] = 2] = "EndToEnd";
- HowToCompare[HowToCompare["EndToStart"] = 3] = "EndToStart";
-})(HowToCompare || (exports.HowToCompare = HowToCompare = {}));
-//# sourceMappingURL=interfaces.js.map
-
-/***/ }),
-
-/***/ 6371:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.XMLSerializer = exports.DOMParser = exports.DOMImplementation = void 0;
-const dom_1 = __nccwpck_require__(4204);
-dom_1.dom.setFeatures(true);
-var dom_2 = __nccwpck_require__(4204);
-Object.defineProperty(exports, "DOMImplementation", ({ enumerable: true, get: function () { return dom_2.DOMImplementation; } }));
-var parser_1 = __nccwpck_require__(8531);
-Object.defineProperty(exports, "DOMParser", ({ enumerable: true, get: function () { return parser_1.DOMParser; } }));
-var serializer_1 = __nccwpck_require__(6052);
-Object.defineProperty(exports, "XMLSerializer", ({ enumerable: true, get: function () { return serializer_1.XMLSerializer; } }));
-//# sourceMappingURL=index.js.map
-
-/***/ }),
-
-/***/ 6182:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.DOMParserImpl = void 0;
-const algorithm_1 = __nccwpck_require__(6573);
-const XMLParserImpl_1 = __nccwpck_require__(3515);
-/**
- * Represents a parser for XML and HTML content.
- *
- * See: https://w3c.github.io/DOM-Parsing/#the-domparser-interface
- */
-class DOMParserImpl {
- /** @inheritdoc */
- parseFromString(source, mimeType) {
- if (mimeType === "text/html")
- throw new Error('HTML parser not implemented.');
- try {
- const parser = new XMLParserImpl_1.XMLParserImpl();
- const doc = parser.parse(source);
- doc._contentType = mimeType;
- return doc;
- }
- catch (e) {
- const errorNS = "http://www.mozilla.org/newlayout/xml/parsererror.xml";
- const doc = (0, algorithm_1.create_xmlDocument)();
- const root = doc.createElementNS(errorNS, "parsererror");
- const ele = doc.createElementNS(errorNS, "error");
- ele.setAttribute("message", e.message);
- root.appendChild(ele);
- doc.appendChild(root);
- return doc;
- }
- }
-}
-exports.DOMParserImpl = DOMParserImpl;
-//# sourceMappingURL=DOMParserImpl.js.map
-
-/***/ }),
-
-/***/ 3515:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.XMLParserImpl = void 0;
-const XMLStringLexer_1 = __nccwpck_require__(3529);
-const interfaces_1 = __nccwpck_require__(4727);
-const infra_1 = __nccwpck_require__(4737);
-const algorithm_1 = __nccwpck_require__(6573);
-const LocalNameSet_1 = __nccwpck_require__(7830);
-/**
- * Represents a parser for XML content.
- *
- * See: https://html.spec.whatwg.org/#xml-parser
- */
-class XMLParserImpl {
- /**
- * Parses XML content.
- *
- * @param source - a string containing XML content
- */
- parse(source) {
- const lexer = new XMLStringLexer_1.XMLStringLexer(source, { skipWhitespaceOnlyText: true });
- const doc = (0, algorithm_1.create_document)();
- let context = doc;
- let token = lexer.nextToken();
- while (token.type !== interfaces_1.TokenType.EOF) {
- switch (token.type) {
- case interfaces_1.TokenType.Declaration:
- const declaration = token;
- if (declaration.version !== "1.0") {
- throw new Error("Invalid xml version: " + declaration.version);
- }
- break;
- case interfaces_1.TokenType.DocType:
- const doctype = token;
- if (!(0, algorithm_1.xml_isPubidChar)(doctype.pubId)) {
- throw new Error("DocType public identifier does not match PubidChar construct.");
- }
- if (!(0, algorithm_1.xml_isLegalChar)(doctype.sysId) ||
- (doctype.sysId.indexOf('"') !== -1 && doctype.sysId.indexOf("'") !== -1)) {
- throw new Error("DocType system identifier contains invalid characters.");
- }
- context.appendChild(doc.implementation.createDocumentType(doctype.name, doctype.pubId, doctype.sysId));
- break;
- case interfaces_1.TokenType.CDATA:
- const cdata = token;
- if (!(0, algorithm_1.xml_isLegalChar)(cdata.data) ||
- cdata.data.indexOf("]]>") !== -1) {
- throw new Error("CDATA contains invalid characters.");
- }
- context.appendChild(doc.createCDATASection(cdata.data));
- break;
- case interfaces_1.TokenType.Comment:
- const comment = token;
- if (!(0, algorithm_1.xml_isLegalChar)(comment.data) ||
- comment.data.indexOf("--") !== -1 || comment.data.endsWith("-")) {
- throw new Error("Comment data contains invalid characters.");
- }
- context.appendChild(doc.createComment(comment.data));
- break;
- case interfaces_1.TokenType.PI:
- const pi = token;
- if (pi.target.indexOf(":") !== -1 || (/^xml$/i).test(pi.target)) {
- throw new Error("Processing instruction target contains invalid characters.");
- }
- if (!(0, algorithm_1.xml_isLegalChar)(pi.data) || pi.data.indexOf("?>") !== -1) {
- throw new Error("Processing instruction data contains invalid characters.");
- }
- context.appendChild(doc.createProcessingInstruction(pi.target, pi.data));
- break;
- case interfaces_1.TokenType.Text:
- const text = token;
- if (!(0, algorithm_1.xml_isLegalChar)(text.data)) {
- throw new Error("Text data contains invalid characters.");
- }
- context.appendChild(doc.createTextNode(this._decodeText(text.data)));
- break;
- case interfaces_1.TokenType.Element:
- const element = token;
- // inherit namespace from parent
- const [prefix, localName] = (0, algorithm_1.namespace_extractQName)(element.name);
- if (localName.indexOf(":") !== -1 || !(0, algorithm_1.xml_isName)(localName)) {
- throw new Error("Node local name contains invalid characters.");
- }
- if (prefix === "xmlns") {
- throw new Error("An element cannot have the 'xmlns' prefix.");
- }
- let namespace = context.lookupNamespaceURI(prefix);
- // override namespace if there is a namespace declaration
- // attribute
- // also lookup namespace declaration attributes
- const nsDeclarations = {};
- for (const [attName, attValue] of element.attributes) {
- if (attName === "xmlns") {
- namespace = attValue;
- }
- else {
- const [attPrefix, attLocalName] = (0, algorithm_1.namespace_extractQName)(attName);
- if (attPrefix === "xmlns") {
- if (attLocalName === prefix) {
- namespace = attValue;
- }
- nsDeclarations[attLocalName] = attValue;
- }
- }
- }
- // create the DOM element node
- const elementNode = (namespace !== null ?
- doc.createElementNS(namespace, element.name) :
- doc.createElement(element.name));
- context.appendChild(elementNode);
- // assign attributes
- const localNameSet = new LocalNameSet_1.LocalNameSet();
- for (const [attName, attValue] of element.attributes) {
- const [attPrefix, attLocalName] = (0, algorithm_1.namespace_extractQName)(attName);
- let attNamespace = null;
- if (attPrefix === "xmlns" || (attPrefix === null && attLocalName === "xmlns")) {
- // namespace declaration attribute
- attNamespace = infra_1.namespace.XMLNS;
- }
- else {
- attNamespace = elementNode.lookupNamespaceURI(attPrefix);
- if (attNamespace !== null && elementNode.isDefaultNamespace(attNamespace)) {
- attNamespace = null;
- }
- else if (attNamespace === null && attPrefix !== null) {
- attNamespace = nsDeclarations[attPrefix] || null;
- }
- }
- if (localNameSet.has(attNamespace, attLocalName)) {
- throw new Error("Element contains duplicate attributes.");
- }
- localNameSet.set(attNamespace, attLocalName);
- if (attNamespace === infra_1.namespace.XMLNS) {
- if (attValue === infra_1.namespace.XMLNS) {
- throw new Error("XMLNS namespace is reserved.");
- }
- }
- if (attLocalName.indexOf(":") !== -1 || !(0, algorithm_1.xml_isName)(attLocalName)) {
- throw new Error("Attribute local name contains invalid characters.");
- }
- if (attPrefix === "xmlns" && attValue === "") {
- throw new Error("Empty XML namespace is not allowed.");
- }
- if (attNamespace !== null)
- elementNode.setAttributeNS(attNamespace, attName, this._decodeAttributeValue(attValue));
- else
- elementNode.setAttribute(attName, this._decodeAttributeValue(attValue));
- }
- if (!element.selfClosing) {
- context = elementNode;
- }
- break;
- case interfaces_1.TokenType.ClosingTag:
- const closingTag = token;
- if (closingTag.name !== context.nodeName) {
- throw new Error('Closing tag name does not match opening tag name.');
- }
- /* istanbul ignore else */
- if (context._parent) {
- context = context._parent;
- }
- break;
- }
- token = lexer.nextToken();
- }
- return doc;
- }
- /**
- * Decodes serialized text.
- *
- * @param text - text value to serialize
- */
- _decodeText(text) {
- return text == null ? text : text.replace(/</g, '<')
- .replace(/>/g, '>')
- .replace(/&/g, '&');
- }
- /**
- * Decodes serialized attribute value.
- *
- * @param text - attribute value to serialize
- */
- _decodeAttributeValue(text) {
- return text == null ? text : text.replace(/</g, '<')
- .replace(/>/g, '>')
- .replace(/&/g, '&');
- }
-}
-exports.XMLParserImpl = XMLParserImpl;
-//# sourceMappingURL=XMLParserImpl.js.map
-
-/***/ }),
-
-/***/ 3529:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.XMLStringLexer = void 0;
-const interfaces_1 = __nccwpck_require__(4727);
-/**
- * Represents a lexer for XML content in a string.
- */
-class XMLStringLexer {
- _str;
- _index;
- _length;
- _options = {
- skipWhitespaceOnlyText: false
- };
- err = { line: -1, col: -1, index: -1, str: "" };
- /**
- * Initializes a new instance of `XMLStringLexer`.
- *
- * @param str - the string to tokenize and lex
- * @param options - lexer options
- */
- constructor(str, options) {
- this._str = str;
- this._index = 0;
- this._length = str.length;
- if (options) {
- this._options.skipWhitespaceOnlyText = options.skipWhitespaceOnlyText || false;
- }
- }
- /**
- * Returns the next token.
- */
- nextToken() {
- if (this.eof()) {
- return { type: interfaces_1.TokenType.EOF };
- }
- let token = (this.skipIfStartsWith('<') ? this.openBracket() : this.text());
- if (this._options.skipWhitespaceOnlyText) {
- if (token.type === interfaces_1.TokenType.Text &&
- XMLStringLexer.isWhiteSpaceToken(token)) {
- token = this.nextToken();
- }
- }
- return token;
- }
- /**
- * Branches from an opening bracket (`<`).
- */
- openBracket() {
- if (this.skipIfStartsWith('?')) {
- if (this.skipIfStartsWith('xml')) {
- if (XMLStringLexer.isSpace(this._str[this._index])) {
- return this.declaration();
- }
- else {
- // a processing instruction starting with xml. e.g.
- this.seek(-3);
- return this.pi();
- }
- }
- else {
- return this.pi();
- }
- }
- else if (this.skipIfStartsWith('!')) {
- if (this.skipIfStartsWith('--')) {
- return this.comment();
- }
- else if (this.skipIfStartsWith('[CDATA[')) {
- return this.cdata();
- }
- else if (this.skipIfStartsWith('DOCTYPE')) {
- return this.doctype();
- }
- else {
- this.throwError("Invalid '!' in opening tag.");
- }
- }
- else if (this.skipIfStartsWith('/')) {
- return this.closeTag();
- }
- else {
- return this.openTag();
- }
- }
- /**
- * Produces an XML declaration token.
- */
- declaration() {
- let version = '';
- let encoding = '';
- let standalone = '';
- while (!this.eof()) {
- this.skipSpace();
- if (this.skipIfStartsWith('?>')) {
- return { type: interfaces_1.TokenType.Declaration, version: version, encoding: encoding, standalone: standalone };
- }
- else {
- // attribute name
- const [attName, attValue] = this.attribute();
- if (attName === 'version')
- version = attValue;
- else if (attName === 'encoding')
- encoding = attValue;
- else if (attName === 'standalone')
- standalone = attValue;
- else
- this.throwError('Invalid attribute name: ' + attName);
- }
- }
- this.throwError('Missing declaration end symbol `?>`');
- }
- /**
- * Produces a doc type token.
- */
- doctype() {
- let pubId = '';
- let sysId = '';
- // name
- this.skipSpace();
- const name = this.takeUntil2('[', '>', true);
- this.skipSpace();
- if (this.skipIfStartsWith('PUBLIC')) {
- pubId = this.quotedString();
- sysId = this.quotedString();
- }
- else if (this.skipIfStartsWith('SYSTEM')) {
- sysId = this.quotedString();
- }
- // skip internal subset
- this.skipSpace();
- if (this.skipIfStartsWith('[')) {
- // skip internal subset nodes
- this.skipUntil(']');
- if (!this.skipIfStartsWith(']')) {
- this.throwError('Missing end bracket of DTD internal subset');
- }
- }
- this.skipSpace();
- if (!this.skipIfStartsWith('>')) {
- this.throwError('Missing doctype end symbol `>`');
- }
- return { type: interfaces_1.TokenType.DocType, name: name, pubId: pubId, sysId: sysId };
- }
- /**
- * Produces a processing instruction token.
- */
- pi() {
- const target = this.takeUntilStartsWith('?>', true);
- if (this.eof()) {
- this.throwError('Missing processing instruction end symbol `?>`');
- }
- this.skipSpace();
- if (this.skipIfStartsWith('?>')) {
- return { type: interfaces_1.TokenType.PI, target: target, data: '' };
- }
- const data = this.takeUntilStartsWith('?>');
- if (this.eof()) {
- this.throwError('Missing processing instruction end symbol `?>`');
- }
- this.seek(2);
- return { type: interfaces_1.TokenType.PI, target: target, data: data };
- }
- /**
- * Produces a text token.
- *
- */
- text() {
- const data = this.takeUntil('<');
- return { type: interfaces_1.TokenType.Text, data: data };
- }
- /**
- * Produces a comment token.
- *
- */
- comment() {
- const data = this.takeUntilStartsWith('-->');
- if (this.eof()) {
- this.throwError('Missing comment end symbol `-->`');
- }
- this.seek(3);
- return { type: interfaces_1.TokenType.Comment, data: data };
- }
- /**
- * Produces a CDATA token.
- *
- */
- cdata() {
- const data = this.takeUntilStartsWith(']]>');
- if (this.eof()) {
- this.throwError('Missing CDATA end symbol `]>`');
- }
- this.seek(3);
- return { type: interfaces_1.TokenType.CDATA, data: data };
- }
- /**
- * Produces an element token.
- */
- openTag() {
- // element name
- this.skipSpace();
- const name = this.takeUntil2('>', '/', true);
- this.skipSpace();
- if (this.skipIfStartsWith('>')) {
- return { type: interfaces_1.TokenType.Element, name: name, attributes: [], selfClosing: false };
- }
- else if (this.skipIfStartsWith('/>')) {
- return { type: interfaces_1.TokenType.Element, name: name, attributes: [], selfClosing: true };
- }
- // attributes
- const attributes = [];
- while (!this.eof()) {
- // end tag
- this.skipSpace();
- if (this.skipIfStartsWith('>')) {
- return { type: interfaces_1.TokenType.Element, name: name, attributes: attributes, selfClosing: false };
- }
- else if (this.skipIfStartsWith('/>')) {
- return { type: interfaces_1.TokenType.Element, name: name, attributes: attributes, selfClosing: true };
- }
- const attr = this.attribute();
- attributes.push(attr);
- }
- this.throwError('Missing opening element tag end symbol `>`');
- }
- /**
- * Produces a closing tag token.
- *
- */
- closeTag() {
- this.skipSpace();
- const name = this.takeUntil('>', true);
- this.skipSpace();
- if (!this.skipIfStartsWith('>')) {
- this.throwError('Missing closing element tag end symbol `>`');
- }
- return { type: interfaces_1.TokenType.ClosingTag, name: name };
- }
- /**
- * Reads an attribute name, value pair
- */
- attribute() {
- // attribute name
- this.skipSpace();
- const name = this.takeUntil('=', true);
- this.skipSpace();
- if (!this.skipIfStartsWith('=')) {
- this.throwError('Missing equals sign before attribute value');
- }
- // attribute value
- const value = this.quotedString();
- return [name, value];
- }
- /**
- * Reads a string between double or single quotes.
- */
- quotedString() {
- this.skipSpace();
- const startQuote = this.take(1);
- if (!XMLStringLexer.isQuote(startQuote)) {
- this.throwError('Missing start quote character before quoted value');
- }
- const value = this.takeUntil(startQuote);
- if (!this.skipIfStartsWith(startQuote)) {
- this.throwError('Missing end quote character after quoted value');
- }
- return value;
- }
- /**
- * Determines if the current index is at or past the end of input string.
- */
- eof() { return this._index >= this._length; }
- /**
- * Skips the length of the given string if the string from current position
- * starts with the given string.
- *
- * @param str - the string to match
- */
- skipIfStartsWith(str) {
- const strLength = str.length;
- if (strLength === 1) {
- if (this._str[this._index] === str) {
- this._index++;
- return true;
- }
- else {
- return false;
- }
- }
- for (let i = 0; i < strLength; i++) {
- if (this._str[this._index + i] !== str[i])
- return false;
- }
- this._index += strLength;
- return true;
- }
- /**
- * Seeks a number of character codes.
- *
- * @param count - number of characters to skip
- */
- seek(count) {
- this._index += count;
- if (this._index < 0)
- this._index = 0;
- if (this._index > this._length)
- this._index = this._length;
- }
- /**
- * Skips space characters.
- */
- skipSpace() {
- while (!this.eof() && (XMLStringLexer.isSpace(this._str[this._index]))) {
- this._index++;
- }
- }
- /**
- * Takes a given number of characters.
- *
- * @param count - character count
- */
- take(count) {
- if (count === 1) {
- return this._str[this._index++];
- }
- const startIndex = this._index;
- this.seek(count);
- return this._str.slice(startIndex, this._index);
- }
- /**
- * Takes characters until the next character matches `char`.
- *
- * @param char - a character to match
- * @param space - whether a space character stops iteration
- */
- takeUntil(char, space = false) {
- const startIndex = this._index;
- while (this._index < this._length) {
- const c = this._str[this._index];
- if (c !== char && (!space || !XMLStringLexer.isSpace(c))) {
- this._index++;
- }
- else {
- break;
- }
- }
- return this._str.slice(startIndex, this._index);
- }
- /**
- * Takes characters until the next character matches `char1` or `char1`.
- *
- * @param char1 - a character to match
- * @param char2 - a character to match
- * @param space - whether a space character stops iteration
- */
- takeUntil2(char1, char2, space = false) {
- const startIndex = this._index;
- while (this._index < this._length) {
- const c = this._str[this._index];
- if (c !== char1 && c !== char2 && (!space || !XMLStringLexer.isSpace(c))) {
- this._index++;
- }
- else {
- break;
- }
- }
- return this._str.slice(startIndex, this._index);
- }
- /**
- * Takes characters until the next characters matches `str`.
- *
- * @param str - a string to match
- * @param space - whether a space character stops iteration
- */
- takeUntilStartsWith(str, space = false) {
- const startIndex = this._index;
- const strLength = str.length;
- while (this._index < this._length) {
- let match = true;
- for (let i = 0; i < strLength; i++) {
- const c = this._str[this._index + i];
- const char = str[i];
- if (space && XMLStringLexer.isSpace(c)) {
- return this._str.slice(startIndex, this._index);
- }
- else if (c !== char) {
- this._index++;
- match = false;
- break;
- }
- }
- if (match)
- return this._str.slice(startIndex, this._index);
- }
- this._index = this._length;
- return this._str.slice(startIndex);
- }
- /**
- * Skips characters until the next character matches `char`.
- *
- * @param char - a character to match
- */
- skipUntil(char) {
- while (this._index < this._length) {
- const c = this._str[this._index];
- if (c !== char) {
- this._index++;
- }
- else {
- break;
- }
- }
- }
- /**
- * Determines if the given token is entirely whitespace.
- *
- * @param token - the token to check
- */
- static isWhiteSpaceToken(token) {
- const str = token.data;
- for (let i = 0; i < str.length; i++) {
- const c = str[i];
- if (c !== ' ' && c !== '\n' && c !== '\r' && c !== '\t' && c !== '\f')
- return false;
- }
- return true;
- }
- /**
- * Determines if the given character is whitespace.
- *
- * @param char - the character to check
- */
- static isSpace(char) {
- return char === ' ' || char === '\n' || char === '\r' || char === '\t';
- }
- /**
- * Determines if the given character is a quote character.
- *
- * @param char - the character to check
- */
- static isQuote(char) {
- return (char === '"' || char === '\'');
- }
- /**
- * Throws a parser error and records the line and column numbers in the parsed
- * string.
- *
- * @param msg - error message
- */
- throwError(msg) {
- const regexp = /\r\n|\r|\n/g;
- let match = null;
- let line = 0;
- let firstNewLineIndex = 0;
- let lastNewlineIndex = this._str.length;
- while ((match = regexp.exec(this._str)) !== null) {
- if (match === null)
- break;
- line++;
- if (match.index < this._index)
- firstNewLineIndex = regexp.lastIndex;
- if (match.index > this._index) {
- lastNewlineIndex = match.index;
- break;
- }
- }
- this.err = {
- line: line,
- col: this._index - firstNewLineIndex,
- index: this._index,
- str: this._str.substring(firstNewLineIndex, lastNewlineIndex)
- };
- throw new Error(msg + "\nIndex: " + this.err.index +
- "\nLn: " + this.err.line + ", Col: " + this.err.col +
- "\nInput: " + this.err.str);
- }
- /**
- * Returns an iterator for the lexer.
- */
- [Symbol.iterator]() {
- this._index = 0;
- return {
- next: function () {
- const token = this.nextToken();
- if (token.type === interfaces_1.TokenType.EOF) {
- return { done: true, value: null };
- }
- else {
- return { done: false, value: token };
- }
- }.bind(this)
- };
- }
-}
-exports.XMLStringLexer = XMLStringLexer;
-//# sourceMappingURL=XMLStringLexer.js.map
-
-/***/ }),
-
-/***/ 8531:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.DOMParser = void 0;
-// Export classes
-var DOMParserImpl_1 = __nccwpck_require__(6182);
-Object.defineProperty(exports, "DOMParser", ({ enumerable: true, get: function () { return DOMParserImpl_1.DOMParserImpl; } }));
-//# sourceMappingURL=index.js.map
-
-/***/ }),
-
-/***/ 4727:
-/***/ ((__unused_webpack_module, exports) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.TokenType = void 0;
-/**
- * Defines the type of a token.
- */
-var TokenType;
-(function (TokenType) {
- TokenType[TokenType["EOF"] = 0] = "EOF";
- TokenType[TokenType["Declaration"] = 1] = "Declaration";
- TokenType[TokenType["DocType"] = 2] = "DocType";
- TokenType[TokenType["Element"] = 3] = "Element";
- TokenType[TokenType["Text"] = 4] = "Text";
- TokenType[TokenType["CDATA"] = 5] = "CDATA";
- TokenType[TokenType["PI"] = 6] = "PI";
- TokenType[TokenType["Comment"] = 7] = "Comment";
- TokenType[TokenType["ClosingTag"] = 8] = "ClosingTag";
-})(TokenType || (exports.TokenType = TokenType = {}));
-//# sourceMappingURL=interfaces.js.map
-
-/***/ }),
-
-/***/ 7830:
-/***/ ((__unused_webpack_module, exports) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.LocalNameSet = void 0;
-/**
- * Represents a set of unique attribute namespaceURI and localName pairs.
- * This set will contain tuples of unique attribute namespaceURI and
- * localName pairs, and is populated as each attr is processed. This set is
- * used to [optionally] enforce the well-formed constraint that an element
- * cannot have two attributes with the same namespaceURI and localName.
- * This can occur when two otherwise identical attributes on the same
- * element differ only by their prefix values.
- */
-class LocalNameSet {
- // tuple storage
- _items = {};
- _nullItems = {};
- /**
- * Adds or replaces a tuple.
- *
- * @param ns - namespace URI
- * @param localName - attribute local name
- */
- set(ns, localName) {
- if (ns === null) {
- this._nullItems[localName] = true;
- }
- else if (this._items[ns]) {
- this._items[ns][localName] = true;
- }
- else {
- this._items[ns] = {};
- this._items[ns][localName] = true;
- }
- }
- /**
- * Determines if the given tuple exists in the set.
- *
- * @param ns - namespace URI
- * @param localName - attribute local name
- */
- has(ns, localName) {
- if (ns === null) {
- return this._nullItems[localName] === true;
- }
- else if (this._items[ns]) {
- return this._items[ns][localName] === true;
- }
- else {
- return false;
- }
- }
-}
-exports.LocalNameSet = LocalNameSet;
-//# sourceMappingURL=LocalNameSet.js.map
-
-/***/ }),
-
-/***/ 8377:
-/***/ ((__unused_webpack_module, exports) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.NamespacePrefixMap = void 0;
-/**
- * A namespace prefix map is a map that associates namespaceURI and namespace
- * prefix lists, where namespaceURI values are the map's unique keys (which can
- * include the null value representing no namespace), and ordered lists of
- * associated prefix values are the map's key values. The namespace prefix map
- * will be populated by previously seen namespaceURIs and all their previously
- * encountered prefix associations for a given node and its ancestors.
- *
- * _Note:_ The last seen prefix for a given namespaceURI is at the end of its
- * respective list. The list is searched to find potentially matching prefixes,
- * and if no matches are found for the given namespaceURI, then the last prefix
- * in the list is used. See copy a namespace prefix map and retrieve a preferred
- * prefix string for additional details.
- *
- * See: https://w3c.github.io/DOM-Parsing/#the-namespace-prefix-map
- */
-class NamespacePrefixMap {
- _items = {};
- _nullItems = [];
- /**
- * Creates a copy of the map.
- */
- copy() {
- /**
- * To copy a namespace prefix map map means to copy the map's keys into a
- * new empty namespace prefix map, and to copy each of the values in the
- * namespace prefix list associated with each keys' value into a new list
- * which should be associated with the respective key in the new map.
- */
- const mapCopy = new NamespacePrefixMap();
- for (const key in this._items) {
- mapCopy._items[key] = this._items[key].slice(0);
- }
- mapCopy._nullItems = this._nullItems.slice(0);
- return mapCopy;
- }
- /**
- * Retrieves a preferred prefix string from the namespace prefix map.
- *
- * @param preferredPrefix - preferred prefix string
- * @param ns - namespace
- */
- get(preferredPrefix, ns) {
- /**
- * 1. Let candidates list be the result of retrieving a list from map where
- * there exists a key in map that matches the value of ns or if there is no
- * such key, then stop running these steps, and return the null value.
- */
- const candidatesList = ns === null ? this._nullItems : (this._items[ns] || null);
- if (candidatesList === null) {
- return null;
- }
- /**
- * 2. Otherwise, for each prefix value prefix in candidates list, iterating
- * from beginning to end:
- *
- * _Note:_ There will always be at least one prefix value in the list.
- */
- let prefix = null;
- for (let i = 0; i < candidatesList.length; i++) {
- prefix = candidatesList[i];
- /**
- * 2.1. If prefix matches preferred prefix, then stop running these steps
- * and return prefix.
- */
- if (prefix === preferredPrefix) {
- return prefix;
- }
- }
- /**
- * 2.2. If prefix is the last item in the candidates list, then stop
- * running these steps and return prefix.
- */
- return prefix;
- }
- /**
- * Checks if a prefix string is found in the namespace prefix map associated
- * with the given namespace.
- *
- * @param prefix - prefix string
- * @param ns - namespace
- */
- has(prefix, ns) {
- /**
- * 1. Let candidates list be the result of retrieving a list from map where
- * there exists a key in map that matches the value of ns or if there is
- * no such key, then stop running these steps, and return false.
- */
- const candidatesList = ns === null ? this._nullItems : (this._items[ns] || null);
- if (candidatesList === null) {
- return false;
- }
- /**
- * 2. If the value of prefix occurs at least once in candidates list,
- * return true, otherwise return false.
- */
- return (candidatesList.indexOf(prefix) !== -1);
- }
- /**
- * Checks if a prefix string is found in the namespace prefix map.
- *
- * @param prefix - prefix string
- */
- hasPrefix(prefix) {
- if (this._nullItems.indexOf(prefix) !== -1)
- return true;
- for (const key in this._items) {
- if (this._items[key].indexOf(prefix) !== -1)
- return true;
- }
- return false;
- }
- /**
- * Adds a prefix string associated with a namespace to the prefix map.
- *
- * @param prefix - prefix string
- * @param ns - namespace
- */
- set(prefix, ns) {
- /**
- * 1. Let candidates list be the result of retrieving a list from map where
- * there exists a key in map that matches the value of ns or if there is
- * no such key, then let candidates list be null.
- */
- const candidatesList = ns === null ? this._nullItems : (this._items[ns] || null);
- /**
- * 2. If candidates list is null, then create a new list with prefix as the
- * only item in the list, and associate that list with a new key ns in map.
- * 3. Otherwise, append prefix to the end of candidates list.
- *
- * _Note:_ The steps in retrieve a preferred prefix string use the list to
- * track the most recently used (MRU) prefix associated with a given
- * namespace, which will be the prefix at the end of the list. This list
- * may contain duplicates of the same prefix value seen earlier
- * (and that's OK).
- */
- if (ns !== null && candidatesList === null) {
- this._items[ns] = [prefix];
- }
- else {
- candidatesList.push(prefix);
- }
- }
-}
-exports.NamespacePrefixMap = NamespacePrefixMap;
-//# sourceMappingURL=NamespacePrefixMap.js.map
-
-/***/ }),
-
-/***/ 6851:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.XMLSerializerImpl = void 0;
-const interfaces_1 = __nccwpck_require__(9454);
-const LocalNameSet_1 = __nccwpck_require__(7830);
-const NamespacePrefixMap_1 = __nccwpck_require__(8377);
-const DOMException_1 = __nccwpck_require__(7175);
-const infra_1 = __nccwpck_require__(4737);
-const algorithm_1 = __nccwpck_require__(6573);
-/**
- * Represents an XML serializer.
- *
- * Implements: https://www.w3.org/TR/DOM-Parsing/#serializing
- */
-class XMLSerializerImpl {
- static _VoidElementNames = new Set(['area', 'base', 'basefont',
- 'bgsound', 'br', 'col', 'embed', 'frame', 'hr', 'img', 'input', 'keygen',
- 'link', 'menuitem', 'meta', 'param', 'source', 'track', 'wbr']);
- /** @inheritdoc */
- serializeToString(root) {
- /**
- * The serializeToString(root) method must produce an XML serialization
- * of root passing a value of false for the require well-formed parameter,
- * and return the result.
- */
- return this._xmlSerialization(root, false);
- }
- /**
- * Produces an XML serialization of the given node.
- *
- * @param node - node to serialize
- * @param requireWellFormed - whether to check conformance
- */
- _xmlSerialization(node, requireWellFormed) {
- // To increase performance, use a namespace-aware serializer only if the
- // document has namespaced elements
- if (node._nodeDocument === undefined || node._nodeDocument._hasNamespaces) {
- /** From: https://w3c.github.io/DOM-Parsing/#xml-serialization
- *
- * 1. Let namespace be a context namespace with value null.
- * The context namespace tracks the XML serialization algorithm's current
- * default namespace. The context namespace is changed when either an Element
- * Node has a default namespace declaration, or the algorithm generates a
- * default namespace declaration for the Element Node to match its own
- * namespace. The algorithm assumes no namespace (null) to start.
- * 2. Let prefix map be a new namespace prefix map.
- * 3. Add the XML namespace with prefix value "xml" to prefix map.
- * 4. Let prefix index be a generated namespace prefix index with value 1.
- * The generated namespace prefix index is used to generate a new unique
- * prefix value when no suitable existing namespace prefix is available to
- * serialize a node's namespaceURI (or the namespaceURI of one of node's
- * attributes). See the generate a prefix algorithm.
- */
- const namespace = null;
- const prefixMap = new NamespacePrefixMap_1.NamespacePrefixMap();
- prefixMap.set("xml", infra_1.namespace.XML);
- const prefixIndex = { value: 1 };
- /**
- * 5. Return the result of running the XML serialization algorithm on node
- * passing the context namespace namespace, namespace prefix map prefix map,
- * generated namespace prefix index reference to prefix index, and the
- * flag require well-formed. If an exception occurs during the execution
- * of the algorithm, then catch that exception and throw an
- * "InvalidStateError" DOMException.
- */
- try {
- return this._serializeNodeNS(node, namespace, prefixMap, prefixIndex, requireWellFormed);
- }
- catch {
- throw new DOMException_1.InvalidStateError();
- }
- }
- else {
- try {
- return this._serializeNode(node, requireWellFormed);
- }
- catch {
- throw new DOMException_1.InvalidStateError();
- }
- }
- }
- /**
- * Produces an XML serialization of a node.
- *
- * @param node - node to serialize
- * @param namespace - context namespace
- * @param prefixMap - namespace prefix map
- * @param prefixIndex - generated namespace prefix index
- * @param requireWellFormed - whether to check conformance
- */
- _serializeNodeNS(node, namespace, prefixMap, prefixIndex, requireWellFormed) {
- switch (node.nodeType) {
- case interfaces_1.NodeType.Element:
- return this._serializeElementNS(node, namespace, prefixMap, prefixIndex, requireWellFormed);
- case interfaces_1.NodeType.Document:
- return this._serializeDocumentNS(node, namespace, prefixMap, prefixIndex, requireWellFormed);
- case interfaces_1.NodeType.Comment:
- return this._serializeComment(node, requireWellFormed);
- case interfaces_1.NodeType.Text:
- return this._serializeText(node, requireWellFormed);
- case interfaces_1.NodeType.DocumentFragment:
- return this._serializeDocumentFragmentNS(node, namespace, prefixMap, prefixIndex, requireWellFormed);
- case interfaces_1.NodeType.DocumentType:
- return this._serializeDocumentType(node, requireWellFormed);
- case interfaces_1.NodeType.ProcessingInstruction:
- return this._serializeProcessingInstruction(node, requireWellFormed);
- case interfaces_1.NodeType.CData:
- return this._serializeCData(node, requireWellFormed);
- default:
- throw new Error(`Unknown node type: ${node.nodeType}`);
- }
- }
- /**
- * Produces an XML serialization of a node.
- *
- * @param node - node to serialize
- * @param requireWellFormed - whether to check conformance
- */
- _serializeNode(node, requireWellFormed) {
- switch (node.nodeType) {
- case interfaces_1.NodeType.Element:
- return this._serializeElement(node, requireWellFormed);
- case interfaces_1.NodeType.Document:
- return this._serializeDocument(node, requireWellFormed);
- case interfaces_1.NodeType.Comment:
- return this._serializeComment(node, requireWellFormed);
- case interfaces_1.NodeType.Text:
- return this._serializeText(node, requireWellFormed);
- case interfaces_1.NodeType.DocumentFragment:
- return this._serializeDocumentFragment(node, requireWellFormed);
- case interfaces_1.NodeType.DocumentType:
- return this._serializeDocumentType(node, requireWellFormed);
- case interfaces_1.NodeType.ProcessingInstruction:
- return this._serializeProcessingInstruction(node, requireWellFormed);
- case interfaces_1.NodeType.CData:
- return this._serializeCData(node, requireWellFormed);
- default:
- throw new Error(`Unknown node type: ${node.nodeType}`);
- }
- }
- /**
- * Produces an XML serialization of an element node.
- *
- * @param node - node to serialize
- * @param namespace - context namespace
- * @param prefixMap - namespace prefix map
- * @param prefixIndex - generated namespace prefix index
- * @param requireWellFormed - whether to check conformance
- */
- _serializeElementNS(node, namespace, prefixMap, prefixIndex, requireWellFormed) {
- /**
- * From: https://w3c.github.io/DOM-Parsing/#xml-serializing-an-element-node
- *
- * 1. If the require well-formed flag is set (its value is true), and this
- * node's localName attribute contains the character ":" (U+003A COLON) or
- * does not match the XML Name production, then throw an exception; the
- * serialization of this node would not be a well-formed element.
- */
- if (requireWellFormed && (node.localName.indexOf(":") !== -1 ||
- !(0, algorithm_1.xml_isName)(node.localName))) {
- throw new Error("Node local name contains invalid characters (well-formed required).");
- }
- /**
- * 2. Let markup be the string "<" (U+003C LESS-THAN SIGN).
- * 3. Let qualified name be an empty string.
- * 4. Let skip end tag be a boolean flag with value false.
- * 5. Let ignore namespace definition attribute be a boolean flag with value
- * false.
- * 6. Given prefix map, copy a namespace prefix map and let map be the
- * result.
- * 7. Let local prefixes map be an empty map. The map has unique Node prefix
- * strings as its keys, with corresponding namespaceURI Node values as the
- * map's key values (in this map, the null namespace is represented by the
- * empty string).
- *
- * _Note:_ This map is local to each element. It is used to ensure there
- * are no conflicting prefixes should a new namespace prefix attribute need
- * to be generated. It is also used to enable skipping of duplicate prefix
- * definitions when writing an element's attributes: the map allows the
- * algorithm to distinguish between a prefix in the namespace prefix map
- * that might be locally-defined (to the current Element) and one that is
- * not.
- * 8. Let local default namespace be the result of recording the namespace
- * information for node given map and local prefixes map.
- *
- * _Note:_ The above step will update map with any found namespace prefix
- * definitions, add the found prefix definitions to the local prefixes map
- * and return a local default namespace value defined by a default namespace
- * attribute if one exists. Otherwise it returns null.
- * 9. Let inherited ns be a copy of namespace.
- * 10. Let ns be the value of node's namespaceURI attribute.
- */
- let markup = "<";
- let qualifiedName = '';
- let skipEndTag = false;
- let ignoreNamespaceDefinitionAttribute = false;
- let map = prefixMap.copy();
- let localPrefixesMap = {};
- let localDefaultNamespace = this._recordNamespaceInformation(node, map, localPrefixesMap);
- let inheritedNS = namespace;
- let ns = node.namespaceURI;
- /** 11. If inherited ns is equal to ns, then: */
- if (inheritedNS === ns) {
- /**
- * 11.1. If local default namespace is not null, then set ignore
- * namespace definition attribute to true.
- */
- if (localDefaultNamespace !== null) {
- ignoreNamespaceDefinitionAttribute = true;
- }
- /**
- * 11.2. If ns is the XML namespace, then append to qualified name the
- * concatenation of the string "xml:" and the value of node's localName.
- * 11.3. Otherwise, append to qualified name the value of node's
- * localName. The node's prefix if it exists, is dropped.
- */
- if (ns === infra_1.namespace.XML) {
- qualifiedName = 'xml:' + node.localName;
- }
- else {
- qualifiedName = node.localName;
- }
- /** 11.4. Append the value of qualified name to markup. */
- markup += qualifiedName;
- }
- else {
- /**
- * 12. Otherwise, inherited ns is not equal to ns (the node's own
- * namespace is different from the context namespace of its parent).
- * Run these sub-steps:
- *
- * 12.1. Let prefix be the value of node's prefix attribute.
- * 12.2. Let candidate prefix be the result of retrieving a preferred
- * prefix string prefix from map given namespace ns. The above may return
- * null if no namespace key ns exists in map.
- */
- let prefix = node.prefix;
- /**
- * We don't need to run "retrieving a preferred prefix string" algorithm if
- * the element has no prefix and its namespace matches to the default
- * namespace.
- * See: https://github.com/web-platform-tests/wpt/pull/16703
- */
- let candidatePrefix = null;
- if (prefix !== null || ns !== localDefaultNamespace) {
- candidatePrefix = map.get(prefix, ns);
- }
- /**
- * 12.3. If the value of prefix matches "xmlns", then run the following
- * steps:
- */
- if (prefix === "xmlns") {
- /**
- * 12.3.1. If the require well-formed flag is set, then throw an error.
- * An Element with prefix "xmlns" will not legally round-trip in a
- * conforming XML parser.
- */
- if (requireWellFormed) {
- throw new Error("An element cannot have the 'xmlns' prefix (well-formed required).");
- }
- /**
- * 12.3.2. Let candidate prefix be the value of prefix.
- */
- candidatePrefix = prefix;
- }
- /**
- * 12.4.Found a suitable namespace prefix: if candidate prefix is not
- * null (a namespace prefix is defined which maps to ns), then:
- */
- if (candidatePrefix !== null) {
- /**
- * The following may serialize a different prefix than the Element's
- * existing prefix if it already had one. However, the retrieving a
- * preferred prefix string algorithm already tried to match the
- * existing prefix if possible.
- *
- * 12.4.1. Append to qualified name the concatenation of candidate
- * prefix, ":" (U+003A COLON), and node's localName. There exists on
- * this node or the node's ancestry a namespace prefix definition that
- * defines the node's namespace.
- * 12.4.2. If the local default namespace is not null (there exists a
- * locally-defined default namespace declaration attribute) and its
- * value is not the XML namespace, then let inherited ns get the value
- * of local default namespace unless the local default namespace is the
- * empty string in which case let it get null (the context namespace
- * is changed to the declared default, rather than this node's own
- * namespace).
- *
- * _Note:_ Any default namespace definitions or namespace prefixes that
- * define the XML namespace are omitted when serializing this node's
- * attributes.
- */
- qualifiedName = candidatePrefix + ':' + node.localName;
- if (localDefaultNamespace !== null && localDefaultNamespace !== infra_1.namespace.XML) {
- inheritedNS = localDefaultNamespace || null;
- }
- /**
- * 12.4.3. Append the value of qualified name to markup.
- */
- markup += qualifiedName;
- /** 12.5. Otherwise, if prefix is not null, then: */
- }
- else if (prefix !== null) {
- /**
- * _Note:_ By this step, there is no namespace or prefix mapping
- * declaration in this node (or any parent node visited by this
- * algorithm) that defines prefix otherwise the step labelled Found
- * a suitable namespace prefix would have been followed. The sub-steps
- * that follow will create a new namespace prefix declaration for prefix
- * and ensure that prefix does not conflict with an existing namespace
- * prefix declaration of the same localName in node's attribute list.
- *
- * 12.5.1. If the local prefixes map contains a key matching prefix,
- * then let prefix be the result of generating a prefix providing as
- * input map, ns, and prefix index.
- */
- if (prefix in localPrefixesMap) {
- prefix = this._generatePrefix(ns, map, prefixIndex);
- }
- /**
- * 12.5.2. Add prefix to map given namespace ns.
- * 12.5.3. Append to qualified name the concatenation of prefix, ":"
- * (U+003A COLON), and node's localName.
- * 12.5.4. Append the value of qualified name to markup.
- */
- map.set(prefix, ns);
- qualifiedName += prefix + ':' + node.localName;
- markup += qualifiedName;
- /**
- * 12.5.5. Append the following to markup, in the order listed:
- *
- * _Note:_ The following serializes a namespace prefix declaration for
- * prefix which was just added to the map.
- *
- * 12.5.5.1. " " (U+0020 SPACE);
- * 12.5.5.2. The string "xmlns:";
- * 12.5.5.3. The value of prefix;
- * 12.5.5.4. "="" (U+003D EQUALS SIGN, U+0022 QUOTATION MARK);
- * 12.5.5.5. The result of serializing an attribute value given ns and
- * the require well-formed flag as input;
- * 12.5.5.6. """ (U+0022 QUOTATION MARK).
- */
- markup += " xmlns:" + prefix + "=\"" +
- this._serializeAttributeValue(ns, requireWellFormed) + "\"";
- /**
- * 12.5.5.7. If local default namespace is not null (there exists a
- * locally-defined default namespace declaration attribute), then
- * let inherited ns get the value of local default namespace unless the
- * local default namespace is the empty string in which case let it get
- * null.
- */
- if (localDefaultNamespace !== null) {
- inheritedNS = localDefaultNamespace || null;
- }
- /**
- * 12.6. Otherwise, if local default namespace is null, or local
- * default namespace is not null and its value is not equal to ns, then:
- */
- }
- else if (localDefaultNamespace === null ||
- (localDefaultNamespace !== null && localDefaultNamespace !== ns)) {
- /**
- * _Note:_ At this point, the namespace for this node still needs to be
- * serialized, but there's no prefix (or candidate prefix) available; the
- * following uses the default namespace declaration to define the
- * namespace--optionally replacing an existing default declaration
- * if present.
- *
- * 12.6.1. Set the ignore namespace definition attribute flag to true.
- * 12.6.2. Append to qualified name the value of node's localName.
- * 12.6.3. Let the value of inherited ns be ns.
- *
- * _Note:_ The new default namespace will be used in the serialization
- * to define this node's namespace and act as the context namespace for
- * its children.
- */
- ignoreNamespaceDefinitionAttribute = true;
- qualifiedName += node.localName;
- inheritedNS = ns;
- /**
- * 12.6.4. Append the value of qualified name to markup.
- */
- markup += qualifiedName;
- /**
- * 12.6.5. Append the following to markup, in the order listed:
- *
- * _Note:_ The following serializes the new (or replacement) default
- * namespace definition.
- *
- * 12.6.5.1. " " (U+0020 SPACE);
- * 12.6.5.2. The string "xmlns";
- * 12.6.5.3. "="" (U+003D EQUALS SIGN, U+0022 QUOTATION MARK);
- * 12.6.5.4. The result of serializing an attribute value given ns
- * and the require well-formed flag as input;
- * 12.6.5.5. """ (U+0022 QUOTATION MARK).
- */
- markup += " xmlns" + "=\"" +
- this._serializeAttributeValue(ns, requireWellFormed) + "\"";
- /**
- * 12.7. Otherwise, the node has a local default namespace that matches
- * ns. Append to qualified name the value of node's localName, let the
- * value of inherited ns be ns, and append the value of qualified name
- * to markup.
- */
- }
- else {
- qualifiedName += node.localName;
- inheritedNS = ns;
- markup += qualifiedName;
- }
- }
- /**
- * 13. Append to markup the result of the XML serialization of node's
- * attributes given map, prefix index, local prefixes map, ignore namespace
- * definition attribute flag, and require well-formed flag.
- */
- markup += this._serializeAttributesNS(node, map, prefixIndex, localPrefixesMap, ignoreNamespaceDefinitionAttribute, requireWellFormed);
- /**
- * 14. If ns is the HTML namespace, and the node's list of children is
- * empty, and the node's localName matches any one of the following void
- * elements: "area", "base", "basefont", "bgsound", "br", "col", "embed",
- * "frame", "hr", "img", "input", "keygen", "link", "menuitem", "meta",
- * "param", "source", "track", "wbr"; then append the following to markup,
- * in the order listed:
- * 14.1. " " (U+0020 SPACE);
- * 14.2. "/" (U+002F SOLIDUS).
- * and set the skip end tag flag to true.
- * 15. If ns is not the HTML namespace, and the node's list of children is
- * empty, then append "/" (U+002F SOLIDUS) to markup and set the skip end
- * tag flag to true.
- * 16. Append ">" (U+003E GREATER-THAN SIGN) to markup.
- */
- const isHTML = (ns === infra_1.namespace.HTML);
- if (isHTML && node.childNodes.length === 0 &&
- XMLSerializerImpl._VoidElementNames.has(node.localName)) {
- markup += " /";
- skipEndTag = true;
- }
- else if (!isHTML && node.childNodes.length === 0) {
- markup += "/";
- skipEndTag = true;
- }
- markup += ">";
- /**
- * 17. If the value of skip end tag is true, then return the value of markup
- * and skip the remaining steps. The node is a leaf-node.
- */
- if (skipEndTag)
- return markup;
- /**
- * 18. If ns is the HTML namespace, and the node's localName matches the
- * string "template", then this is a template element. Append to markup the
- * result of XML serializing a DocumentFragment node given the template
- * element's template contents (a DocumentFragment), providing inherited
- * ns, map, prefix index, and the require well-formed flag.
- *
- * _Note:_ This allows template content to round-trip, given the rules for
- * parsing XHTML documents.
- *
- * 19. Otherwise, append to markup the result of running the XML
- * serialization algorithm on each of node's children, in tree order,
- * providing inherited ns, map, prefix index, and the require well-formed
- * flag.
- */
- if (isHTML && node.localName === "template") {
- // TODO: serialize template contents
- }
- else {
- for (const childNode of node._children || node.childNodes) {
- markup += this._serializeNodeNS(childNode, inheritedNS, map, prefixIndex, requireWellFormed);
- }
- }
- /**
- * 20. Append the following to markup, in the order listed:
- * 20.1. "" (U+003E GREATER-THAN SIGN).
- */
- markup += "";
- /**
- * 21. Return the value of markup.
- */
- return markup;
- }
- /**
- * Produces an XML serialization of a document node.
- *
- * @param node - node to serialize
- * @param namespace - context namespace
- * @param prefixMap - namespace prefix map
- * @param prefixIndex - generated namespace prefix index
- * @param requireWellFormed - whether to check conformance
- */
- _serializeDocumentNS(node, namespace, prefixMap, prefixIndex, requireWellFormed) {
- /**
- * If the require well-formed flag is set (its value is true), and this node
- * has no documentElement (the documentElement attribute's value is null),
- * then throw an exception; the serialization of this node would not be a
- * well-formed document.
- */
- if (requireWellFormed && node.documentElement === null) {
- throw new Error("Missing document element (well-formed required).");
- }
- /**
- * Otherwise, run the following steps:
- * 1. Let serialized document be an empty string.
- * 2. For each child child of node, in tree order, run the XML
- * serialization algorithm on the child passing along the provided
- * arguments, and append the result to serialized document.
- *
- * _Note:_ This will serialize any number of ProcessingInstruction and
- * Comment nodes both before and after the Document's documentElement node,
- * including at most one DocumentType node. (Text nodes are not allowed as
- * children of the Document.)
- *
- * 3. Return the value of serialized document.
- */
- let serializedDocument = "";
- for (const childNode of node._children || node.childNodes) {
- serializedDocument += this._serializeNodeNS(childNode, namespace, prefixMap, prefixIndex, requireWellFormed);
- }
- return serializedDocument;
- }
- /**
- * Produces an XML serialization of a comment node.
- *
- * @param node - node to serialize
- * @param requireWellFormed - whether to check conformance
- */
- _serializeComment(node, requireWellFormed) {
- /**
- * If the require well-formed flag is set (its value is true), and node's
- * data contains characters that are not matched by the XML Char production
- * or contains "--" (two adjacent U+002D HYPHEN-MINUS characters) or that
- * ends with a "-" (U+002D HYPHEN-MINUS) character, then throw an exception;
- * the serialization of this node's data would not be well-formed.
- */
- if (requireWellFormed && (!(0, algorithm_1.xml_isLegalChar)(node.data) ||
- node.data.indexOf("--") !== -1 || node.data.endsWith("-"))) {
- throw new Error("Comment data contains invalid characters (well-formed required).");
- }
- /**
- * Otherwise, return the concatenation of "".
- */
- return "";
- }
- /**
- * Produces an XML serialization of a text node.
- *
- * @param node - node to serialize
- * @param requireWellFormed - whether to check conformance
- * @param level - current depth of the XML tree
- */
- _serializeText(node, requireWellFormed) {
- /**
- * 1. If the require well-formed flag is set (its value is true), and
- * node's data contains characters that are not matched by the XML Char
- * production, then throw an exception; the serialization of this node's
- * data would not be well-formed.
- */
- if (requireWellFormed && !(0, algorithm_1.xml_isLegalChar)(node.data)) {
- throw new Error("Text data contains invalid characters (well-formed required).");
- }
- /**
- * 2. Let markup be the value of node's data.
- * 3. Replace any occurrences of "&" in markup by "&".
- * 4. Replace any occurrences of "<" in markup by "<".
- * 5. Replace any occurrences of ">" in markup by ">".
- * 6. Return the value of markup.
- */
- let result = "";
- for (let i = 0; i < node.data.length; i++) {
- const c = node.data[i];
- if (c === "&")
- result += "&";
- else if (c === "<")
- result += "<";
- else if (c === ">")
- result += ">";
- else
- result += c;
- }
- return result;
- }
- /**
- * Produces an XML serialization of a document fragment node.
- *
- * @param node - node to serialize
- * @param namespace - context namespace
- * @param prefixMap - namespace prefix map
- * @param prefixIndex - generated namespace prefix index
- * @param requireWellFormed - whether to check conformance
- */
- _serializeDocumentFragmentNS(node, namespace, prefixMap, prefixIndex, requireWellFormed) {
- /**
- * 1. Let markup the empty string.
- * 2. For each child child of node, in tree order, run the XML serialization
- * algorithm on the child given namespace, prefix map, a reference to prefix
- * index, and flag require well-formed. Concatenate the result to markup.
- * 3. Return the value of markup.
- */
- let markup = "";
- for (const childNode of node._children || node.childNodes) {
- markup += this._serializeNodeNS(childNode, namespace, prefixMap, prefixIndex, requireWellFormed);
- }
- return markup;
- }
- /**
- * Produces an XML serialization of a document type node.
- *
- * @param node - node to serialize
- * @param requireWellFormed - whether to check conformance
- */
- _serializeDocumentType(node, requireWellFormed) {
- /**
- * 1. If the require well-formed flag is true and the node's publicId
- * attribute contains characters that are not matched by the XML PubidChar
- * production, then throw an exception; the serialization of this node
- * would not be a well-formed document type declaration.
- */
- if (requireWellFormed && !(0, algorithm_1.xml_isPubidChar)(node.publicId)) {
- throw new Error("DocType public identifier does not match PubidChar construct (well-formed required).");
- }
- /**
- * 2. If the require well-formed flag is true and the node's systemId
- * attribute contains characters that are not matched by the XML Char
- * production or that contains both a """ (U+0022 QUOTATION MARK) and a
- * "'" (U+0027 APOSTROPHE), then throw an exception; the serialization
- * of this node would not be a well-formed document type declaration.
- */
- if (requireWellFormed &&
- (!(0, algorithm_1.xml_isLegalChar)(node.systemId) ||
- (node.systemId.indexOf('"') !== -1 && node.systemId.indexOf("'") !== -1))) {
- throw new Error("DocType system identifier contains invalid characters (well-formed required).");
- }
- /**
- * 3. Let markup be an empty string.
- * 4. Append the string "" (U+003E GREATER-THAN SIGN) to markup.
- * 11. Return the value of markup.
- */
- return node.publicId && node.systemId ?
- ""
- : node.publicId ?
- ""
- : node.systemId ?
- ""
- :
- "";
- }
- /**
- * Produces an XML serialization of a processing instruction node.
- *
- * @param node - node to serialize
- * @param requireWellFormed - whether to check conformance
- */
- _serializeProcessingInstruction(node, requireWellFormed) {
- /**
- * 1. If the require well-formed flag is set (its value is true), and node's
- * target contains a ":" (U+003A COLON) character or is an ASCII
- * case-insensitive match for the string "xml", then throw an exception;
- * the serialization of this node's target would not be well-formed.
- */
- if (requireWellFormed && (node.target.indexOf(":") !== -1 || (/^xml$/i).test(node.target))) {
- throw new Error("Processing instruction target contains invalid characters (well-formed required).");
- }
- /**
- * 2. If the require well-formed flag is set (its value is true), and node's
- * data contains characters that are not matched by the XML Char production
- * or contains the string "?>" (U+003F QUESTION MARK,
- * U+003E GREATER-THAN SIGN), then throw an exception; the serialization of
- * this node's data would not be well-formed.
- */
- if (requireWellFormed && (!(0, algorithm_1.xml_isLegalChar)(node.data) ||
- node.data.indexOf("?>") !== -1)) {
- throw new Error("Processing instruction data contains invalid characters (well-formed required).");
- }
- /**
- * 3. Let markup be the concatenation of the following, in the order listed:
- * 3.1. "" (U+003F QUESTION MARK, U+003E GREATER-THAN SIGN).
- * 4. Return the value of markup.
- */
- return "";
- }
- /**
- * Produces an XML serialization of a CDATA node.
- *
- * @param node - node to serialize
- * @param requireWellFormed - whether to check conformance
- */
- _serializeCData(node, requireWellFormed) {
- if (requireWellFormed && (node.data.indexOf("]]>") !== -1)) {
- throw new Error("CDATA contains invalid characters (well-formed required).");
- }
- return "";
- }
- /**
- * Produces an XML serialization of the attributes of an element node.
- *
- * @param node - node to serialize
- * @param map - namespace prefix map
- * @param prefixIndex - generated namespace prefix index
- * @param localPrefixesMap - local prefixes map
- * @param ignoreNamespaceDefinitionAttribute - whether to ignore namespace
- * attributes
- * @param requireWellFormed - whether to check conformance
- */
- _serializeAttributesNS(node, map, prefixIndex, localPrefixesMap, ignoreNamespaceDefinitionAttribute, requireWellFormed) {
- /**
- * 1. Let result be the empty string.
- * 2. Let localname set be a new empty namespace localname set. This
- * localname set will contain tuples of unique attribute namespaceURI and
- * localName pairs, and is populated as each attr is processed. This set is
- * used to [optionally] enforce the well-formed constraint that an element
- * cannot have two attributes with the same namespaceURI and localName.
- * This can occur when two otherwise identical attributes on the same
- * element differ only by their prefix values.
- */
- let result = "";
- const localNameSet = requireWellFormed ? new LocalNameSet_1.LocalNameSet() : undefined;
- /**
- * 3. Loop: For each attribute attr in element's attributes, in the order
- * they are specified in the element's attribute list:
- */
- for (const attr of node.attributes) {
- // Optimize common case
- if (!ignoreNamespaceDefinitionAttribute && !requireWellFormed && attr.namespaceURI === null) {
- result += " " + attr.localName + "=\"" +
- this._serializeAttributeValue(attr.value, requireWellFormed) + "\"";
- continue;
- }
- /**
- * 3.1. If the require well-formed flag is set (its value is true), and the
- * localname set contains a tuple whose values match those of a new tuple
- * consisting of attr's namespaceURI attribute and localName attribute,
- * then throw an exception; the serialization of this attr would fail to
- * produce a well-formed element serialization.
- */
- if (requireWellFormed && localNameSet && localNameSet.has(attr.namespaceURI, attr.localName)) {
- throw new Error("Element contains duplicate attributes (well-formed required).");
- }
- /**
- * 3.2. Create a new tuple consisting of attr's namespaceURI attribute and
- * localName attribute, and add it to the localname set.
- * 3.3. Let attribute namespace be the value of attr's namespaceURI value.
- * 3.4. Let candidate prefix be null.
- */
- if (requireWellFormed && localNameSet)
- localNameSet.set(attr.namespaceURI, attr.localName);
- let attributeNamespace = attr.namespaceURI;
- let candidatePrefix = null;
- /** 3.5. If attribute namespace is not null, then run these sub-steps: */
- if (attributeNamespace !== null) {
- /**
- * 3.5.1. Let candidate prefix be the result of retrieving a preferred
- * prefix string from map given namespace attribute namespace with
- * preferred prefix being attr's prefix value.
- */
- candidatePrefix = map.get(attr.prefix, attributeNamespace);
- /**
- * 3.5.2. If the value of attribute namespace is the XMLNS namespace,
- * then run these steps:
- */
- if (attributeNamespace === infra_1.namespace.XMLNS) {
- /**
- * 3.5.2.1. If any of the following are true, then stop running these
- * steps and goto Loop to visit the next attribute:
- * - the attr's value is the XML namespace;
- * _Note:_ The XML namespace cannot be redeclared and survive
- * round-tripping (unless it defines the prefix "xml"). To avoid this
- * problem, this algorithm always prefixes elements in the XML
- * namespace with "xml" and drops any related definitions as seen
- * in the above condition.
- * - the attr's prefix is null and the ignore namespace definition
- * attribute flag is true (the Element's default namespace attribute
- * should be skipped);
- * - the attr's prefix is not null and either
- * * the attr's localName is not a key contained in the local
- * prefixes map, or
- * * the attr's localName is present in the local prefixes map but
- * the value of the key does not match attr's value
- * and furthermore that the attr's localName (as the prefix to find)
- * is found in the namespace prefix map given the namespace consisting
- * of the attr's value (the current namespace prefix definition was
- * exactly defined previously--on an ancestor element not the current
- * element whose attributes are being processed).
- */
- if (attr.value === infra_1.namespace.XML ||
- (attr.prefix === null && ignoreNamespaceDefinitionAttribute) ||
- (attr.prefix !== null && (!(attr.localName in localPrefixesMap) ||
- localPrefixesMap[attr.localName] !== attr.value) &&
- map.has(attr.localName, attr.value)))
- continue;
- /**
- * 3.5.2.2. If the require well-formed flag is set (its value is true),
- * and the value of attr's value attribute matches the XMLNS
- * namespace, then throw an exception; the serialization of this
- * attribute would produce invalid XML because the XMLNS namespace
- * is reserved and cannot be applied as an element's namespace via
- * XML parsing.
- *
- * _Note:_ DOM APIs do allow creation of elements in the XMLNS
- * namespace but with strict qualifications.
- */
- if (requireWellFormed && attr.value === infra_1.namespace.XMLNS) {
- throw new Error("XMLNS namespace is reserved (well-formed required).");
- }
- /**
- * 3.5.2.3. If the require well-formed flag is set (its value is true),
- * and the value of attr's value attribute is the empty string, then
- * throw an exception; namespace prefix declarations cannot be used
- * to undeclare a namespace (use a default namespace declaration
- * instead).
- */
- if (requireWellFormed && attr.value === '') {
- throw new Error("Namespace prefix declarations cannot be used to undeclare a namespace (well-formed required).");
- }
- /**
- * 3.5.2.4. the attr's prefix matches the string "xmlns", then let
- * candidate prefix be the string "xmlns".
- */
- if (attr.prefix === 'xmlns')
- candidatePrefix = 'xmlns';
- /**
- * 3.5.3. Otherwise, the attribute namespace is not the XMLNS namespace.
- * Run these steps:
- *
- * _Note:_ The (candidatePrefix === null) check is not in the spec.
- * We deviate from the spec here. Otherwise a prefix is generated for
- * all attributes with namespaces.
- */
- }
- else if (candidatePrefix === null) {
- if (attr.prefix !== null &&
- (!map.hasPrefix(attr.prefix) ||
- map.has(attr.prefix, attributeNamespace))) {
- /**
- * Check if we can use the attribute's own prefix.
- * We deviate from the spec here.
- * TODO: This is not an efficient way of searching for prefixes.
- * Follow developments to the spec.
- */
- candidatePrefix = attr.prefix;
- }
- else {
- /**
- * 3.5.3.1. Let candidate prefix be the result of generating a prefix
- * providing map, attribute namespace, and prefix index as input.
- */
- candidatePrefix = this._generatePrefix(attributeNamespace, map, prefixIndex);
- }
- /**
- * 3.5.3.2. Append the following to result, in the order listed:
- * 3.5.3.2.1. " " (U+0020 SPACE);
- * 3.5.3.2.2. The string "xmlns:";
- * 3.5.3.2.3. The value of candidate prefix;
- * 3.5.3.2.4. "="" (U+003D EQUALS SIGN, U+0022 QUOTATION MARK);
- * 3.5.3.2.5. The result of serializing an attribute value given
- * attribute namespace and the require well-formed flag as input;
- * 3.5.3.2.6. """ (U+0022 QUOTATION MARK).
- */
- result += " xmlns:" + candidatePrefix + "=\"" +
- this._serializeAttributeValue(attributeNamespace, requireWellFormed) + "\"";
- }
- }
- /**
- * 3.6. Append a " " (U+0020 SPACE) to result.
- * 3.7. If candidate prefix is not null, then append to result the
- * concatenation of candidate prefix with ":" (U+003A COLON).
- */
- result += " ";
- if (candidatePrefix !== null) {
- result += candidatePrefix + ':';
- }
- /**
- * 3.8. If the require well-formed flag is set (its value is true), and
- * this attr's localName attribute contains the character
- * ":" (U+003A COLON) or does not match the XML Name production or
- * equals "xmlns" and attribute namespace is null, then throw an
- * exception; the serialization of this attr would not be a
- * well-formed attribute.
- */
- if (requireWellFormed && (attr.localName.indexOf(":") !== -1 ||
- !(0, algorithm_1.xml_isName)(attr.localName) ||
- (attr.localName === "xmlns" && attributeNamespace === null))) {
- throw new Error("Attribute local name contains invalid characters (well-formed required).");
- }
- /**
- * 3.9. Append the following strings to result, in the order listed:
- * 3.9.1. The value of attr's localName;
- * 3.9.2. "="" (U+003D EQUALS SIGN, U+0022 QUOTATION MARK);
- * 3.9.3. The result of serializing an attribute value given attr's value
- * attribute and the require well-formed flag as input;
- * 3.9.4. """ (U+0022 QUOTATION MARK).
- */
- result += attr.localName + "=\"" +
- this._serializeAttributeValue(attr.value, requireWellFormed) + "\"";
- }
- /**
- * 4. Return the value of result.
- */
- return result;
- }
- /**
- * Records namespace information for the given element and returns the
- * default namespace attribute value.
- *
- * @param node - element node to process
- * @param map - namespace prefix map
- * @param localPrefixesMap - local prefixes map
- */
- _recordNamespaceInformation(node, map, localPrefixesMap) {
- /**
- * 1. Let default namespace attr value be null.
- */
- let defaultNamespaceAttrValue = null;
- /**
- * 2. Main: For each attribute attr in element's attributes, in the order
- * they are specified in the element's attribute list:
- */
- for (const attr of node.attributes) {
- /**
- * _Note:_ The following conditional steps find namespace prefixes. Only
- * attributes in the XMLNS namespace are considered (e.g., attributes made
- * to look like namespace declarations via
- * setAttribute("xmlns:pretend-prefix", "pretend-namespace") are not
- * included).
- */
- /** 2.1. Let attribute namespace be the value of attr's namespaceURI value. */
- let attributeNamespace = attr.namespaceURI;
- /** 2.2. Let attribute prefix be the value of attr's prefix. */
- let attributePrefix = attr.prefix;
- /** 2.3. If the attribute namespace is the XMLNS namespace, then: */
- if (attributeNamespace === infra_1.namespace.XMLNS) {
- /**
- * 2.3.1. If attribute prefix is null, then attr is a default namespace
- * declaration. Set the default namespace attr value to attr's value and
- * stop running these steps, returning to Main to visit the next
- * attribute.
- */
- if (attributePrefix === null) {
- defaultNamespaceAttrValue = attr.value;
- continue;
- /**
- * 2.3.2. Otherwise, the attribute prefix is not null and attr is a
- * namespace prefix definition. Run the following steps:
- */
- }
- else {
- /** 2.3.2.1. Let prefix definition be the value of attr's localName. */
- let prefixDefinition = attr.localName;
- /** 2.3.2.2. Let namespace definition be the value of attr's value. */
- let namespaceDefinition = attr.value;
- /**
- * 2.3.2.3. If namespace definition is the XML namespace, then stop
- * running these steps, and return to Main to visit the next
- * attribute.
- *
- * _Note:_ XML namespace definitions in prefixes are completely
- * ignored (in order to avoid unnecessary work when there might be
- * prefix conflicts). XML namespaced elements are always handled
- * uniformly by prefixing (and overriding if necessary) the element's
- * localname with the reserved "xml" prefix.
- */
- if (namespaceDefinition === infra_1.namespace.XML) {
- continue;
- }
- /**
- * 2.3.2.4. If namespace definition is the empty string (the
- * declarative form of having no namespace), then let namespace
- * definition be null instead.
- */
- if (namespaceDefinition === '') {
- namespaceDefinition = null;
- }
- /**
- * 2.3.2.5. If prefix definition is found in map given the namespace
- * namespace definition, then stop running these steps, and return to
- * Main to visit the next attribute.
- *
- * _Note:_ This step avoids adding duplicate prefix definitions for
- * the same namespace in the map. This has the side-effect of avoiding
- * later serialization of duplicate namespace prefix declarations in
- * any descendant nodes.
- */
- if (map.has(prefixDefinition, namespaceDefinition)) {
- continue;
- }
- /**
- * 2.3.2.6. Add the prefix prefix definition to map given namespace
- * namespace definition.
- */
- map.set(prefixDefinition, namespaceDefinition);
- /**
- * 2.3.2.7. Add the value of prefix definition as a new key to the
- * local prefixes map, with the namespace definition as the key's
- * value replacing the value of null with the empty string if
- * applicable.
- */
- localPrefixesMap[prefixDefinition] = namespaceDefinition || '';
- }
- }
- }
- /**
- * 3. Return the value of default namespace attr value.
- *
- * _Note:_ The empty string is a legitimate return value and is not
- * converted to null.
- */
- return defaultNamespaceAttrValue;
- }
- /**
- * Generates a new prefix for the given namespace.
- *
- * @param newNamespace - a namespace to generate prefix for
- * @param prefixMap - namespace prefix map
- * @param prefixIndex - generated namespace prefix index
- */
- _generatePrefix(newNamespace, prefixMap, prefixIndex) {
- /**
- * 1. Let generated prefix be the concatenation of the string "ns" and the
- * current numerical value of prefix index.
- * 2. Let the value of prefix index be incremented by one.
- * 3. Add to map the generated prefix given the new namespace namespace.
- * 4. Return the value of generated prefix.
- */
- let generatedPrefix = "ns" + prefixIndex.value;
- prefixIndex.value++;
- prefixMap.set(generatedPrefix, newNamespace);
- return generatedPrefix;
- }
- /**
- * Produces an XML serialization of an attribute value.
- *
- * @param value - attribute value
- * @param requireWellFormed - whether to check conformance
- */
- _serializeAttributeValue(value, requireWellFormed) {
- /**
- * From: https://w3c.github.io/DOM-Parsing/#dfn-serializing-an-attribute-value
- *
- * 1. If the require well-formed flag is set (its value is true), and
- * attribute value contains characters that are not matched by the XML Char
- * production, then throw an exception; the serialization of this attribute
- * value would fail to produce a well-formed element serialization.
- */
- if (requireWellFormed && value !== null && !(0, algorithm_1.xml_isLegalChar)(value)) {
- throw new Error("Invalid characters in attribute value.");
- }
- /**
- * 2. If attribute value is null, then return the empty string.
- */
- if (value === null)
- return "";
- /**
- * 3. Otherwise, attribute value is a string. Return the value of attribute
- * value, first replacing any occurrences of the following:
- * - "&" with "&"
- * - """ with """
- * - "<" with "<"
- * - ">" with ">"
- * NOTE
- * This matches behavior present in browsers, and goes above and beyond the
- * grammar requirement in the XML specification's AttValue production by
- * also replacing ">" characters.
- */
- let result = "";
- for (let i = 0; i < value.length; i++) {
- const c = value[i];
- if (c === "\"")
- result += """;
- else if (c === "&")
- result += "&";
- else if (c === "<")
- result += "<";
- else if (c === ">")
- result += ">";
- else
- result += c;
- }
- return result;
- }
- /**
- * Produces an XML serialization of an element node.
- *
- * @param node - node to serialize
- * @param requireWellFormed - whether to check conformance
- */
- _serializeElement(node, requireWellFormed) {
- /**
- * From: https://w3c.github.io/DOM-Parsing/#xml-serializing-an-element-node
- *
- * 1. If the require well-formed flag is set (its value is true), and this
- * node's localName attribute contains the character ":" (U+003A COLON) or
- * does not match the XML Name production, then throw an exception; the
- * serialization of this node would not be a well-formed element.
- */
- if (requireWellFormed && (node.localName.indexOf(":") !== -1 ||
- !(0, algorithm_1.xml_isName)(node.localName))) {
- throw new Error("Node local name contains invalid characters (well-formed required).");
- }
- /**
- * 2. Let markup be the string "<" (U+003C LESS-THAN SIGN).
- * 3. Let qualified name be an empty string.
- * 4. Let skip end tag be a boolean flag with value false.
- * 5. Let ignore namespace definition attribute be a boolean flag with value
- * false.
- * 6. Given prefix map, copy a namespace prefix map and let map be the
- * result.
- * 7. Let local prefixes map be an empty map. The map has unique Node prefix
- * strings as its keys, with corresponding namespaceURI Node values as the
- * map's key values (in this map, the null namespace is represented by the
- * empty string).
- *
- * _Note:_ This map is local to each element. It is used to ensure there
- * are no conflicting prefixes should a new namespace prefix attribute need
- * to be generated. It is also used to enable skipping of duplicate prefix
- * definitions when writing an element's attributes: the map allows the
- * algorithm to distinguish between a prefix in the namespace prefix map
- * that might be locally-defined (to the current Element) and one that is
- * not.
- * 8. Let local default namespace be the result of recording the namespace
- * information for node given map and local prefixes map.
- *
- * _Note:_ The above step will update map with any found namespace prefix
- * definitions, add the found prefix definitions to the local prefixes map
- * and return a local default namespace value defined by a default namespace
- * attribute if one exists. Otherwise it returns null.
- * 9. Let inherited ns be a copy of namespace.
- * 10. Let ns be the value of node's namespaceURI attribute.
- */
- let skipEndTag = false;
- /** 11. If inherited ns is equal to ns, then: */
- /**
- * 11.1. If local default namespace is not null, then set ignore
- * namespace definition attribute to true.
- * 11.2. If ns is the XML namespace, then append to qualified name the
- * concatenation of the string "xml:" and the value of node's localName.
- * 11.3. Otherwise, append to qualified name the value of node's
- * localName. The node's prefix if it exists, is dropped.
- */
- const qualifiedName = node.localName;
- /** 11.4. Append the value of qualified name to markup. */
- let markup = "<" + qualifiedName;
- /**
- * 13. Append to markup the result of the XML serialization of node's
- * attributes given map, prefix index, local prefixes map, ignore namespace
- * definition attribute flag, and require well-formed flag.
- */
- markup += this._serializeAttributes(node, requireWellFormed);
- /**
- * 14. If ns is the HTML namespace, and the node's list of children is
- * empty, and the node's localName matches any one of the following void
- * elements: "area", "base", "basefont", "bgsound", "br", "col", "embed",
- * "frame", "hr", "img", "input", "keygen", "link", "menuitem", "meta",
- * "param", "source", "track", "wbr"; then append the following to markup,
- * in the order listed:
- * 14.1. " " (U+0020 SPACE);
- * 14.2. "/" (U+002F SOLIDUS).
- * and set the skip end tag flag to true.
- * 15. If ns is not the HTML namespace, and the node's list of children is
- * empty, then append "/" (U+002F SOLIDUS) to markup and set the skip end
- * tag flag to true.
- * 16. Append ">" (U+003E GREATER-THAN SIGN) to markup.
- */
- if (node._children.size === 0) {
- markup += "/";
- skipEndTag = true;
- }
- markup += ">";
- /**
- * 17. If the value of skip end tag is true, then return the value of markup
- * and skip the remaining steps. The node is a leaf-node.
- */
- if (skipEndTag)
- return markup;
- /**
- * 18. If ns is the HTML namespace, and the node's localName matches the
- * string "template", then this is a template element. Append to markup the
- * result of XML serializing a DocumentFragment node given the template
- * element's template contents (a DocumentFragment), providing inherited
- * ns, map, prefix index, and the require well-formed flag.
- *
- * _Note:_ This allows template content to round-trip, given the rules for
- * parsing XHTML documents.
- *
- * 19. Otherwise, append to markup the result of running the XML
- * serialization algorithm on each of node's children, in tree order,
- * providing inherited ns, map, prefix index, and the require well-formed
- * flag.
- */
- for (const childNode of node._children) {
- markup += this._serializeNode(childNode, requireWellFormed);
- }
- /**
- * 20. Append the following to markup, in the order listed:
- * 20.1. "" (U+003E GREATER-THAN SIGN).
- */
- markup += "";
- /**
- * 21. Return the value of markup.
- */
- return markup;
- }
- /**
- * Produces an XML serialization of a document node.
- *
- * @param node - node to serialize
- * @param requireWellFormed - whether to check conformance
- */
- _serializeDocument(node, requireWellFormed) {
- /**
- * If the require well-formed flag is set (its value is true), and this node
- * has no documentElement (the documentElement attribute's value is null),
- * then throw an exception; the serialization of this node would not be a
- * well-formed document.
- */
- if (requireWellFormed && node.documentElement === null) {
- throw new Error("Missing document element (well-formed required).");
- }
- /**
- * Otherwise, run the following steps:
- * 1. Let serialized document be an empty string.
- * 2. For each child child of node, in tree order, run the XML
- * serialization algorithm on the child passing along the provided
- * arguments, and append the result to serialized document.
- *
- * _Note:_ This will serialize any number of ProcessingInstruction and
- * Comment nodes both before and after the Document's documentElement node,
- * including at most one DocumentType node. (Text nodes are not allowed as
- * children of the Document.)
- *
- * 3. Return the value of serialized document.
- */
- let serializedDocument = "";
- for (const childNode of node._children) {
- serializedDocument += this._serializeNode(childNode, requireWellFormed);
- }
- return serializedDocument;
- }
- /**
- * Produces an XML serialization of a document fragment node.
- *
- * @param node - node to serialize
- * @param requireWellFormed - whether to check conformance
- */
- _serializeDocumentFragment(node, requireWellFormed) {
- /**
- * 1. Let markup the empty string.
- * 2. For each child child of node, in tree order, run the XML serialization
- * algorithm on the child given namespace, prefix map, a reference to prefix
- * index, and flag require well-formed. Concatenate the result to markup.
- * 3. Return the value of markup.
- */
- let markup = "";
- for (const childNode of node._children) {
- markup += this._serializeNode(childNode, requireWellFormed);
- }
- return markup;
- }
- /**
- * Produces an XML serialization of the attributes of an element node.
- *
- * @param node - node to serialize
- * @param requireWellFormed - whether to check conformance
- */
- _serializeAttributes(node, requireWellFormed) {
- /**
- * 1. Let result be the empty string.
- * 2. Let localname set be a new empty namespace localname set. This
- * localname set will contain tuples of unique attribute namespaceURI and
- * localName pairs, and is populated as each attr is processed. This set is
- * used to [optionally] enforce the well-formed constraint that an element
- * cannot have two attributes with the same namespaceURI and localName.
- * This can occur when two otherwise identical attributes on the same
- * element differ only by their prefix values.
- */
- let result = "";
- const localNameSet = requireWellFormed ? {} : undefined;
- /**
- * 3. Loop: For each attribute attr in element's attributes, in the order
- * they are specified in the element's attribute list:
- */
- for (const attr of node.attributes) {
- /**
- * 3.1. If the require well-formed flag is set (its value is true), and the
- * localname set contains a tuple whose values match those of a new tuple
- * consisting of attr's namespaceURI attribute and localName attribute,
- * then throw an exception; the serialization of this attr would fail to
- * produce a well-formed element serialization.
- */
- if (requireWellFormed && localNameSet && (attr.localName in localNameSet)) {
- throw new Error("Element contains duplicate attributes (well-formed required).");
- }
- /**
- * 3.2. Create a new tuple consisting of attr's namespaceURI attribute and
- * localName attribute, and add it to the localname set.
- * 3.3. Let attribute namespace be the value of attr's namespaceURI value.
- * 3.4. Let candidate prefix be null.
- */
- if (requireWellFormed && localNameSet)
- localNameSet[attr.localName] = true;
- /** 3.5. If attribute namespace is not null, then run these sub-steps: */
- /**
- * 3.6. Append a " " (U+0020 SPACE) to result.
- * 3.7. If candidate prefix is not null, then append to result the
- * concatenation of candidate prefix with ":" (U+003A COLON).
- */
- /**
- * 3.8. If the require well-formed flag is set (its value is true), and
- * this attr's localName attribute contains the character
- * ":" (U+003A COLON) or does not match the XML Name production or
- * equals "xmlns" and attribute namespace is null, then throw an
- * exception; the serialization of this attr would not be a
- * well-formed attribute.
- */
- if (requireWellFormed && (attr.localName.indexOf(":") !== -1 ||
- !(0, algorithm_1.xml_isName)(attr.localName))) {
- throw new Error("Attribute local name contains invalid characters (well-formed required).");
- }
- /**
- * 3.9. Append the following strings to result, in the order listed:
- * 3.9.1. The value of attr's localName;
- * 3.9.2. "="" (U+003D EQUALS SIGN, U+0022 QUOTATION MARK);
- * 3.9.3. The result of serializing an attribute value given attr's value
- * attribute and the require well-formed flag as input;
- * 3.9.4. """ (U+0022 QUOTATION MARK).
- */
- result += " " + attr.localName + "=\"" +
- this._serializeAttributeValue(attr.value, requireWellFormed) + "\"";
- }
- /**
- * 4. Return the value of result.
- */
- return result;
- }
-}
-exports.XMLSerializerImpl = XMLSerializerImpl;
-//# sourceMappingURL=XMLSerializerImpl.js.map
-
-/***/ }),
-
-/***/ 6052:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.XMLSerializer = void 0;
-// Export classes
-var XMLSerializerImpl_1 = __nccwpck_require__(6851);
-Object.defineProperty(exports, "XMLSerializer", ({ enumerable: true, get: function () { return XMLSerializerImpl_1.XMLSerializerImpl; } }));
-//# sourceMappingURL=index.js.map
-
-/***/ }),
-
-/***/ 9786:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.Cast = void 0;
-const Guard_1 = __nccwpck_require__(7773);
-/**
- * Contains type casts for DOM objects.
- */
-class Cast {
- /**
- * Casts the given object to a `Node`.
- *
- * @param a - the object to cast
- */
- static asNode(a) {
- if (Guard_1.Guard.isNode(a)) {
- return a;
- }
- else {
- throw new Error("Invalid object. Node expected.");
- }
- }
-}
-exports.Cast = Cast;
-//# sourceMappingURL=Cast.js.map
-
-/***/ }),
-
-/***/ 4581:
-/***/ ((__unused_webpack_module, exports) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.EmptySet = void 0;
-class EmptySet {
- get size() {
- return 0;
- }
- add(value) {
- throw new Error("Cannot add to an empty set.");
- }
- clear() {
- // no-op
- }
- delete(value) {
- return false;
- }
- forEach(callbackfn, thisArg) {
- // no-op
- }
- has(value) {
- return false;
- }
- [Symbol.iterator]() {
- return new EmptySetIterator();
- }
- entries() {
- return new EmptySetIterator();
- }
- keys() {
- return new EmptySetIterator();
- }
- values() {
- return new EmptySetIterator();
- }
- get [Symbol.toStringTag]() {
- return "EmptySet";
- }
-}
-exports.EmptySet = EmptySet;
-class EmptySetIterator {
- [Symbol.iterator]() {
- return this;
- }
- next() {
- return { done: true, value: null };
- }
-}
-//# sourceMappingURL=EmptySet.js.map
-
-/***/ }),
-
-/***/ 7773:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.Guard = void 0;
-const interfaces_1 = __nccwpck_require__(9454);
-/**
- * Contains user-defined type guards for DOM objects.
- */
-class Guard {
- /**
- * Determines if the given object is a `Node`.
- *
- * @param a - the object to check
- */
- static isNode(a) {
- return (!!a && a._nodeType !== undefined);
- }
- /**
- * Determines if the given object is a `Document`.
- *
- * @param a - the object to check
- */
- static isDocumentNode(a) {
- return (Guard.isNode(a) && a._nodeType === interfaces_1.NodeType.Document);
- }
- /**
- * Determines if the given object is a `DocumentType`.
- *
- * @param a - the object to check
- */
- static isDocumentTypeNode(a) {
- return (Guard.isNode(a) && a._nodeType === interfaces_1.NodeType.DocumentType);
- }
- /**
- * Determines if the given object is a `DocumentFragment`.
- *
- * @param a - the object to check
- */
- static isDocumentFragmentNode(a) {
- return (Guard.isNode(a) && a._nodeType === interfaces_1.NodeType.DocumentFragment);
- }
- /**
- * Determines if the given object is a `Attr`.
- *
- * @param a - the object to check
- */
- static isAttrNode(a) {
- return (Guard.isNode(a) && a._nodeType === interfaces_1.NodeType.Attribute);
- }
- /**
- * Determines if the given node is a `CharacterData` node.
- *
- * @param a - the object to check
- */
- static isCharacterDataNode(a) {
- if (!Guard.isNode(a))
- return false;
- const type = a._nodeType;
- return (type === interfaces_1.NodeType.Text ||
- type === interfaces_1.NodeType.ProcessingInstruction ||
- type === interfaces_1.NodeType.Comment ||
- type === interfaces_1.NodeType.CData);
- }
- /**
- * Determines if the given object is a `Text` or a `CDATASection`.
- *
- * @param a - the object to check
- */
- static isTextNode(a) {
- return (Guard.isNode(a) && (a._nodeType === interfaces_1.NodeType.Text || a._nodeType === interfaces_1.NodeType.CData));
- }
- /**
- * Determines if the given object is a `Text`.
- *
- * @param a - the object to check
- */
- static isExclusiveTextNode(a) {
- return (Guard.isNode(a) && a._nodeType === interfaces_1.NodeType.Text);
- }
- /**
- * Determines if the given object is a `CDATASection`.
- *
- * @param a - the object to check
- */
- static isCDATASectionNode(a) {
- return (Guard.isNode(a) && a._nodeType === interfaces_1.NodeType.CData);
- }
- /**
- * Determines if the given object is a `Comment`.
- *
- * @param a - the object to check
- */
- static isCommentNode(a) {
- return (Guard.isNode(a) && a._nodeType === interfaces_1.NodeType.Comment);
- }
- /**
- * Determines if the given object is a `ProcessingInstruction`.
- *
- * @param a - the object to check
- */
- static isProcessingInstructionNode(a) {
- return (Guard.isNode(a) && a._nodeType === interfaces_1.NodeType.ProcessingInstruction);
- }
- /**
- * Determines if the given object is an `Element`.
- *
- * @param a - the object to check
- */
- static isElementNode(a) {
- return (Guard.isNode(a) && a._nodeType === interfaces_1.NodeType.Element);
- }
- /**
- * Determines if the given object is a custom `Element`.
- *
- * @param a - the object to check
- */
- static isCustomElementNode(a) {
- return (Guard.isElementNode(a) && a._customElementState === "custom");
- }
- /**
- * Determines if the given object is a `ShadowRoot`.
- *
- * @param a - the object to check
- */
- static isShadowRoot(a) {
- return (!!a && a.host !== undefined);
- }
- /**
- * Determines if the given object is a `MouseEvent`.
- *
- * @param a - the object to check
- */
- static isMouseEvent(a) {
- return (!!a && a.screenX !== undefined && a.screenY != undefined);
- }
- /**
- * Determines if the given object is a slotable.
- *
- * Element and Text nodes are slotables. A slotable has an associated name
- * (a string).
- *
- * @param a - the object to check
- */
- static isSlotable(a) {
- return (!!a && a._name !== undefined && a._assignedSlot !== undefined &&
- (Guard.isTextNode(a) || Guard.isElementNode(a)));
- }
- /**
- * Determines if the given object is a slot.
- *
- * @param a - the object to check
- */
- static isSlot(a) {
- return (!!a && a._name !== undefined && a._assignedNodes !== undefined &&
- Guard.isElementNode(a));
- }
- /**
- * Determines if the given object is a `Window`.
- *
- * @param a - the object to check
- */
- static isWindow(a) {
- return (!!a && a.navigator !== undefined);
- }
- /**
- * Determines if the given object is an `EventListener`.
- *
- * @param a - the object to check
- */
- static isEventListener(a) {
- return (!!a && a.handleEvent !== undefined);
- }
- /**
- * Determines if the given object is a `RegisteredObserver`.
- *
- * @param a - the object to check
- */
- static isRegisteredObserver(a) {
- return (!!a && a.observer !== undefined && a.options !== undefined);
- }
- /**
- * Determines if the given object is a `TransientRegisteredObserver`.
- *
- * @param a - the object to check
- */
- static isTransientRegisteredObserver(a) {
- return (!!a && a.source !== undefined && Guard.isRegisteredObserver(a));
- }
-}
-exports.Guard = Guard;
-//# sourceMappingURL=Guard.js.map
-
-/***/ }),
-
-/***/ 8247:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.EmptySet = exports.Guard = exports.Cast = void 0;
-var Cast_1 = __nccwpck_require__(9786);
-Object.defineProperty(exports, "Cast", ({ enumerable: true, get: function () { return Cast_1.Cast; } }));
-var Guard_1 = __nccwpck_require__(7773);
-Object.defineProperty(exports, "Guard", ({ enumerable: true, get: function () { return Guard_1.Guard; } }));
-var EmptySet_1 = __nccwpck_require__(4581);
-Object.defineProperty(exports, "EmptySet", ({ enumerable: true, get: function () { return EmptySet_1.EmptySet; } }));
-//# sourceMappingURL=index.js.map
-
-/***/ }),
-
-/***/ 9558:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.forgivingBase64Encode = forgivingBase64Encode;
-exports.forgivingBase64Decode = forgivingBase64Decode;
-const CodePoints_1 = __nccwpck_require__(4467);
-/**
- * Base-64 encodes the given string.
- *
- * @param input - a string
- */
-function forgivingBase64Encode(input) {
- /**
- * To forgiving-base64 encode given a byte sequence data, apply the base64
- * algorithm defined in section 4 of RFC 4648 to data and return the result.
- * [RFC4648]
- */
- return Buffer.from(input).toString('base64');
-}
-/**
- * Decodes a base-64 string.
- *
- * @param input - a string
- */
-function forgivingBase64Decode(input) {
- if (input === "")
- return "";
- /**
- * 1. Remove all ASCII whitespace from data.
- */
- input = input.replace(CodePoints_1.ASCIIWhiteSpace, '');
- /**
- * 2. If data’s length divides by 4 leaving no remainder, then:
- * 2.1. If data ends with one or two U+003D (=) code points, then remove them from data.
- */
- if (input.length % 4 === 0) {
- if (input.endsWith("==")) {
- input = input.substr(0, input.length - 2);
- }
- else if (input.endsWith("=")) {
- input = input.substr(0, input.length - 1);
- }
- }
- /**
- * 3. If data’s length divides by 4 leaving a remainder of 1, then return failure.
- */
- if (input.length % 4 === 1)
- return null;
- /**
- * 4. If data contains a code point that is not one of
- * - U+002B (+)
- * - U+002F (/)
- * - ASCII alphanumeric
- * then return failure.
- */
- if (!/[0-9A-Za-z+/]/.test(input))
- return null;
- /**
- * 5. Let output be an empty byte sequence.
- * 6. Let buffer be an empty buffer that can have bits appended to it.
- * 7. Let position be a position variable for data, initially pointing at the
- * start of data.
- * 8. While position does not point past the end of data:
- * 8.1. Find the code point pointed to by position in the second column of
- * Table 1: The Base 64 Alphabet of RFC 4648. Let n be the number given in the
- * first cell of the same row. [RFC4648]
- * 8.2. Append the six bits corresponding to n, most significant bit first,
- * to buffer.
- * 8.3. If buffer has accumulated 24 bits, interpret them as three 8-bit
- * big-endian numbers. Append three bytes with values equal to those numbers
- * to output, in the same order, and then empty buffer.
- * 8.4. Advance position by 1.
- * 9. If buffer is not empty, it contains either 12 or 18 bits. If it contains
- * 12 bits, then discard the last four and interpret the remaining eight as an
- * 8-bit big-endian number. If it contains 18 bits, then discard the last two
- * and interpret the remaining 16 as two 8-bit big-endian numbers. Append the
- * one or two bytes with values equal to those one or two numbers to output,
- * in the same order.
- * 10. Return output.
- */
- return Buffer.from(input, 'base64').toString('utf8');
-}
-//# sourceMappingURL=Base64.js.map
-
-/***/ }),
-
-/***/ 8311:
-/***/ ((__unused_webpack_module, exports) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.isASCIIByte = isASCIIByte;
-/**
- * Determines if the given number is an ASCII byte.
- *
- * @param byte - a byte
- */
-function isASCIIByte(byte) {
- /**
- * An ASCII byte is a byte in the range 0x00 (NUL) to 0x7F (DEL), inclusive.
- */
- return byte >= 0x00 && byte <= 0x7F;
-}
-//# sourceMappingURL=Byte.js.map
-
-/***/ }),
-
-/***/ 2017:
-/***/ ((__unused_webpack_module, exports) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.length = length;
-exports.byteLowercase = byteLowercase;
-exports.byteUppercase = byteUppercase;
-exports.byteCaseInsensitiveMatch = byteCaseInsensitiveMatch;
-exports.startsWith = startsWith;
-exports.byteLessThan = byteLessThan;
-exports.isomorphicDecode = isomorphicDecode;
-/**
- * Returns the count of bytes in a sequence.
- *
- * @param list - a byte sequence
- */
-function length(list) {
- /**
- * A byte sequence’s length is the number of bytes it contains.
- */
- return list.length;
-}
-/**
- * Converts each byte to lowercase.
- *
- * @param list - a byte sequence
- */
-function byteLowercase(list) {
- /**
- * To byte-lowercase a byte sequence, increase each byte it contains, in the
- * range 0x41 (A) to 0x5A (Z), inclusive, by 0x20.
- */
- for (let i = 0; i < list.length; i++) {
- const c = list[i];
- if (c >= 0x41 && c <= 0x5A) {
- list[i] = c + 0x20;
- }
- }
-}
-/**
- * Converts each byte to uppercase.
- *
- * @param list - a byte sequence
- */
-function byteUppercase(list) {
- /**
- * To byte-uppercase a byte sequence, subtract each byte it contains, in the
- * range 0x61 (a) to 0x7A (z), inclusive, by 0x20.
- */
- for (let i = 0; i < list.length; i++) {
- const c = list[i];
- if (c >= 0x61 && c <= 0x7A) {
- list[i] = c - 0x20;
- }
- }
-}
-/**
- * Compares two byte sequences.
- *
- * @param listA - a byte sequence
- * @param listB - a byte sequence
- */
-function byteCaseInsensitiveMatch(listA, listB) {
- /**
- * A byte sequence A is a byte-case-insensitive match for a byte sequence B,
- * if the byte-lowercase of A is the byte-lowercase of B.
- */
- if (listA.length !== listB.length)
- return false;
- for (let i = 0; i < listA.length; i++) {
- let a = listA[i];
- let b = listB[i];
- if (a >= 0x41 && a <= 0x5A)
- a += 0x20;
- if (b >= 0x41 && b <= 0x5A)
- b += 0x20;
- if (a !== b)
- return false;
- }
- return true;
-}
-/**
- * Determines if `listA` starts with `listB`.
- *
- * @param listA - a byte sequence
- * @param listB - a byte sequence
- */
-function startsWith(listA, listB) {
- /**
- * 1. Let i be 0.
- * 2. While true:
- * 2.1. Let aByte be the ith byte of a if i is less than a’s length; otherwise null.
- * 2.3. Let bByte be the ith byte of b if i is less than b’s length; otherwise null.
- * 2.4. If bByte is null, then return true.
- * 2.5. Return false if aByte is not bByte.
- * 2.6. Set i to i + 1.
- */
- let i = 0;
- while (true) {
- if (i >= listA.length)
- return false;
- if (i >= listB.length)
- return true;
- if (listA[i] !== listB[i])
- return false;
- i++;
- }
-}
-/**
- * Determines if `listA` is less than `listB`.
- *
- * @param listA - a byte sequence
- * @param listB - a byte sequence
- */
-function byteLessThan(listA, listB) {
- /**
- * 1. If b starts with a, then return false.
- * 2. If a starts with b, then return true.
- * 3. Let n be the smallest index such that the nth byte of a is different
- * from the nth byte of b. (There has to be such an index, since neither byte
- * sequence starts with the other.)
- * 4. If the nth byte of a is less than the nth byte of b, then return true.
- * 5. Return false.
- */
- let i = 0;
- while (true) {
- if (i >= listA.length)
- return false;
- if (i >= listB.length)
- return true;
- const a = listA[i];
- const b = listB[i];
- if (a < b)
- return true;
- else if (a > b)
- return false;
- i++;
- }
-}
-/**
- * Decodes a byte sequence into a string.
- *
- * @param list - a byte sequence
- */
-function isomorphicDecode(list) {
- /**
- * To isomorphic decode a byte sequence input, return a string whose length is
- * equal to input’s length and whose code points have the same values as
- * input’s bytes, in the same order.
- */
- return String.fromCodePoint(...list);
-}
-//# sourceMappingURL=ByteSequence.js.map
-
-/***/ }),
-
-/***/ 4467:
-/***/ ((__unused_webpack_module, exports) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.ASCIIAlphanumeric = exports.ASCIIAlpha = exports.ASCIILowerAlpha = exports.ASCIIUpperAlpha = exports.ASCIIHexDigit = exports.ASCIILowerHexDigit = exports.ASCIIUpperHexDigit = exports.ASCIIDigit = exports.Control = exports.C0ControlOrSpace = exports.C0Control = exports.ASCIIWhiteSpace = exports.ASCIITabOrNewLine = exports.ASCIICodePoint = exports.NonCharacter = exports.ScalarValue = exports.Surrogate = void 0;
-/**
- * A surrogate is a code point that is in the range U+D800 to U+DFFF, inclusive.
- */
-exports.Surrogate = /[\uD800-\uDFFF]/;
-/**
- * A scalar value is a code point that is not a surrogate.
- */
-exports.ScalarValue = /[\uD800-\uDFFF]/;
-/**
- * A noncharacter is a code point that is in the range U+FDD0 to U+FDEF,
- * inclusive, or U+FFFE, U+FFFF, U+1FFFE, U+1FFFF, U+2FFFE, U+2FFFF, U+3FFFE,
- * U+3FFFF, U+4FFFE, U+4FFFF, U+5FFFE, U+5FFFF, U+6FFFE, U+6FFFF, U+7FFFE,
- * U+7FFFF, U+8FFFE, U+8FFFF, U+9FFFE, U+9FFFF, U+AFFFE, U+AFFFF, U+BFFFE,
- * U+BFFFF, U+CFFFE, U+CFFFF, U+DFFFE, U+DFFFF, U+EFFFE, U+EFFFF, U+FFFFE,
- * U+FFFFF, U+10FFFE, or U+10FFFF.
- */
-exports.NonCharacter = /[\uFDD0-\uFDEF\uFFFE\uFFFF]|[\uD83F\uD87F\uD8BF\uD8FF\uD93F\uD97F\uD9BF\uD9FF\uDA3F\uDA7F\uDABF\uDAFF\uDB3F\uDB7F\uDBBF\uDBFF][\uDFFE\uDFFF]/;
-/**
- * An ASCII code point is a code point in the range U+0000 NULL to U+007F
- * DELETE, inclusive.
- */
-exports.ASCIICodePoint = /[\u0000-\u007F]/;
-/**
- * An ASCII tab or newline is U+0009 TAB, U+000A LF, or U+000D CR.
- */
-exports.ASCIITabOrNewLine = /[\t\n\r]/;
-/**
- * ASCII whitespace is U+0009 TAB, U+000A LF, U+000C FF, U+000D CR, or
- * U+0020 SPACE.
- */
-exports.ASCIIWhiteSpace = /[\t\n\f\r ]/;
-/**
- * A C0 control is a code point in the range U+0000 NULL to U+001F
- * INFORMATION SEPARATOR ONE, inclusive.
- */
-exports.C0Control = /[\u0000-\u001F]/;
-/**
- * A C0 control or space is a C0 control or U+0020 SPACE.
- */
-exports.C0ControlOrSpace = /[\u0000-\u001F ]/;
-/**
- * A control is a C0 control or a code point in the range U+007F DELETE to
- * U+009F APPLICATION PROGRAM COMMAND, inclusive.
- */
-exports.Control = /[\u0000-\u001F\u007F-\u009F]/;
-/**
- * An ASCII digit is a code point in the range U+0030 (0) to U+0039 (9),
- * inclusive.
- */
-exports.ASCIIDigit = /[0-9]/;
-/**
- * An ASCII upper hex digit is an ASCII digit or a code point in the range
- * U+0041 (A) to U+0046 (F), inclusive.
- */
-exports.ASCIIUpperHexDigit = /[0-9A-F]/;
-/**
- * An ASCII lower hex digit is an ASCII digit or a code point in the range
- * U+0061 (a) to U+0066 (f), inclusive.
- */
-exports.ASCIILowerHexDigit = /[0-9a-f]/;
-/**
- * An ASCII hex digit is an ASCII upper hex digit or ASCII lower hex digit.
- */
-exports.ASCIIHexDigit = /[0-9A-Fa-f]/;
-/**
- * An ASCII upper alpha is a code point in the range U+0041 (A) to U+005A (Z),
- * inclusive.
- */
-exports.ASCIIUpperAlpha = /[A-Z]/;
-/**
- * An ASCII lower alpha is a code point in the range U+0061 (a) to U+007A (z),
- * inclusive.
- */
-exports.ASCIILowerAlpha = /[a-z]/;
-/**
- * An ASCII alpha is an ASCII upper alpha or ASCII lower alpha.
- */
-exports.ASCIIAlpha = /[A-Za-z]/;
-/**
- * An ASCII alphanumeric is an ASCII digit or ASCII alpha.
- */
-exports.ASCIIAlphanumeric = /[0-9A-Za-z]/;
-//# sourceMappingURL=CodePoints.js.map
-
-/***/ }),
-
-/***/ 5475:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.parseJSONFromBytes = parseJSONFromBytes;
-exports.serializeJSONToBytes = serializeJSONToBytes;
-exports.parseJSONIntoInfraValues = parseJSONIntoInfraValues;
-exports.convertAJSONDerivedJavaScriptValueToAnInfraValue = convertAJSONDerivedJavaScriptValueToAnInfraValue;
-const util_1 = __nccwpck_require__(7061);
-/**
- * Parses the given byte sequence representing a JSON string into an object.
- *
- * @param bytes - a byte sequence
- */
-function parseJSONFromBytes(bytes) {
- /**
- * 1. Let jsonText be the result of running UTF-8 decode on bytes. [ENCODING]
- * 2. Return ? Call(%JSONParse%, undefined, « jsonText »).
- */
- const jsonText = (0, util_1.utf8Decode)(bytes);
- return JSON.parse.call(undefined, jsonText);
-}
-/**
- * Serialize the given JavaScript value into a byte sequence.
- *
- * @param value - a JavaScript value
- */
-function serializeJSONToBytes(value) {
- /**
- * 1. Let jsonString be ? Call(%JSONStringify%, undefined, « value »).
- * 2. Return the result of running UTF-8 encode on jsonString. [ENCODING]
- */
- const jsonString = JSON.stringify.call(undefined, value);
- return (0, util_1.utf8Encode)(jsonString);
-}
-/**
- * Parses the given JSON string into a Realm-independent JavaScript value.
- *
- * @param jsonText - a JSON string
- */
-function parseJSONIntoInfraValues(jsonText) {
- /**
- * 1. Let jsValue be ? Call(%JSONParse%, undefined, « jsonText »).
- * 2. Return the result of converting a JSON-derived JavaScript value to an
- * Infra value, given jsValue.
- */
- const jsValue = JSON.parse.call(undefined, jsonText);
- return convertAJSONDerivedJavaScriptValueToAnInfraValue(jsValue);
-}
-/**
- * Parses the value into a Realm-independent JavaScript value.
- *
- * @param jsValue - a JavaScript value
- */
-function convertAJSONDerivedJavaScriptValueToAnInfraValue(jsValue) {
- /**
- * 1. If Type(jsValue) is Null, String, or Number, then return jsValue.
- */
- if (jsValue === null || (0, util_1.isString)(jsValue) || (0, util_1.isNumber)(jsValue))
- return jsValue;
- /**
- * 2. If IsArray(jsValue) is true, then:
- * 2.1. Let result be an empty list.
- * 2.2. Let length be ! ToLength(! Get(jsValue, "length")).
- * 2.3. For each index of the range 0 to length − 1, inclusive:
- * 2.3.1. Let indexName be ! ToString(index).
- * 2.3.2. Let jsValueAtIndex be ! Get(jsValue, indexName).
- * 2.3.3. Let infraValueAtIndex be the result of converting a JSON-derived
- * JavaScript value to an Infra value, given jsValueAtIndex.
- * 2.3.4. Append infraValueAtIndex to result.
- * 2.8. Return result.
- */
- if ((0, util_1.isArray)(jsValue)) {
- const result = new Array();
- for (const jsValueAtIndex of jsValue) {
- result.push(convertAJSONDerivedJavaScriptValueToAnInfraValue(jsValueAtIndex));
- }
- return result;
- }
- else if ((0, util_1.isObject)(jsValue)) {
- /**
- * 3. Let result be an empty ordered map.
- * 4. For each key of ! jsValue.[[OwnPropertyKeys]]():
- * 4.1. Let jsValueAtKey be ! Get(jsValue, key).
- * 4.2. Let infraValueAtKey be the result of converting a JSON-derived
- * JavaScript value to an Infra value, given jsValueAtKey.
- * 4.3. Set result[key] to infraValueAtKey.
- * 5. Return result.
- */
- const result = new Map();
- for (const key in jsValue) {
- /* istanbul ignore else */
- if (jsValue.hasOwnProperty(key)) {
- const jsValueAtKey = jsValue[key];
- result.set(key, convertAJSONDerivedJavaScriptValueToAnInfraValue(jsValueAtKey));
- }
- }
- return result;
- }
- /* istanbul ignore next */
- return jsValue;
-}
-//# sourceMappingURL=JSON.js.map
-
-/***/ }),
-
-/***/ 1193:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.append = append;
-exports.extend = extend;
-exports.prepend = prepend;
-exports.replace = replace;
-exports.insert = insert;
-exports.remove = remove;
-exports.empty = empty;
-exports.contains = contains;
-exports.size = size;
-exports.isEmpty = isEmpty;
-exports.forEach = forEach;
-exports.clone = clone;
-exports.sortInAscendingOrder = sortInAscendingOrder;
-exports.sortInDescendingOrder = sortInDescendingOrder;
-const util_1 = __nccwpck_require__(7061);
-/**
- * Adds the given item to the end of the list.
- *
- * @param list - a list
- * @param item - an item
- */
-function append(list, item) {
- list.push(item);
-}
-/**
- * Extends a list by appending all items from another list.
- *
- * @param listA - a list to extend
- * @param listB - a list containing items to append to `listA`
- */
-function extend(listA, listB) {
- listA.push(...listB);
-}
-/**
- * Inserts the given item to the start of the list.
- *
- * @param list - a list
- * @param item - an item
- */
-function prepend(list, item) {
- list.unshift(item);
-}
-/**
- * Replaces the given item or all items matching condition with a new item.
- *
- * @param list - a list
- * @param conditionOrItem - an item to replace or a condition matching items
- * to replace
- * @param item - an item
- */
-function replace(list, conditionOrItem, newItem) {
- let i = 0;
- for (const oldItem of list) {
- if ((0, util_1.isFunction)(conditionOrItem)) {
- if (!!conditionOrItem.call(null, oldItem)) {
- list[i] = newItem;
- }
- }
- else if (oldItem === conditionOrItem) {
- list[i] = newItem;
- return;
- }
- i++;
- }
-}
-/**
- * Inserts the given item before the given index.
- *
- * @param list - a list
- * @param item - an item
- */
-function insert(list, item, index) {
- list.splice(index, 0, item);
-}
-/**
- * Removes the given item or all items matching condition.
- *
- * @param list - a list
- * @param conditionOrItem - an item to remove or a condition matching items
- * to remove
- */
-function remove(list, conditionOrItem) {
- let i = list.length;
- while (i--) {
- const oldItem = list[i];
- if ((0, util_1.isFunction)(conditionOrItem)) {
- if (!!conditionOrItem.call(null, oldItem)) {
- list.splice(i, 1);
- }
- }
- else if (oldItem === conditionOrItem) {
- list.splice(i, 1);
- return;
- }
- }
-}
-/**
- * Removes all items from the list.
- */
-function empty(list) {
- list.length = 0;
-}
-/**
- * Determines if the list contains the given item or any items matching
- * condition.
- *
- * @param list - a list
- * @param conditionOrItem - an item to a condition to match
- */
-function contains(list, conditionOrItem) {
- for (const oldItem of list) {
- if ((0, util_1.isFunction)(conditionOrItem)) {
- if (!!conditionOrItem.call(null, oldItem)) {
- return true;
- }
- }
- else if (oldItem === conditionOrItem) {
- return true;
- }
- }
- return false;
-}
-/**
- * Returns the count of items in the list matching the given condition.
- *
- * @param list - a list
- * @param condition - an optional condition to match
- */
-function size(list, condition) {
- if (condition === undefined) {
- return list.length;
- }
- else {
- let count = 0;
- for (const item of list) {
- if (!!condition.call(null, item)) {
- count++;
- }
- }
- return count;
- }
-}
-/**
- * Determines if the list is empty.
- *
- * @param list - a list
- */
-function isEmpty(list) {
- return list.length === 0;
-}
-/**
- * Returns an iterator for the items of the list.
- *
- * @param list - a list
- * @param condition - an optional condition to match
- */
-function* forEach(list, condition) {
- if (condition === undefined) {
- yield* list;
- }
- else {
- for (const item of list) {
- if (!!condition.call(null, item)) {
- yield item;
- }
- }
- }
-}
-/**
- * Creates and returns a shallow clone of list.
- *
- * @param list - a list
- */
-function clone(list) {
- return new Array(...list);
-}
-/**
- * Returns a new list containing items from the list sorted in ascending
- * order.
- *
- * @param list - a list
- * @param lessThanAlgo - a function that returns `true` if its first argument
- * is less than its second argument, and `false` otherwise.
- */
-function sortInAscendingOrder(list, lessThanAlgo) {
- return list.sort((itemA, itemB) => lessThanAlgo.call(null, itemA, itemB) ? -1 : 1);
-}
-/**
- * Returns a new list containing items from the list sorted in descending
- * order.
- *
- * @param list - a list
- * @param lessThanAlgo - a function that returns `true` if its first argument
- * is less than its second argument, and `false` otherwise.
- */
-function sortInDescendingOrder(list, lessThanAlgo) {
- return list.sort((itemA, itemB) => lessThanAlgo.call(null, itemA, itemB) ? 1 : -1);
-}
-//# sourceMappingURL=List.js.map
-
-/***/ }),
-
-/***/ 6067:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.get = get;
-exports.set = set;
-exports.remove = remove;
-exports.contains = contains;
-exports.keys = keys;
-exports.values = values;
-exports.size = size;
-exports.isEmpty = isEmpty;
-exports.forEach = forEach;
-exports.clone = clone;
-exports.sortInAscendingOrder = sortInAscendingOrder;
-exports.sortInDescendingOrder = sortInDescendingOrder;
-const util_1 = __nccwpck_require__(7061);
-/**
- * Gets the value corresponding to the given key.
- *
- * @param map - a map
- * @param key - a key
- */
-function get(map, key) {
- return map.get(key);
-}
-/**
- * Sets the value corresponding to the given key.
- *
- * @param map - a map
- * @param key - a key
- * @param val - a value
- */
-function set(map, key, val) {
- map.set(key, val);
-}
-/**
- * Removes the item with the given key or all items matching condition.
- *
- * @param map - a map
- * @param conditionOrItem - the key of an item to remove or a condition matching
- * items to remove
- */
-function remove(map, conditionOrItem) {
- if (!(0, util_1.isFunction)(conditionOrItem)) {
- map.delete(conditionOrItem);
- }
- else {
- const toRemove = [];
- for (const item of map) {
- if (!!conditionOrItem.call(null, item)) {
- toRemove.push(item[0]);
- }
- }
- for (const key of toRemove) {
- map.delete(key);
- }
- }
-}
-/**
- * Determines if the map contains a value with the given key.
- *
- * @param map - a map
- * @param conditionOrItem - the key of an item to match or a condition matching
- * items
- */
-function contains(map, conditionOrItem) {
- if (!(0, util_1.isFunction)(conditionOrItem)) {
- return map.has(conditionOrItem);
- }
- else {
- for (const item of map) {
- if (!!conditionOrItem.call(null, item)) {
- return true;
- }
- }
- return false;
- }
-}
-/**
- * Gets the keys of the map.
- *
- * @param map - a map
- */
-function keys(map) {
- return new Set(map.keys());
-}
-/**
- * Gets the values of the map.
- *
- * @param map - a map
- */
-function values(map) {
- return [...map.values()];
-}
-/**
- * Gets the size of the map.
- *
- * @param map - a map
- * @param condition - an optional condition to match
- */
-function size(map, condition) {
- if (condition === undefined) {
- return map.size;
- }
- else {
- let count = 0;
- for (const item of map) {
- if (!!condition.call(null, item)) {
- count++;
- }
- }
- return count;
- }
-}
-/**
- * Determines if the map is empty.
- *
- * @param map - a map
- */
-function isEmpty(map) {
- return map.size === 0;
-}
-/**
- * Returns an iterator for the items of the map.
- *
- * @param map - a map
- * @param condition - an optional condition to match
- */
-function* forEach(map, condition) {
- if (condition === undefined) {
- yield* map;
- }
- else {
- for (const item of map) {
- if (!!condition.call(null, item)) {
- yield item;
- }
- }
- }
-}
-/**
- * Creates and returns a shallow clone of map.
- *
- * @param map - a map
- */
-function clone(map) {
- return new Map(map);
-}
-/**
- * Returns a new map containing items from the map sorted in ascending
- * order.
- *
- * @param map - a map
- * @param lessThanAlgo - a function that returns `true` if its first argument
- * is less than its second argument, and `false` otherwise.
- */
-function sortInAscendingOrder(map, lessThanAlgo) {
- const list = new Array(...map);
- list.sort((itemA, itemB) => lessThanAlgo.call(null, itemA, itemB) ? -1 : 1);
- return new Map(list);
-}
-/**
- * Returns a new map containing items from the map sorted in descending
- * order.
- *
- * @param map - a map
- * @param lessThanAlgo - a function that returns `true` if its first argument
- * is less than its second argument, and `false` otherwise.
- */
-function sortInDescendingOrder(map, lessThanAlgo) {
- const list = new Array(...map);
- list.sort((itemA, itemB) => lessThanAlgo.call(null, itemA, itemB) ? 1 : -1);
- return new Map(list);
-}
-//# sourceMappingURL=Map.js.map
-
-/***/ }),
-
-/***/ 9018:
-/***/ ((__unused_webpack_module, exports) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.XLink = exports.SVG = exports.MathML = exports.XMLNS = exports.XML = exports.HTML = void 0;
-exports.HTML = "http://www.w3.org/1999/xhtml";
-exports.XML = "http://www.w3.org/XML/1998/namespace";
-exports.XMLNS = "http://www.w3.org/2000/xmlns/";
-exports.MathML = "http://www.w3.org/1998/Math/MathML";
-exports.SVG = "http://www.w3.org/2000/svg";
-exports.XLink = "http://www.w3.org/1999/xlink";
-//# sourceMappingURL=Namespace.js.map
-
-/***/ }),
-
-/***/ 7758:
-/***/ ((__unused_webpack_module, exports) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.enqueue = enqueue;
-exports.dequeue = dequeue;
-/**
- * Appends the given item to the queue.
- *
- * @param list - a list
- * @param item - an item
- */
-function enqueue(list, item) {
- list.push(item);
-}
-/**
- * Removes and returns an item from the queue.
- *
- * @param list - a list
- */
-function dequeue(list) {
- return list.shift() || null;
-}
-//# sourceMappingURL=Queue.js.map
-
-/***/ }),
-
-/***/ 2237:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.append = append;
-exports.extend = extend;
-exports.prepend = prepend;
-exports.replace = replace;
-exports.insert = insert;
-exports.remove = remove;
-exports.empty = empty;
-exports.contains = contains;
-exports.size = size;
-exports.isEmpty = isEmpty;
-exports.forEach = forEach;
-exports.clone = clone;
-exports.sortInAscendingOrder = sortInAscendingOrder;
-exports.sortInDescendingOrder = sortInDescendingOrder;
-exports.isSubsetOf = isSubsetOf;
-exports.isSupersetOf = isSupersetOf;
-exports.intersection = intersection;
-exports.union = union;
-exports.range = range;
-const util_1 = __nccwpck_require__(7061);
-/**
- * Adds the given item to the end of the set.
- *
- * @param set - a set
- * @param item - an item
- */
-function append(set, item) {
- set.add(item);
-}
-/**
- * Extends a set by appending all items from another set.
- *
- * @param setA - a list to extend
- * @param setB - a list containing items to append to `setA`
- */
-function extend(setA, setB) {
- setB.forEach(setA.add, setA);
-}
-/**
- * Inserts the given item to the start of the set.
- *
- * @param set - a set
- * @param item - an item
- */
-function prepend(set, item) {
- const cloned = new Set(set);
- set.clear();
- set.add(item);
- cloned.forEach(set.add, set);
-}
-/**
- * Replaces the given item or all items matching condition with a new item.
- *
- * @param set - a set
- * @param conditionOrItem - an item to replace or a condition matching items
- * to replace
- * @param item - an item
- */
-function replace(set, conditionOrItem, newItem) {
- const newSet = new Set();
- for (const oldItem of set) {
- if ((0, util_1.isFunction)(conditionOrItem)) {
- if (!!conditionOrItem.call(null, oldItem)) {
- newSet.add(newItem);
- }
- else {
- newSet.add(oldItem);
- }
- }
- else if (oldItem === conditionOrItem) {
- newSet.add(newItem);
- }
- else {
- newSet.add(oldItem);
- }
- }
- set.clear();
- newSet.forEach(set.add, set);
-}
-/**
- * Inserts the given item before the given index.
- *
- * @param set - a set
- * @param item - an item
- */
-function insert(set, item, index) {
- const newSet = new Set();
- let i = 0;
- for (const oldItem of set) {
- if (i === index)
- newSet.add(item);
- newSet.add(oldItem);
- i++;
- }
- set.clear();
- newSet.forEach(set.add, set);
-}
-/**
- * Removes the given item or all items matching condition.
- *
- * @param set - a set
- * @param conditionOrItem - an item to remove or a condition matching items
- * to remove
- */
-function remove(set, conditionOrItem) {
- if (!(0, util_1.isFunction)(conditionOrItem)) {
- set.delete(conditionOrItem);
- }
- else {
- const toRemove = [];
- for (const item of set) {
- if (!!conditionOrItem.call(null, item)) {
- toRemove.push(item);
- }
- }
- for (const oldItem of toRemove) {
- set.delete(oldItem);
- }
- }
-}
-/**
- * Removes all items from the set.
- */
-function empty(set) {
- set.clear();
-}
-/**
- * Determines if the set contains the given item or any items matching
- * condition.
- *
- * @param set - a set
- * @param conditionOrItem - an item to a condition to match
- */
-function contains(set, conditionOrItem) {
- if (!(0, util_1.isFunction)(conditionOrItem)) {
- return set.has(conditionOrItem);
- }
- else {
- for (const oldItem of set) {
- if (!!conditionOrItem.call(null, oldItem)) {
- return true;
- }
- }
- }
- return false;
-}
-/**
- * Returns the count of items in the set matching the given condition.
- *
- * @param set - a set
- * @param condition - an optional condition to match
- */
-function size(set, condition) {
- if (condition === undefined) {
- return set.size;
- }
- else {
- let count = 0;
- for (const item of set) {
- if (!!condition.call(null, item)) {
- count++;
- }
- }
- return count;
- }
-}
-/**
- * Determines if the set is empty.
- *
- * @param set - a set
- */
-function isEmpty(set) {
- return set.size === 0;
-}
-/**
- * Returns an iterator for the items of the set.
- *
- * @param set - a set
- * @param condition - an optional condition to match
- */
-function* forEach(set, condition) {
- if (condition === undefined) {
- yield* set;
- }
- else {
- for (const item of set) {
- if (!!condition.call(null, item)) {
- yield item;
- }
- }
- }
-}
-/**
- * Creates and returns a shallow clone of set.
- *
- * @param set - a set
- */
-function clone(set) {
- return new Set(set);
-}
-/**
- * Returns a new set containing items from the set sorted in ascending
- * order.
- *
- * @param set - a set
- * @param lessThanAlgo - a function that returns `true` if its first argument
- * is less than its second argument, and `false` otherwise.
- */
-function sortInAscendingOrder(set, lessThanAlgo) {
- const list = new Array(...set);
- list.sort((itemA, itemB) => lessThanAlgo.call(null, itemA, itemB) ? -1 : 1);
- return new Set(list);
-}
-/**
- * Returns a new set containing items from the set sorted in descending
- * order.
- *
- * @param set - a set
- * @param lessThanAlgo - a function that returns `true` if its first argument
- * is less than its second argument, and `false` otherwise.
- */
-function sortInDescendingOrder(set, lessThanAlgo) {
- const list = new Array(...set);
- list.sort((itemA, itemB) => lessThanAlgo.call(null, itemA, itemB) ? 1 : -1);
- return new Set(list);
-}
-/**
- * Determines if a set is a subset of another set.
- *
- * @param subset - a set
- * @param superset - a superset possibly containing all items from `subset`.
- */
-function isSubsetOf(subset, superset) {
- for (const item of subset) {
- if (!superset.has(item))
- return false;
- }
- return true;
-}
-/**
- * Determines if a set is a superset of another set.
- *
- * @param superset - a set
- * @param subset - a subset possibly contained within `superset`.
- */
-function isSupersetOf(superset, subset) {
- return isSubsetOf(subset, superset);
-}
-/**
- * Returns a new set with items that are contained in both sets.
- *
- * @param setA - a set
- * @param setB - a set
- */
-function intersection(setA, setB) {
- const newSet = new Set();
- for (const item of setA) {
- if (setB.has(item))
- newSet.add(item);
- }
- return newSet;
-}
-/**
- * Returns a new set with items from both sets.
- *
- * @param setA - a set
- * @param setB - a set
- */
-function union(setA, setB) {
- const newSet = new Set(setA);
- setB.forEach(newSet.add, newSet);
- return newSet;
-}
-/**
- * Returns a set of integers from `n` to `m` inclusive.
- *
- * @param n - starting number
- * @param m - ending number
- */
-function range(n, m) {
- const newSet = new Set();
- for (let i = n; i <= m; i++) {
- newSet.add(i);
- }
- return newSet;
-}
-//# sourceMappingURL=Set.js.map
-
-/***/ }),
-
-/***/ 9221:
-/***/ ((__unused_webpack_module, exports) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.push = push;
-exports.pop = pop;
-/**
- * Pushes the given item to the stack.
- *
- * @param list - a list
- * @param item - an item
- */
-function push(list, item) {
- list.push(item);
-}
-/**
- * Pops and returns an item from the stack.
- *
- * @param list - a list
- */
-function pop(list) {
- return list.pop() || null;
-}
-//# sourceMappingURL=Stack.js.map
-
-/***/ }),
-
-/***/ 2472:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.isCodeUnitPrefix = isCodeUnitPrefix;
-exports.isCodeUnitLessThan = isCodeUnitLessThan;
-exports.isomorphicEncode = isomorphicEncode;
-exports.isASCIIString = isASCIIString;
-exports.asciiLowercase = asciiLowercase;
-exports.asciiUppercase = asciiUppercase;
-exports.asciiCaseInsensitiveMatch = asciiCaseInsensitiveMatch;
-exports.asciiEncode = asciiEncode;
-exports.asciiDecode = asciiDecode;
-exports.stripNewlines = stripNewlines;
-exports.normalizeNewlines = normalizeNewlines;
-exports.stripLeadingAndTrailingASCIIWhitespace = stripLeadingAndTrailingASCIIWhitespace;
-exports.stripAndCollapseASCIIWhitespace = stripAndCollapseASCIIWhitespace;
-exports.collectASequenceOfCodePoints = collectASequenceOfCodePoints;
-exports.skipASCIIWhitespace = skipASCIIWhitespace;
-exports.strictlySplit = strictlySplit;
-exports.splitAStringOnASCIIWhitespace = splitAStringOnASCIIWhitespace;
-exports.splitAStringOnCommas = splitAStringOnCommas;
-exports.concatenate = concatenate;
-const CodePoints_1 = __nccwpck_require__(4467);
-const ByteSequence_1 = __nccwpck_require__(2017);
-const Byte_1 = __nccwpck_require__(8311);
-const util_1 = __nccwpck_require__(7061);
-/**
- * Determines if the string `a` is a code unit prefix of string `b`.
- *
- * @param a - a string
- * @param b - a string
- */
-function isCodeUnitPrefix(a, b) {
- /**
- * 1. Let i be 0.
- * 2. While true:
- * 2.1. Let aCodeUnit be the ith code unit of a if i is less than a’s length;
- * otherwise null.
- * 2.2. Let bCodeUnit be the ith code unit of b if i is less than b’s length;
- * otherwise null.
- * 2.3. If bCodeUnit is null, then return true.
- * 2.4. Return false if aCodeUnit is different from bCodeUnit.
- * 2.5. Set i to i + 1.
- */
- let i = 0;
- while (true) {
- const aCodeUnit = i < a.length ? a.charCodeAt(i) : null;
- const bCodeUnit = i < b.length ? b.charCodeAt(i) : null;
- if (aCodeUnit === null)
- return true;
- if (aCodeUnit !== bCodeUnit)
- return false;
- i++;
- }
-}
-/**
- * Determines if the string `a` is a code unit less than string `b`.
- *
- * @param a - a string
- * @param b - a string
- */
-function isCodeUnitLessThan(a, b) {
- /**
- * 1. If b is a code unit prefix of a, then return false.
- * 2. If a is a code unit prefix of b, then return true.
- * 3. Let n be the smallest index such that the nth code unit of a is
- * different from the nth code unit of b. (There has to be such an index,
- * since neither string is a prefix of the other.)
- * 4. If the nth code unit of a is less than the nth code unit of b, then
- * return true.
- * 5. Return false.
- */
- if (isCodeUnitPrefix(b, a))
- return false;
- if (isCodeUnitPrefix(a, b))
- return true;
- for (let i = 0; i < Math.min(a.length, b.length); i++) {
- const aCodeUnit = a.charCodeAt(i);
- const bCodeUnit = b.charCodeAt(i);
- if (aCodeUnit === bCodeUnit)
- continue;
- return (aCodeUnit < bCodeUnit);
- }
- /* istanbul ignore next */
- return false;
-}
-/**
- * Isomorphic encodes the given string.
- *
- * @param str - a string
- */
-function isomorphicEncode(str) {
- /**
- * 1. Assert: input contains no code points greater than U+00FF.
- * 2. Return a byte sequence whose length is equal to input’s length and whose
- * bytes have the same values as input’s code points, in the same order.
- */
- const codePoints = Array.from(str);
- const bytes = new Uint8Array(codePoints.length);
- let i = 0;
- for (const codePoint of str) {
- const byte = codePoint.codePointAt(0);
- console.assert(byte !== undefined && byte <= 0x00FF, "isomorphicEncode requires string bytes to be less than or equal to 0x00FF.");
- if (byte !== undefined && byte <= 0x00FF) {
- bytes[i++] = byte;
- }
- }
- return bytes;
-}
-/**
- * Determines if the given string is An ASCII string.
- *
- * @param str - a string
- */
-function isASCIIString(str) {
- /**
- * An ASCII string is a string whose code points are all ASCII code points.
- */
- return /^[\u0000-\u007F]*$/.test(str);
-}
-/**
- * Converts all uppercase ASCII code points to lowercase.
- *
- * @param str - a string
- */
-function asciiLowercase(str) {
- /**
- * To ASCII lowercase a string, replace all ASCII upper alphas in the string
- * with their corresponding code point in ASCII lower alpha.
- */
- let result = "";
- for (const c of str) {
- const code = c.codePointAt(0);
- if (code !== undefined && code >= 0x41 && code <= 0x5A) {
- result += String.fromCodePoint(code + 0x20);
- }
- else {
- result += c;
- }
- }
- return result;
-}
-/**
- * Converts all uppercase ASCII code points to uppercase.
- *
- * @param str - a string
- */
-function asciiUppercase(str) {
- /**
- * To ASCII uppercase a string, replace all ASCII lower alphas in the string
- * with their corresponding code point in ASCII upper alpha.
- */
- let result = "";
- for (const c of str) {
- const code = c.codePointAt(0);
- if (code !== undefined && code >= 0x61 && code <= 0x7A) {
- result += String.fromCodePoint(code - 0x20);
- }
- else {
- result += c;
- }
- }
- return result;
-}
-/**
- * Compares two ASCII strings case-insensitively.
- *
- * @param a - a string
- * @param b - a string
- */
-function asciiCaseInsensitiveMatch(a, b) {
- /**
- * A string A is an ASCII case-insensitive match for a string B, if the ASCII
- * lowercase of A is the ASCII lowercase of B.
- */
- return asciiLowercase(a) === asciiLowercase(b);
-}
-/**
- * ASCII encodes a string.
- *
- * @param str - a string
- */
-function asciiEncode(str) {
- /**
- * 1. Assert: input is an ASCII string.
- * 2. Return the isomorphic encoding of input.
- */
- console.assert(isASCIIString(str), "asciiEncode requires an ASCII string.");
- return isomorphicEncode(str);
-}
-/**
- * ASCII decodes a byte sequence.
- *
- * @param bytes - a byte sequence
- */
-function asciiDecode(bytes) {
- /**
- * 1. Assert: All bytes in input are ASCII bytes.
- * 2. Return the isomorphic decoding of input.
- */
- for (const byte of bytes) {
- console.assert((0, Byte_1.isASCIIByte)(byte), "asciiDecode requires an ASCII byte sequence.");
- }
- return (0, ByteSequence_1.isomorphicDecode)(bytes);
-}
-/**
- * Strips newline characters from a string.
- *
- * @param str - a string
- */
-function stripNewlines(str) {
- /**
- * To strip newlines from a string, remove any U+000A LF and U+000D CR code
- * points from the string.
- */
- return str.replace(/[\n\r]/g, "");
-}
-/**
- * Normalizes newline characters in a string by converting consecutive
- * carriage-return newline characters and also single carriage return characters
- * into a single newline.
- *
- * @param str - a string
- */
-function normalizeNewlines(str) {
- /**
- * To normalize newlines in a string, replace every U+000D CR U+000A LF code
- * point pair with a single U+000A LF code point, and then replace every
- * remaining U+000D CR code point with a U+000A LF code point.
- */
- return str.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
-}
-/**
- * Removes leading and trailing whitespace characters from a string.
- *
- * @param str - a string
- */
-function stripLeadingAndTrailingASCIIWhitespace(str) {
- /**
- * To strip leading and trailing ASCII whitespace from a string, remove all
- * ASCII whitespace that are at the start or the end of the string.
- */
- return str.replace(/^[\t\n\f\r ]+/, "").replace(/[\t\n\f\r ]+$/, "");
-}
-/**
- * Removes consecutive newline characters from a string.
- *
- * @param str - a string
- */
-function stripAndCollapseASCIIWhitespace(str) {
- /**
- * To strip and collapse ASCII whitespace in a string, replace any sequence of
- * one or more consecutive code points that are ASCII whitespace in the string
- * with a single U+0020 SPACE code point, and then remove any leading and
- * trailing ASCII whitespace from that string.
- */
- return stripLeadingAndTrailingASCIIWhitespace(str.replace(/[\t\n\f\r ]{2,}/g, " "));
-}
-/**
- * Collects a sequence of code points matching a given condition from the input
- * string.
- *
- * @param condition - a condition to match
- * @param input - a string
- * @param options - starting position
- */
-function collectASequenceOfCodePoints(condition, input, options) {
- /**
- * 1. Let result be the empty string.
- * 2. While position doesn’t point past the end of input and the code point at
- * position within input meets the condition condition:
- * 2.1. Append that code point to the end of result.
- * 2.2. Advance position by 1.
- * 3. Return result.
- */
- if (!(0, util_1.isArray)(input))
- return collectASequenceOfCodePoints(condition, Array.from(input), options);
- let result = "";
- while (options.position < input.length && !!condition.call(null, input[options.position])) {
- result += input[options.position];
- options.position++;
- }
- return result;
-}
-/**
- * Skips over ASCII whitespace.
- *
- * @param input - input string
- * @param options - starting position
- */
-function skipASCIIWhitespace(input, options) {
- /**
- * To skip ASCII whitespace within a string input given a position variable
- * position, collect a sequence of code points that are ASCII whitespace from
- * input given position. The collected code points are not used, but position
- * is still updated.
- */
- collectASequenceOfCodePoints(str => CodePoints_1.ASCIIWhiteSpace.test(str), input, options);
-}
-/**
- * Solits a string at the given delimiter.
- *
- * @param input - input string
- * @param delimiter - a delimiter string
- */
-function strictlySplit(input, delimiter) {
- /**
- * 1. Let position be a position variable for input, initially pointing at the
- * start of input.
- * 2. Let tokens be a list of strings, initially empty.
- * 3. Let token be the result of collecting a sequence of code points that are
- * not equal to delimiter from input, given position.
- * 4. Append token to tokens.
- * 5. While position is not past the end of input:
- * 5.1. Assert: the code point at position within input is delimiter.
- * 5.2. Advance position by 1.
- * 5.3. Let token be the result of collecting a sequence of code points that
- * are not equal to delimiter from input, given position.
- * 5.4. Append token to tokens.
- * 6. Return tokens.
- */
- if (!(0, util_1.isArray)(input))
- return strictlySplit(Array.from(input), delimiter);
- const options = { position: 0 };
- const tokens = [];
- let token = collectASequenceOfCodePoints(str => delimiter !== str, input, options);
- tokens.push(token);
- while (options.position < input.length) {
- console.assert(input[options.position] === delimiter, "strictlySplit found no delimiter in input string.");
- options.position++;
- token = collectASequenceOfCodePoints(str => delimiter !== str, input, options);
- tokens.push(token);
- }
- return tokens;
-}
-/**
- * Splits a string on ASCII whitespace.
- *
- * @param input - a string
- */
-function splitAStringOnASCIIWhitespace(input) {
- /**
- * 1. Let position be a position variable for input, initially pointing at the
- * start of input.
- * 2. Let tokens be a list of strings, initially empty.
- * 3. Skip ASCII whitespace within input given position.
- * 4. While position is not past the end of input:
- * 4.1. Let token be the result of collecting a sequence of code points that
- * are not ASCII whitespace from input, given position.
- * 4.2. Append token to tokens.
- * 4.3. Skip ASCII whitespace within input given position.
- * 5. Return tokens.
- */
- if (!(0, util_1.isArray)(input))
- return splitAStringOnASCIIWhitespace(Array.from(input));
- const options = { position: 0 };
- const tokens = [];
- skipASCIIWhitespace(input, options);
- while (options.position < input.length) {
- const token = collectASequenceOfCodePoints(str => !CodePoints_1.ASCIIWhiteSpace.test(str), input, options);
- tokens.push(token);
- skipASCIIWhitespace(input, options);
- }
- return tokens;
-}
-/**
- * Splits a string on commas.
- *
- * @param input - a string
- */
-function splitAStringOnCommas(input) {
- /**
- * 1. Let position be a position variable for input, initially pointing at the
- * start of input.
- * 2. Let tokens be a list of strings, initially empty.
- * 3. While position is not past the end of input:
- * 3.1. Let token be the result of collecting a sequence of code points that
- * are not U+002C (,) from input, given position.
- * 3.2. Strip leading and trailing ASCII whitespace from token.
- * 3.3. Append token to tokens.
- * 3.4. If position is not past the end of input, then:
- * 3.4.1. Assert: the code point at position within input is U+002C (,).
- * 3.4.2. Advance position by 1.
- * 4. Return tokens.
- */
- if (!(0, util_1.isArray)(input))
- return splitAStringOnCommas(Array.from(input));
- const options = { position: 0 };
- const tokens = [];
- while (options.position < input.length) {
- const token = collectASequenceOfCodePoints(str => str !== ',', input, options);
- tokens.push(stripLeadingAndTrailingASCIIWhitespace(token));
- if (options.position < input.length) {
- console.assert(input[options.position] === ',', "splitAStringOnCommas found no delimiter in input string.");
- options.position++;
- }
- }
- return tokens;
-}
-/**
- * Concatenates a list of strings with the given separator.
- *
- * @param list - a list of strings
- * @param separator - a separator string
- */
-function concatenate(list, separator = "") {
- /**
- * 1. If list is empty, then return the empty string.
- * 2. If separator is not given, then set separator to the empty string.
- * 3. Return a string whose contents are list’s items, in order, separated
- * from each other by separator.
- */
- if (list.length === 0)
- return "";
- return list.join(separator);
-}
-//# sourceMappingURL=String.js.map
-
-/***/ }),
-
-/***/ 4737:
-/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
-
-
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
- if (k2 === undefined) k2 = k;
- var desc = Object.getOwnPropertyDescriptor(m, k);
- if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
- desc = { enumerable: true, get: function() { return m[k]; } };
- }
- Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
- if (k2 === undefined) k2 = k;
- o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
- Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
- o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
- var ownKeys = function(o) {
- ownKeys = Object.getOwnPropertyNames || function (o) {
- var ar = [];
- for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
- return ar;
- };
- return ownKeys(o);
- };
- return function (mod) {
- if (mod && mod.__esModule) return mod;
- var result = {};
- if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
- __setModuleDefault(result, mod);
- return result;
- };
-})();
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.string = exports.stack = exports.set = exports.queue = exports.namespace = exports.map = exports.list = exports.json = exports.codePoint = exports.byteSequence = exports.byte = exports.base64 = void 0;
-const base64 = __importStar(__nccwpck_require__(9558));
-exports.base64 = base64;
-const byte = __importStar(__nccwpck_require__(8311));
-exports.byte = byte;
-const byteSequence = __importStar(__nccwpck_require__(2017));
-exports.byteSequence = byteSequence;
-const codePoint = __importStar(__nccwpck_require__(4467));
-exports.codePoint = codePoint;
-const json = __importStar(__nccwpck_require__(5475));
-exports.json = json;
-const list = __importStar(__nccwpck_require__(1193));
-exports.list = list;
-const map = __importStar(__nccwpck_require__(6067));
-exports.map = map;
-const namespace = __importStar(__nccwpck_require__(9018));
-exports.namespace = namespace;
-const queue = __importStar(__nccwpck_require__(7758));
-exports.queue = queue;
-const set = __importStar(__nccwpck_require__(2237));
-exports.set = set;
-const stack = __importStar(__nccwpck_require__(9221));
-exports.stack = stack;
-const string = __importStar(__nccwpck_require__(2472));
-exports.string = string;
-//# sourceMappingURL=index.js.map
-
-/***/ }),
-
-/***/ 3650:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.setValidationErrorCallback = setValidationErrorCallback;
-exports.newURL = newURL;
-exports.isSpecialScheme = isSpecialScheme;
-exports.isSpecial = isSpecial;
-exports.defaultPort = defaultPort;
-exports.includesCredentials = includesCredentials;
-exports.cannotHaveAUsernamePasswordPort = cannotHaveAUsernamePasswordPort;
-exports.urlSerializer = urlSerializer;
-exports.hostSerializer = hostSerializer;
-exports.iPv4Serializer = iPv4Serializer;
-exports.iPv6Serializer = iPv6Serializer;
-exports.urlParser = urlParser;
-exports.basicURLParser = basicURLParser;
-exports.setTheUsername = setTheUsername;
-exports.setThePassword = setThePassword;
-exports.isSingleDotPathSegment = isSingleDotPathSegment;
-exports.isDoubleDotPathSegment = isDoubleDotPathSegment;
-exports.shorten = shorten;
-exports.isNormalizedWindowsDriveLetter = isNormalizedWindowsDriveLetter;
-exports.isWindowsDriveLetter = isWindowsDriveLetter;
-exports.startsWithAWindowsDriveLetter = startsWithAWindowsDriveLetter;
-exports.hostParser = hostParser;
-exports.iPv4NumberParser = iPv4NumberParser;
-exports.iPv4Parser = iPv4Parser;
-exports.iPv6Parser = iPv6Parser;
-exports.opaqueHostParser = opaqueHostParser;
-exports.resolveABlobURL = resolveABlobURL;
-exports.percentEncode = percentEncode;
-exports.percentDecode = percentDecode;
-exports.stringPercentDecode = stringPercentDecode;
-exports.utf8PercentEncode = utf8PercentEncode;
-exports.hostEquals = hostEquals;
-exports.urlEquals = urlEquals;
-exports.urlEncodedStringParser = urlEncodedStringParser;
-exports.urlEncodedParser = urlEncodedParser;
-exports.urlEncodedByteSerializer = urlEncodedByteSerializer;
-exports.urlEncodedSerializer = urlEncodedSerializer;
-exports.origin = origin;
-exports.domainToASCII = domainToASCII;
-exports.domainToUnicode = domainToUnicode;
-exports.asciiSerializationOfAnOrigin = asciiSerializationOfAnOrigin;
-const util_1 = __nccwpck_require__(7061);
-const interfaces_1 = __nccwpck_require__(3904);
-const infra_1 = __nccwpck_require__(4737);
-const url_1 = __nccwpck_require__(7016);
-let _validationErrorCallback;
-/**
- * Default ports for a special URL scheme.
- */
-const _defaultPorts = {
- "ftp": 21,
- "file": null,
- "http": 80,
- "https": 443,
- "ws": 80,
- "wss": 443
-};
-/**
- * The C0 control percent-encode set are the C0 controls and all code points
- * greater than U+007E (~).
- */
-const _c0ControlPercentEncodeSet = /[\0-\x1F\x7F-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/;
-/**
- * The fragment percent-encode set is the C0 control percent-encode set and
- * U+0020 SPACE, U+0022 ("), U+003C (<), U+003E (>), and U+0060 (`).
- */
-const _fragmentPercentEncodeSet = /[ "<>`]|[\0-\x1F\x7F-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/;
-/**
- * The path percent-encode set is the fragment percent-encode set and
- * U+0023 (#), U+003F (?), U+007B ({), and U+007D (}).
- */
-const _pathPercentEncodeSet = /[ "<>`#?{}]|[\0-\x1F\x7F-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/;
-/**
- * The userinfo percent-encode set is the path percent-encode set and
- * U+002F (/), U+003A (:), U+003B (;), U+003D (=), U+0040 (@), U+005B ([),
- * U+005C (\), U+005D (]), U+005E (^), and U+007C (|).
- */
-const _userInfoPercentEncodeSet = /[ "<>`#?{}/:;=@\[\]\\\^\|]|[\0-\x1F\x7F-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/;
-/**
- * The URL code points are ASCII alphanumeric, U+0021 (!), U+0024 ($),
- * U+0026 (&), U+0027 ('), U+0028 LEFT PARENTHESIS, U+0029 RIGHT PARENTHESIS,
- * U+002A (*), U+002B (+), U+002C (,), U+002D (-), U+002E (.), U+002F (/),
- * U+003A (:), U+003B (;), U+003D (=), U+003F (?), U+0040 (@), U+005F (_),
- * U+007E (~), and code points in the range U+00A0 to U+10FFFD, inclusive,
- * excluding surrogates and noncharacters.
- */
-const _urlCodePoints = /[0-9A-Za-z!\$&-\/:;=\?@_~\xA0-\uD7FF\uE000-\uFDCF\uFDF0-\uFFFD]|[\uD800-\uD83E\uD840-\uD87E\uD880-\uD8BE\uD8C0-\uD8FE\uD900-\uD93E\uD940-\uD97E\uD980-\uD9BE\uD9C0-\uD9FE\uDA00-\uDA3E\uDA40-\uDA7E\uDA80-\uDABE\uDAC0-\uDAFE\uDB00-\uDB3E\uDB40-\uDB7E\uDB80-\uDBBE\uDBC0-\uDBFE][\uDC00-\uDFFF]|[\uD83F\uD87F\uD8BF\uD8FF\uD93F\uD97F\uD9BF\uD9FF\uDA3F\uDA7F\uDABF\uDAFF\uDB3F\uDB7F\uDBBF\uDBFF][\uDC00-\uDFFD]/;
-/**
- * A forbidden host code point is U+0000 NULL, U+0009 TAB, U+000A LF,
- * U+000D CR, U+0020 SPACE, U+0023 (#), U+0025 (%), U+002F (/), U+003A (:),
- * U+003F (?), U+0040 (@), U+005B ([), U+005C (\), or U+005D (]).
- */
-const _forbiddenHostCodePoint = /[\0\t\f\r #%/:?@\[\\\]]/;
-/**
- * Sets the callback function for validation errors.
- *
- * @param validationErrorCallback - a callback function to be called when a
- * validation error occurs
- */
-function setValidationErrorCallback(validationErrorCallback) {
- _validationErrorCallback = validationErrorCallback;
-}
-/**
- * Generates a validation error.
- *
- * @param message - error message
- */
-function validationError(message) {
- if (_validationErrorCallback !== undefined) {
- _validationErrorCallback.call(null, "Validation Error: " + message);
- }
-}
-/**
- * Creates a new URL.
- */
-function newURL() {
- return {
- scheme: '',
- username: '',
- password: '',
- host: null,
- port: null,
- path: [],
- query: null,
- fragment: null,
- _cannotBeABaseURLFlag: false,
- _blobURLEntry: null
- };
-}
-/**
- * Determines if the scheme is a special scheme.
- *
- * @param scheme - a scheme
- */
-function isSpecialScheme(scheme) {
- return (scheme in _defaultPorts);
-}
-/**
- * Determines if the URL has a special scheme.
- *
- * @param url - an URL
- */
-function isSpecial(url) {
- return isSpecialScheme(url.scheme);
-}
-/**
- * Returns the default port for a special scheme.
- *
- * @param scheme - a scheme
- */
-function defaultPort(scheme) {
- return _defaultPorts[scheme] || null;
-}
-/**
- * Determines if the URL has credentials.
- *
- * @param url - an URL
- */
-function includesCredentials(url) {
- return url.username !== '' || url.password !== '';
-}
-/**
- * Determines if an URL cannot have credentials.
- *
- * @param url - an URL
- */
-function cannotHaveAUsernamePasswordPort(url) {
- /**
- * A URL cannot have a username/password/port if its host is null or the
- * empty string, its cannot-be-a-base-URL flag is set, or its scheme is
- * "file".
- */
- return (url.host === null || url.host === "" || url._cannotBeABaseURLFlag ||
- url.scheme === "file");
-}
-/**
- * Serializes an URL into a string.
- *
- * @param url - an URL
- */
-function urlSerializer(url, excludeFragmentFlag = false) {
- /**
- * 1. Let output be url’s scheme and U+003A (:) concatenated.
- */
- let output = url.scheme + ':';
- /**
- * 2. If url’s host is non-null:
- */
- if (url.host !== null) {
- /**
- * 2.1. Append "//" to output.
- */
- output += '//';
- /**
- * 2.2. If url includes credentials, then:
- */
- if (includesCredentials(url)) {
- /**
- * 2.2.1. Append url’s username to output.
- * 2.2.2. If url’s password is not the empty string, then append U+003A (:),
- * followed by url’s password, to output.
- * 2.2.3. Append U+0040 (@) to output.
- */
- output += url.username;
- if (url.password !== '') {
- output += ':' + url.password;
- }
- output += '@';
- }
- /**
- * 2.3. Append url’s host, serialized, to output.
- * 2.4. If url’s port is non-null, append U+003A (:) followed by url’s port,
- * serialized, to output.
- */
- output += hostSerializer(url.host);
- if (url.port !== null) {
- output += ':' + url.port;
- }
- }
- else if (url.host === null && url.scheme === "file") {
- /**
- * 3. Otherwise, if url’s host is null and url’s scheme is "file", append "//" to output.
- */
- output += '//';
- }
- /**
- * 4. If url’s cannot-be-a-base-URL flag is set, append url’s path[0] to
- * output.
- * 5. Otherwise, then for each string in url’s path, append U+002F (/)
- * followed by the string to output.
- */
- if (url._cannotBeABaseURLFlag) {
- output += url.path[0];
- }
- else {
- for (const str of url.path) {
- output += '/' + str;
- }
- }
- /**
- * 6. If url’s query is non-null, append U+003F (?), followed by url’s
- * query, to output.
- * 7. If the exclude fragment flag is unset and url’s fragment is non-null,
- * append U+0023 (#), followed by url’s fragment, to output.
- * 8. Return output.
- */
- if (url.query !== null) {
- output += '?' + url.query;
- }
- if (!excludeFragmentFlag && url.fragment !== null) {
- output += '#' + url.fragment;
- }
- return output;
-}
-/**
- * Serializes a host into a string.
- *
- * @param host - a host
- */
-function hostSerializer(host) {
- /**
- * 1. If host is an IPv4 address, return the result of running the IPv4
- * serializer on host.
- * 2. Otherwise, if host is an IPv6 address, return U+005B ([), followed
- * by the result of running the IPv6 serializer on host, followed by
- * U+005D (]).
- * 3. Otherwise, host is a domain, opaque host, or empty host, return host.
- */
- if ((0, util_1.isNumber)(host)) {
- return iPv4Serializer(host);
- }
- else if ((0, util_1.isArray)(host)) {
- return '[' + iPv6Serializer(host) + ']';
- }
- else {
- return host;
- }
-}
-/**
- * Serializes an IPv4 address into a string.
- *
- * @param address - an IPv4 address
- */
-function iPv4Serializer(address) {
- /**
- * 1. Let output be the empty string.
- * 2. Let n be the value of address.
- * 3. For each i in the range 1 to 4, inclusive:
- * 3.1. Prepend n % 256, serialized, to output.
- * 3.2. If i is not 4, then prepend U+002E (.) to output.
- * 3.3. Set n to floor(n / 256).
- * 4. Return output.
- */
- let output = "";
- let n = address;
- for (let i = 1; i <= 4; i++) {
- output = (n % 256).toString() + output;
- if (i !== 4) {
- output = '.' + output;
- }
- n = Math.floor(n / 256);
- }
- return output;
-}
-/**
- * Serializes an IPv6 address into a string.
- *
- * @param address - an IPv6 address represented as a list of eight numbers
- */
-function iPv6Serializer(address) {
- /**
- * 1. Let output be the empty string.
- * 2. Let compress be an index to the first IPv6 piece in the first longest
- * sequences of address’s IPv6 pieces that are 0.
- * In 0:f:0:0:f:f:0:0 it would point to the second 0.
- * 3. If there is no sequence of address’s IPv6 pieces that are 0 that is
- * longer than 1, then set compress to null.
- */
- let output = "";
- let compress = null;
- let lastIndex = -1;
- let count = 0;
- let lastCount = 0;
- for (let i = 0; i < 8; i++) {
- if (address[i] !== 0)
- continue;
- count = 1;
- for (let j = i + 1; j < 8; j++) {
- if (address[j] !== 0)
- break;
- count++;
- continue;
- }
- if (count > lastCount) {
- lastCount = count;
- lastIndex = i;
- }
- }
- if (lastCount > 1)
- compress = lastIndex;
- /**
- * 4. Let ignore0 be false.
- * 5. For each pieceIndex in the range 0 to 7, inclusive:
- */
- let ignore0 = false;
- for (let pieceIndex = 0; pieceIndex < 8; pieceIndex++) {
- /**
- * 5.1. If ignore0 is true and address[pieceIndex] is 0, then continue.
- * 5.2. Otherwise, if ignore0 is true, set ignore0 to false.
- * 5.3. If compress is pieceIndex, then:
- */
- if (ignore0 && address[pieceIndex] === 0)
- continue;
- if (ignore0)
- ignore0 = false;
- if (compress === pieceIndex) {
- /**
- * 5.3.1. Let separator be "::" if pieceIndex is 0, and U+003A (:) otherwise.
- * 5.3.2. Append separator to output.
- * 5.3.3. Set ignore0 to true and continue.
- */
- output += (pieceIndex === 0 ? '::' : ':');
- ignore0 = true;
- continue;
- }
- /**
- * 5.4. Append address[pieceIndex], represented as the shortest possible
- * lowercase hexadecimal number, to output.
- * 5.5. If pieceIndex is not 7, then append U+003A (:) to output.
- */
- output += address[pieceIndex].toString(16);
- if (pieceIndex !== 7)
- output += ':';
- }
- /**
- * 6. Return output.
- */
- return output;
-}
-/**
- * Parses an URL string.
- *
- * @param input - input string
- * @param baseURL - base URL
- * @param encodingOverride - encoding override
- */
-function urlParser(input, baseURL, encodingOverride) {
- /**
- * 1. Let url be the result of running the basic URL parser on input with
- * base, and encoding override as provided.
- * 2. If url is failure, return failure.
- * 3. If url’s scheme is not "blob", return url.
- * 4. Set url’s blob URL entry to the result of resolving the blob URL url,
- * if that did not return failure, and null otherwise.
- * 5. Return url.
- */
- const url = basicURLParser(input, baseURL, encodingOverride);
- if (url === null)
- return null;
- if (url.scheme !== "blob")
- return url;
- const entry = resolveABlobURL(url);
- if (entry !== null) {
- url._blobURLEntry = entry;
- }
- else {
- url._blobURLEntry = null;
- }
- return url;
-}
-/**
- * Parses an URL string.
- *
- * @param input - input string
- * @param baseURL - base URL
- * @param encodingOverride - encoding override
- */
-function basicURLParser(input, baseURL, encodingOverride, url, stateOverride) {
- /**
- * 1. If url is not given:
- * 1.1. Set url to a new URL.
- * 1.2. If input contains any leading or trailing C0 control or space,
- * validation error.
- * 1.3. Remove any leading and trailing C0 control or space from input.
- */
- if (url === undefined) {
- url = newURL();
- // leading
- const leadingControlOrSpace = /^[\u0000-\u001F\u0020]+/;
- const trailingControlOrSpace = /[\u0000-\u001F\u0020]+$/;
- if (leadingControlOrSpace.test(input) || trailingControlOrSpace.test(input)) {
- validationError("Input string contains leading or trailing control characters or space.");
- }
- input = input.replace(leadingControlOrSpace, '');
- input = input.replace(trailingControlOrSpace, '');
- }
- /**
- * 2. If input contains any ASCII tab or newline, validation error.
- * 3. Remove all ASCII tab or newline from input.
- */
- const tabOrNewline = /[\u0009\u000A\u000D]/g;
- if (tabOrNewline.test(input)) {
- validationError("Input string contains tab or newline characters.");
- }
- input = input.replace(tabOrNewline, '');
- /**
- * 4. Let state be state override if given, or scheme start state otherwise.
- * 5. If base is not given, set it to null.
- * 6. Let encoding be UTF-8.
- * 7. If encoding override is given, set encoding to the result of getting
- * an output encoding from encoding override.
- */
- let state = (stateOverride === undefined ? interfaces_1.ParserState.SchemeStart : stateOverride);
- if (baseURL === undefined)
- baseURL = null;
- let encoding = (encodingOverride === undefined ||
- encodingOverride === "replacement" || encodingOverride === "UTF-16BE" ||
- encodingOverride === "UTF-16LE" ? "UTF-8" : encodingOverride);
- /**
- * 8. Let buffer be the empty string.
- * 9. Let the @ flag, [] flag, and passwordTokenSeenFlag be unset.
- * 10. Let pointer be a pointer to first code point in input.
- */
- let buffer = "";
- let atFlag = false;
- let arrayFlag = false;
- let passwordTokenSeenFlag = false;
- const EOF = "";
- const walker = new util_1.StringWalker(input);
- /**
- * 11. Keep running the following state machine by switching on state. If
- * after a run pointer points to the EOF code point, go to the next step.
- * Otherwise, increase pointer by one and continue with the state machine.
- */
- while (true) {
- switch (state) {
- case interfaces_1.ParserState.SchemeStart:
- /**
- * 1. If c is an ASCII alpha, append c, lowercased, to buffer, and set
- * state to scheme state.
- * 2. Otherwise, if state override is not given, set state to no scheme
- * state, and decrease pointer by one.
- * 3. Otherwise, validation error, return failure.
- */
- if (infra_1.codePoint.ASCIIAlpha.test(walker.c())) {
- buffer += walker.c().toLowerCase();
- state = interfaces_1.ParserState.Scheme;
- }
- else if (stateOverride === undefined) {
- state = interfaces_1.ParserState.NoScheme;
- walker.pointer--;
- }
- else {
- validationError("Invalid scheme start character.");
- return null;
- }
- break;
- case interfaces_1.ParserState.Scheme:
- /**
- * 1. If c is an ASCII alphanumeric, U+002B (+), U+002D (-), or U+002E
- * (.), append c, lowercased, to buffer.
- */
- if (infra_1.codePoint.ASCIIAlphanumeric.test(walker.c()) ||
- walker.c() === '+' || walker.c() === '-' || walker.c() === '.') {
- buffer += walker.c().toLowerCase();
- }
- else if (walker.c() === ':') {
- /**
- * 2. Otherwise, if c is U+003A (:), then:
- * 2.1. If state override is given, then:
- * 2.1.1. If url’s scheme is a special scheme and buffer is not a
- * special scheme, then return.
- * 2.1.2. If url’s scheme is not a special scheme and buffer is a
- * special scheme, then return.
- * 2.1.3. If url includes credentials or has a non-null port, and
- * buffer is "file", then return.
- * 2.1.4. If url’s scheme is "file" and its host is an empty host or
- * null, then return.
- */
- if (stateOverride !== undefined) {
- if (isSpecialScheme(url.scheme) && !isSpecialScheme(buffer))
- return url;
- if (!isSpecialScheme(url.scheme) && isSpecialScheme(buffer))
- return url;
- if ((includesCredentials(url) || url.port !== null) && buffer === "file")
- return url;
- if (url.scheme === "file" && (url.host === "" || url.host === null))
- return url;
- }
- /**
- * 2.2. Set url’s scheme to buffer.
- */
- url.scheme = buffer;
- /**
- * 2.3. If state override is given, then:
- * 2.3.1. If url’s port is url’s scheme’s default port, then set
- * url’s port to null.
- * 2.3.2. Return.
- */
- if (stateOverride !== undefined) {
- if (url.port === defaultPort(url.scheme)) {
- url.port = null;
- }
- return url;
- }
- /**
- * 2.4. Set buffer to the empty string.
- */
- buffer = "";
- if (url.scheme === "file") {
- /**
- * 2.5. If url’s scheme is "file", then:
- * 2.5.1. If remaining does not start with "//", validation error.
- * 2.5.2. Set state to file state.
- */
- if (!walker.remaining().startsWith("//")) {
- validationError("Invalid file URL scheme, '//' expected.");
- }
- state = interfaces_1.ParserState.File;
- }
- else if (isSpecial(url) && baseURL !== null && baseURL.scheme === url.scheme) {
- /**
- * 2.6. Otherwise, if url is special, base is non-null, and base’s
- * scheme is equal to url’s scheme, set state to special relative
- * or authority state.
- */
- state = interfaces_1.ParserState.SpecialRelativeOrAuthority;
- }
- else if (isSpecial(url)) {
- /**
- * 2.7. Otherwise, if url is special, set state to special
- * authority slashes state.
- */
- state = interfaces_1.ParserState.SpecialAuthoritySlashes;
- }
- else if (walker.remaining().startsWith("/")) {
- /**
- * 2.8. Otherwise, if remaining starts with an U+002F (/), set state
- * to path or authority state and increase pointer by one.
- */
- state = interfaces_1.ParserState.PathOrAuthority;
- walker.pointer++;
- }
- else {
- /**
- * 2.9. Otherwise, set url’s cannot-be-a-base-URL flag, append an
- * empty string to url’s path, and set state to
- * cannot-be-a-base-URL path state.
- */
- url._cannotBeABaseURLFlag = true;
- url.path.push("");
- state = interfaces_1.ParserState.CannotBeABaseURLPath;
- }
- }
- else if (stateOverride === undefined) {
- /**
- * 3. Otherwise, if state override is not given, set buffer to the
- * empty string, state to no scheme state, and start over (from the
- * first code point in input).
- */
- buffer = "";
- state = interfaces_1.ParserState.NoScheme;
- walker.pointer = 0;
- continue;
- }
- else {
- /**
- * 4. Otherwise, validation error, return failure.
- */
- validationError("Invalid input string.");
- return null;
- }
- break;
- case interfaces_1.ParserState.NoScheme:
- /**
- * 1. If base is null, or base’s cannot-be-a-base-URL flag is set
- * and c is not U+0023 (#), validation error, return failure.
- * 2. Otherwise, if base’s cannot-be-a-base-URL flag is set and
- * c is U+0023 (#), set url’s scheme to base’s scheme, url’s path to
- * a copy of base’s path, url’s query to base’s query, url’s
- * fragment to the empty string, set url’s cannot-be-a-base-URL
- * flag, and set state to fragment state.
- * 3. Otherwise, if base’s scheme is not "file", set state to
- * relative state and decrease pointer by one.
- * 4. Otherwise, set state to file state and decrease pointer by one.
- */
- if (baseURL === null || (baseURL._cannotBeABaseURLFlag && walker.c() !== '#')) {
- validationError("Invalid input string.");
- return null;
- }
- else if (baseURL._cannotBeABaseURLFlag && walker.c() === '#') {
- url.scheme = baseURL.scheme;
- url.path = infra_1.list.clone(baseURL.path);
- url.query = baseURL.query;
- url.fragment = "";
- url._cannotBeABaseURLFlag = true;
- state = interfaces_1.ParserState.Fragment;
- }
- else if (baseURL.scheme !== "file") {
- state = interfaces_1.ParserState.Relative;
- walker.pointer--;
- }
- else {
- state = interfaces_1.ParserState.File;
- walker.pointer--;
- }
- break;
- case interfaces_1.ParserState.SpecialRelativeOrAuthority:
- /**
- * If c is U+002F (/) and remaining starts with U+002F (/), then set
- * state to special authority ignore slashes state and increase
- * pointer by one.
- * Otherwise, validation error, set state to relative state and
- * decrease pointer by one.
- */
- if (walker.c() === '/' && walker.remaining().startsWith('/')) {
- state = interfaces_1.ParserState.SpecialAuthorityIgnoreSlashes;
- walker.pointer++;
- }
- else {
- validationError("Invalid input string.");
- state = interfaces_1.ParserState.Relative;
- walker.pointer--;
- }
- break;
- case interfaces_1.ParserState.PathOrAuthority:
- /**
- * If c is U+002F (/), then set state to authority state.
- * Otherwise, set state to path state, and decrease pointer by one.
- */
- if (walker.c() === '/') {
- state = interfaces_1.ParserState.Authority;
- }
- else {
- state = interfaces_1.ParserState.Path;
- walker.pointer--;
- }
- break;
- case interfaces_1.ParserState.Relative:
- /**
- * Set url’s scheme to base’s scheme, and then, switching on c:
- */
- if (baseURL === null) {
- throw new Error("Invalid parser state. Base URL is null.");
- }
- url.scheme = baseURL.scheme;
- switch (walker.c()) {
- case EOF: // EOF
- /**
- * Set url’s username to base’s username, url’s password to base’s
- * password, url’s host to base’s host, url’s port to base’s port,
- * url’s path to a copy of base’s path, and url’s query to base’s
- * query.
- */
- url.username = baseURL.username;
- url.password = baseURL.password;
- url.host = baseURL.host;
- url.port = baseURL.port;
- url.path = infra_1.list.clone(baseURL.path);
- url.query = baseURL.query;
- break;
- case '/':
- /**
- * Set state to relative slash state.
- */
- state = interfaces_1.ParserState.RelativeSlash;
- break;
- case '?':
- /**
- * Set url’s username to base’s username, url’s password to base’s
- * password, url’s host to base’s host, url’s port to base’s port,
- * url’s path to a copy of base’s path, url’s query to the empty
- * string, and state to query state.
- */
- url.username = baseURL.username;
- url.password = baseURL.password;
- url.host = baseURL.host;
- url.port = baseURL.port;
- url.path = infra_1.list.clone(baseURL.path);
- url.query = "";
- state = interfaces_1.ParserState.Query;
- break;
- case '#':
- /**
- * Set url’s username to base’s username, url’s password to base’s
- * password, url’s host to base’s host, url’s port to base’s port,
- * url’s path to a copy of base’s path, url’s query to base’s
- * query, url’s fragment to the empty string, and state to
- * fragment state.
- */
- url.username = baseURL.username;
- url.password = baseURL.password;
- url.host = baseURL.host;
- url.port = baseURL.port;
- url.path = infra_1.list.clone(baseURL.path);
- url.query = baseURL.query;
- url.fragment = "";
- state = interfaces_1.ParserState.Fragment;
- break;
- default:
- /**
- * If url is special and c is U+005C (\), validation error,
- * set state to relative slash state.
- * Otherwise, run these steps:
- * 1. Set url’s username to base’s username, url’s password to
- * base’s password, url’s host to base’s host, url’s port to
- * base’s port, url’s path to a copy of base’s path, and then
- * remove url’s path’s last item, if any.
- * 2. Set state to path state, and decrease pointer by one.
- */
- if (isSpecial(url) && walker.c() === '\\') {
- validationError("Invalid input string.");
- state = interfaces_1.ParserState.RelativeSlash;
- }
- else {
- url.username = baseURL.username;
- url.password = baseURL.password;
- url.host = baseURL.host;
- url.port = baseURL.port;
- url.path = infra_1.list.clone(baseURL.path);
- if (url.path.length !== 0)
- url.path.splice(url.path.length - 1, 1);
- state = interfaces_1.ParserState.Path;
- walker.pointer--;
- }
- break;
- }
- break;
- case interfaces_1.ParserState.RelativeSlash:
- /**
- * 1. If url is special and c is U+002F (/) or U+005C (\), then:
- * 1.1. If c is U+005C (\), validation error.
- * 1.2. Set state to special authority ignore slashes state.
- * 2. Otherwise, if c is U+002F (/), then set state to authority state.
- * 3. Otherwise, set url’s username to base’s username, url’s password
- * to base’s password, url’s host to base’s host, url’s port to base’s
- * port, state to path state, and then, decrease pointer by one.
- */
- if (isSpecial(url) && (walker.c() === '/' || walker.c() === '\\')) {
- if (walker.c() === '\\') {
- validationError("Invalid input string.");
- }
- state = interfaces_1.ParserState.SpecialAuthorityIgnoreSlashes;
- }
- else if (walker.c() === '/') {
- state = interfaces_1.ParserState.Authority;
- }
- else {
- if (baseURL === null) {
- throw new Error("Invalid parser state. Base URL is null.");
- }
- url.username = baseURL.username;
- url.password = baseURL.password;
- url.host = baseURL.host;
- url.port = baseURL.port;
- state = interfaces_1.ParserState.Path;
- walker.pointer--;
- }
- break;
- case interfaces_1.ParserState.SpecialAuthoritySlashes:
- /**
- * If c is U+002F (/) and remaining starts with U+002F (/), then set
- * state to special authority ignore slashes state and increase
- * pointer by one.
- * Otherwise, validation error, set state to special authority ignore
- * slashes state, and decrease pointer by one.
- */
- if (walker.c() === '/' && walker.remaining().startsWith('/')) {
- state = interfaces_1.ParserState.SpecialAuthorityIgnoreSlashes;
- walker.pointer++;
- }
- else {
- validationError("Expected '//'.");
- state = interfaces_1.ParserState.SpecialAuthorityIgnoreSlashes;
- walker.pointer--;
- }
- break;
- case interfaces_1.ParserState.SpecialAuthorityIgnoreSlashes:
- /**
- * If c is neither U+002F (/) nor U+005C (\), then set state to
- * authority state and decrease pointer by one.
- * Otherwise, validation error.
- */
- if (walker.c() !== '/' && walker.c() !== '\\') {
- state = interfaces_1.ParserState.Authority;
- walker.pointer--;
- }
- else {
- validationError("Unexpected '/' or '\\'.");
- }
- break;
- case interfaces_1.ParserState.Authority:
- /**
- * 1. If c is U+0040 (@), then:
- */
- if (walker.c() === '@') {
- /**
- * 1.1. Validation error.
- * 1.2. If the @ flag is set, prepend "%40" to buffer.
- * 1.3. Set the @ flag.
- * 1.4. For each codePoint in buffer:
- */
- validationError("Unexpected '@'.");
- if (atFlag)
- buffer = '%40' + buffer;
- atFlag = true;
- for (const codePoint of buffer) {
- /**
- * 1.4.1. If codePoint is U+003A (:) and passwordTokenSeenFlag is
- * unset, then set passwordTokenSeenFlag and continue.
- * 1.4.2. Let encodedCodePoints be the result of running UTF-8
- * percent encode codePoint using the userinfo percent-encode set.
- * 1.4.3. If passwordTokenSeenFlag is set, then append
- * encodedCodePoints to url’s password.
- * 1.4.4. Otherwise, append encodedCodePoints to url’s username.
- */
- if (codePoint === ':' && !passwordTokenSeenFlag) {
- passwordTokenSeenFlag = true;
- continue;
- }
- const encodedCodePoints = utf8PercentEncode(codePoint, _userInfoPercentEncodeSet);
- if (passwordTokenSeenFlag) {
- url.password += encodedCodePoints;
- }
- else {
- url.username += encodedCodePoints;
- }
- }
- /**
- * 1.5. Set buffer to the empty string.
- */
- buffer = "";
- }
- else if (walker.c() === EOF || walker.c() === '/' || walker.c() === '?' || walker.c() === '#' ||
- (isSpecial(url) && walker.c() === '\\')) {
- /**
- * 2. Otherwise, if one of the following is true
- * - c is the EOF code point, U+002F (/), U+003F (?), or U+0023 (#)
- * - url is special and c is U+005C (\)
- * then:
- * 2.1. If @ flag is set and buffer is the empty string, validation
- * error, return failure.
- * 2.2. Decrease pointer by the number of code points in buffer plus
- * one, set buffer to the empty string, and set state to host state.
- */
- if (atFlag && buffer === "") {
- validationError("Invalid input string.");
- return null;
- }
- walker.pointer -= (buffer.length + 1);
- buffer = "";
- state = interfaces_1.ParserState.Host;
- }
- else {
- /**
- * 3. Otherwise, append c to buffer.
- */
- buffer += walker.c();
- }
- break;
- case interfaces_1.ParserState.Host:
- case interfaces_1.ParserState.Hostname:
- if (stateOverride !== undefined && url.scheme === "file") {
- /**
- * 1. If state override is given and url’s scheme is "file", then
- * decrease pointer by one and set state to file host state.
- */
- walker.pointer--;
- state = interfaces_1.ParserState.FileHost;
- }
- else if (walker.c() === ':' && !arrayFlag) {
- /**
- * 2. Otherwise, if c is U+003A (:) and the [] flag is unset, then:
- * 2.1. If buffer is the empty string, validation error, return
- * failure.
- * 2.2. Let host be the result of host parsing buffer with url is
- * not special.
- * 2.3. If host is failure, then return failure.
- * 2.4. Set url’s host to host, buffer to the empty string, and
- * state to port state.
- * 2.5. If state override is given and state override is hostname
- * state, then return.
- */
- if (buffer === "") {
- validationError("Invalid input string.");
- return null;
- }
- const host = hostParser(buffer, !isSpecial(url));
- if (host === null)
- return null;
- url.host = host;
- buffer = "";
- state = interfaces_1.ParserState.Port;
- if (stateOverride === interfaces_1.ParserState.Hostname)
- return url;
- }
- else if (walker.c() === EOF || walker.c() === '/' || walker.c() === '?' || walker.c() === '#' ||
- (isSpecial(url) && walker.c() === '\\')) {
- /**
- * 3. Otherwise, if one of the following is true
- * - c is the EOF code point, U+002F (/), U+003F (?), or U+0023 (#)
- * - url is special and c is U+005C (\)
- * then decrease pointer by one, and then:
- * 3.1. If url is special and buffer is the empty string, validation
- * error, return failure.
- * 3.2. Otherwise, if state override is given, buffer is the empty
- * string, and either url includes credentials or url’s port is
- * non-null, validation error, return.
- * 3.3. Let host be the result of host parsing buffer with url is
- * not special.
- * 3.4. If host is failure, then return failure.
- * 3.5. Set url’s host to host, buffer to the empty string, and
- * state to path start state.
- * 3.6. If state override is given, then return.
- */
- walker.pointer--;
- if (isSpecial(url) && buffer === "") {
- validationError("Invalid input string.");
- return null;
- }
- else if (stateOverride !== undefined && buffer === "" &&
- (includesCredentials(url) || url.port !== null)) {
- validationError("Invalid input string.");
- return url;
- }
- const host = hostParser(buffer, !isSpecial(url));
- if (host === null)
- return null;
- url.host = host;
- buffer = "";
- state = interfaces_1.ParserState.PathStart;
- if (stateOverride !== undefined)
- return url;
- }
- else {
- /**
- * 4. Otherwise:
- * 4.1. If c is U+005B ([), then set the [] flag.
- * 4.2. If c is U+005D (]), then unset the [] flag.
- * 4.3. Append c to buffer.
- */
- if (walker.c() === '[')
- arrayFlag = true;
- if (walker.c() === ']')
- arrayFlag = false;
- buffer += walker.c();
- }
- break;
- case interfaces_1.ParserState.Port:
- if (infra_1.codePoint.ASCIIDigit.test(walker.c())) {
- /**
- * 1. If c is an ASCII digit, append c to buffer.
- */
- buffer += walker.c();
- }
- else if (walker.c() === EOF || walker.c() === '/' || walker.c() === '?' || walker.c() === '#' ||
- (isSpecial(url) && walker.c() === '\\') || stateOverride) {
- /**
- * 2. Otherwise, if one of the following is true
- * - c is the EOF code point, U+002F (/), U+003F (?), or U+0023 (#)
- * - url is special and c is U+005C (\)
- * - state override is given
- * then:
- */
- if (buffer !== "") {
- /**
- * 2.1. If buffer is not the empty string, then:
- * 2.1.1. Let port be the mathematical integer value that is
- * represented by buffer in radix-10 using ASCII digits for digits
- * with values 0 through 9.
- * 2.1.2. If port is greater than 2**16 − 1, validation error,
- * return failure.
- * 2.1.3. Set url’s port to null, if port is url’s scheme’s default
- * port, and to port otherwise.
- * 2.1.4. Set buffer to the empty string.
- */
- if (buffer !== "") {
- const port = parseInt(buffer, 10);
- if (port > Math.pow(2, 16) - 1) {
- validationError("Invalid port number.");
- return null;
- }
- url.port = (port === defaultPort(url.scheme) ? null : port);
- buffer = "";
- }
- }
- /**
- * 2.2. If state override is given, then return.
- * 2.3. Set state to path start state, and decrease pointer by one.
- */
- if (stateOverride !== undefined) {
- return url;
- }
- state = interfaces_1.ParserState.PathStart;
- walker.pointer--;
- }
- else {
- /**
- * 3. Otherwise, validation error, return failure.
- */
- validationError("Invalid input string.");
- return null;
- }
- break;
- case interfaces_1.ParserState.File:
- /**
- * 1. Set url’s scheme to "file".
- */
- url.scheme = "file";
- if (walker.c() === '/' || walker.c() === '\\') {
- /**
- * 2. If c is U+002F (/) or U+005C (\), then:
- * 2.1. If c is U+005C (\), validation error.
- * 2.2. Set state to file slash state.
- */
- if (walker.c() === '\\') {
- validationError("Invalid input string.");
- }
- state = interfaces_1.ParserState.FileSlash;
- }
- else if (baseURL !== null && baseURL.scheme === "file") {
- /**
- * 3. Otherwise, if base is non-null and base’s scheme is "file",
- * switch on c:
- */
- switch (walker.c()) {
- case EOF:
- /**
- * Set url’s host to base’s host, url’s path to a copy of base’s
- * path, and url’s query to base’s query.
- */
- url.host = baseURL.host;
- url.path = infra_1.list.clone(baseURL.path);
- url.query = baseURL.query;
- break;
- case '?':
- /**
- * Set url’s host to base’s host, url’s path to a copy of base’s
- * path, url’s query to the empty string, and state to query
- * state.
- */
- url.host = baseURL.host;
- url.path = infra_1.list.clone(baseURL.path);
- url.query = "";
- state = interfaces_1.ParserState.Query;
- break;
- case '#':
- /**
- * Set url’s host to base’s host, url’s path to a copy of base’s
- * path, url’s query to base’s query, url’s fragment to the
- * empty string, and state to fragment state.
- */
- url.host = baseURL.host;
- url.path = infra_1.list.clone(baseURL.path);
- url.query = baseURL.query;
- url.fragment = "";
- state = interfaces_1.ParserState.Fragment;
- break;
- default:
- /**
- * 1. If the substring from pointer in input does not start
- * with a Windows drive letter, then set url’s host to base’s
- * host, url’s path to a copy of base’s path, and then shorten
- * url’s path.
- * _Note:_ is a (platform-independent) Windows drive letter
- * quirk.
- * 2. Otherwise, validation error.
- * 3. Set state to path state, and decrease pointer by one.
- */
- if (!startsWithAWindowsDriveLetter(walker.substring())) {
- url.host = baseURL.host;
- url.path = infra_1.list.clone(baseURL.path);
- shorten(url);
- }
- else {
- validationError("Unexpected windows drive letter in input string.");
- }
- state = interfaces_1.ParserState.Path;
- walker.pointer--;
- break;
- }
- }
- else {
- /**
- * 4. Otherwise, set state to path state, and decrease pointer by
- * one.
- */
- state = interfaces_1.ParserState.Path;
- walker.pointer--;
- }
- break;
- case interfaces_1.ParserState.FileSlash:
- if (walker.c() === '/' || walker.c() === '\\') {
- /**
- * 1. If c is U+002F (/) or U+005C (\), then:
- * 1.1. If c is U+005C (\), validation error.
- * 1.2. Set state to file host state.
- */
- if (walker.c() === '\\') {
- validationError("Invalid input string.");
- }
- state = interfaces_1.ParserState.FileHost;
- }
- else {
- /**
- * 2. Otherwise:
- * 2.1. If base is non-null, base’s scheme is "file", and the
- * substring from pointer in input does not start with a Windows
- * drive letter, then:
- * 2.1.1. If base’s path[0] is a normalized Windows drive letter,
- * then append base’s path[0] to url’s path.
- * _Note:_ is a (platform-independent) Windows drive letter
- * quirk. Both url’s and base’s host are null under these conditions
- * and therefore not copied.
- * 2.1.2. Otherwise, set url’s host to base’s host.
- * 2.2. Set state to path state, and decrease pointer by one.
- */
- if (baseURL !== null && baseURL.scheme === "file" &&
- !startsWithAWindowsDriveLetter(walker.substring())) {
- if (isNormalizedWindowsDriveLetter(baseURL.path[0])) {
- url.path.push(baseURL.path[0]);
- }
- else {
- url.host = baseURL.host;
- }
- }
- state = interfaces_1.ParserState.Path;
- walker.pointer--;
- }
- break;
- case interfaces_1.ParserState.FileHost:
- if (walker.c() === EOF || walker.c() === '/' || walker.c() === '\\' ||
- walker.c() === '?' || walker.c() === '#') {
- /**
- * 1. If c is the EOF code point, U+002F (/), U+005C (\), U+003F (?),
- * or U+0023 (#), then decrease pointer by one and then:
- */
- walker.pointer--;
- if (stateOverride === undefined && isWindowsDriveLetter(buffer)) {
- /**
- * 1.1. If state override is not given and buffer is a Windows drive
- * letter, validation error, set state to path state.
- * _Note:_ is a (platform-independent) Windows drive letter
- * quirk. buffer is not reset here and instead used in the path state.
- */
- validationError("Unexpected windows drive letter in input string.");
- state = interfaces_1.ParserState.Path;
- }
- else if (buffer === "") {
- /**
- * 1.2. Otherwise, if buffer is the empty string, then:
- * 1.2.1. Set url’s host to the empty string.
- * 1.2.2. If state override is given, then return.
- * 1.2.3. Set state to path start state.
- */
- url.host = "";
- if (stateOverride !== undefined)
- return url;
- state = interfaces_1.ParserState.PathStart;
- }
- else {
- /**
- * 1.3. Otherwise, run these steps:
- * 1.3.1. Let host be the result of host parsing buffer with url
- * is not special.
- * 1.3.2. If host is failure, then return failure.
- * 1.3.3. If host is "localhost", then set host to the empty
- * string.
- * 1.3.4. Set url’s host to host.
- * 1.3.5. If state override is given, then return.
- * 1.3.6. Set buffer to the empty string and state to path start
- * state.
- */
- let host = hostParser(buffer, !isSpecial(url));
- if (host === null)
- return null;
- if (host === "localhost")
- host = "";
- url.host = host;
- if (stateOverride !== undefined)
- return url;
- buffer = "";
- state = interfaces_1.ParserState.PathStart;
- }
- }
- else {
- /**
- * 2. Otherwise, append c to buffer.
- */
- buffer += walker.c();
- }
- break;
- case interfaces_1.ParserState.PathStart:
- if (isSpecial(url)) {
- /**
- * 1. If url is special, then:
- * 1.1. If c is U+005C (\), validation error.
- * 1.2. Set state to path state.
- * 1.3. If c is neither U+002F (/) nor U+005C (\), then decrease
- * pointer by one.
- */
- if (walker.c() === '\\') {
- validationError("Invalid input string.");
- }
- state = interfaces_1.ParserState.Path;
- if (walker.c() !== '/' && walker.c() !== '\\')
- walker.pointer--;
- }
- else if (stateOverride === undefined && walker.c() === '?') {
- /**
- * 2. Otherwise, if state override is not given and c is U+003F (?),
- * set url’s query to the empty string and state to query state.
- */
- url.query = "";
- state = interfaces_1.ParserState.Query;
- }
- else if (stateOverride === undefined && walker.c() === '#') {
- /**
- * 3. Otherwise, if state override is not given and c is U+0023 (#),
- * set url’s fragment to the empty string and state to fragment
- * state.
- */
- url.fragment = "";
- state = interfaces_1.ParserState.Fragment;
- }
- else if (walker.c() !== EOF) {
- /**
- * 4. Otherwise, if c is not the EOF code point:
- * 4.1. Set state to path state.
- * 4.2. If c is not U+002F (/), then decrease pointer by one.
- */
- state = interfaces_1.ParserState.Path;
- if (walker.c() !== '/')
- walker.pointer--;
- }
- break;
- case interfaces_1.ParserState.Path:
- if ((walker.c() === EOF || walker.c() === '/') ||
- (isSpecial(url) && walker.c() === '\\') ||
- (stateOverride === undefined && (walker.c() === '?' || walker.c() === '#'))) {
- /**
- * 1. If one of the following is true
- * - c is the EOF code point or U+002F (/)
- * - url is special and c is U+005C (\)
- * - state override is not given and c is U+003F (?) or U+0023 (#)
- * then:
- */
- if (isSpecial(url) && walker.c() === '\\') {
- /**
- * 1.1 If url is special and c is U+005C (\), validation error.
- */
- validationError("Invalid input string.");
- }
- if (isDoubleDotPathSegment(buffer)) {
- /**
- * 1.2. If buffer is a double-dot path segment, shorten url’s path,
- * and then if neither c is U+002F (/), nor url is special and c is
- * U+005C (\), append the empty string to url’s path.
- */
- shorten(url);
- if (walker.c() !== '/' && !(isSpecial(url) && walker.c() === '\\')) {
- url.path.push("");
- }
- }
- else if (isSingleDotPathSegment(buffer) && walker.c() !== '/' &&
- !(isSpecial(url) && walker.c() === '\\')) {
- /**
- * 1.3. Otherwise, if buffer is a single-dot path segment and if
- * neither c is U+002F (/), nor url is special and c is U+005C (\),
- * append the empty string to url’s path.
- */
- url.path.push("");
- }
- else if (!isSingleDotPathSegment(buffer)) {
- /**
- * 1.4. Otherwise, if buffer is not a single-dot path segment, then:
- */
- if (url.scheme === "file" && url.path.length === 0 &&
- isWindowsDriveLetter(buffer)) {
- /**
- * 1.4.1. If url’s scheme is "file", url’s path is empty, and
- * buffer is a Windows drive letter, then:
- * 1.4.1.1. If url’s host is neither the empty string nor null,
- * validation error, set url’s host to the empty string.
- * 1.4.1.2. Replace the second code point in buffer with U+003A (:).
- * _Note:_ is a (platform-independent) Windows drive letter quirk.
- */
- if (url.host !== null && url.host !== "") {
- validationError("Invalid input string.");
- url.host = "";
- }
- const bufferCodePoints = Array.from(buffer);
- buffer = bufferCodePoints.slice(0, 1) + ':' + bufferCodePoints.slice(2);
- }
- /**
- * 1.4.2. Append buffer to url’s path.
- */
- url.path.push(buffer);
- }
- /**
- * 1.5. Set buffer to the empty string.
- */
- buffer = "";
- /**
- * 1.6. If url’s scheme is "file" and c is the EOF code point,
- * U+003F (?), or U+0023 (#), then while url’s path’s size is
- * greater than 1 and url’s path[0] is the empty string, validation
- * error, remove the first item from url’s path.
- */
- if (url.scheme === "file" && (walker.c() === EOF || walker.c() === '?' || walker.c() === '#')) {
- while (url.path.length > 1 && url.path[0] === "") {
- validationError("Invalid input string.");
- url.path.splice(0, 1);
- }
- }
- /**
- * 1.7. If c is U+003F (?), then set url’s query to the empty string
- * and state to query state.
- * 1.8. If c is U+0023 (#), then set url’s fragment to the empty
- * string and state to fragment state.
- */
- if (walker.c() === '?') {
- url.query = "";
- state = interfaces_1.ParserState.Query;
- }
- if (walker.c() === '#') {
- url.fragment = "";
- state = interfaces_1.ParserState.Fragment;
- }
- }
- else {
- /**
- * 2. Otherwise, run these steps:
- * 2.1. If c is not a URL code point and not U+0025 (%), validation
- * error.
- * 2.2. If c is U+0025 (%) and remaining does not start with two
- * ASCII hex digits, validation error.
- * 2.3. UTF-8 percent encode c using the path percent-encode set,
- * and append the result to buffer.
- */
- if (!_urlCodePoints.test(walker.c()) && walker.c() !== '%') {
- validationError("Character is not a URL code point or a percent encoded character.");
- }
- if (walker.c() === '%' && !/^[0-9a-fA-F][0-9a-fA-F]/.test(walker.remaining())) {
- validationError("Percent encoded character must be followed by two hex digits.");
- }
- buffer += utf8PercentEncode(walker.c(), _pathPercentEncodeSet);
- }
- break;
- case interfaces_1.ParserState.CannotBeABaseURLPath:
- /**
- * 1. If c is U+003F (?), then set url’s query to the empty string and
- * state to query state.
- * 2. Otherwise, if c is U+0023 (#), then set url’s fragment to the
- * empty string and state to fragment state.
- * 3. Otherwise:
- * 3.1. If c is not the EOF code point, not a URL code point, and not
- * U+0025 (%), validation error.
- * 3.2. If c is U+0025 (%) and remaining does not start with two ASCII
- * hex digits, validation error.
- * 3.3. If c is not the EOF code point, UTF-8 percent encode c using
- * the C0 control percent-encode set, and append the result to url’s
- * path[0].
- */
- if (walker.c() === '?') {
- url.query = "";
- state = interfaces_1.ParserState.Query;
- }
- else if (walker.c() === '#') {
- url.fragment = "";
- state = interfaces_1.ParserState.Fragment;
- }
- else {
- if (walker.c() !== EOF && !_urlCodePoints.test(walker.c()) && walker.c() !== '%') {
- validationError("Character is not a URL code point or a percent encoded character.");
- }
- if (walker.c() === '%' && !/^[0-9a-fA-F][0-9a-fA-F]/.test(walker.remaining())) {
- validationError("Percent encoded character must be followed by two hex digits.");
- }
- if (walker.c() !== EOF) {
- url.path[0] += utf8PercentEncode(walker.c(), _c0ControlPercentEncodeSet);
- }
- }
- break;
- case interfaces_1.ParserState.Query:
- /**
- * 1. If encoding is not UTF-8 and one of the following is true
- * - url is not special
- * - url’s scheme is "ws" or "wss"
- * then set encoding to UTF-8.
- */
- if (encoding !== "UTF-8" && (!isSpecial(url) ||
- url.scheme === "ws" || url.scheme === "wss")) {
- encoding = "UTF-8";
- }
- if (stateOverride === undefined && walker.c() === '#') {
- /**
- * 2. If state override is not given and c is U+0023 (#), then set
- * url’s fragment to the empty string and state to fragment state.
- */
- url.fragment = "";
- state = interfaces_1.ParserState.Fragment;
- }
- else if (walker.c() !== EOF) {
- /**
- * 3. Otherwise, if c is not the EOF code point:
- * 3.1. If c is not a URL code point and not U+0025 (%), validation
- * error.
- */
- if (!_urlCodePoints.test(walker.c()) && walker.c() !== '%') {
- validationError("Character is not a URL code point or a percent encoded character.");
- }
- /**
- * 3.2. If c is U+0025 (%) and remaining does not start with two
- * ASCII hex digits, validation error.
- */
- if (walker.c() === '%' && !/^[0-9a-fA-F][0-9a-fA-F]/.test(walker.remaining())) {
- validationError("Percent encoded character must be followed by two hex digits.");
- }
- /**
- * 3.3. Let bytes be the result of encoding c using encoding.
- */
- if (encoding.toUpperCase() !== "UTF-8") {
- throw new Error("Only UTF-8 encoding is supported.");
- }
- let bytes = (0, util_1.utf8Encode)(walker.c());
- /**
- * 3.4. If bytes starts with `&#` and ends with 0x3B (;), then:
- */
- if (bytes.length >= 3 && bytes[0] === 38 && bytes[1] === 35 &&
- bytes[bytes.length - 1] === 59) {
- /**
- * 3.4.1. Replace `&#` at the start of bytes with `%26%23`.
- * 3.4.2. Replace 0x3B (;) at the end of bytes with `%3B`.
- * 3.4.4. Append bytes, isomorphic decoded, to url’s query.
- * _Note:_ can happen when encoding code points using a
- * non-UTF-8 encoding.
- */
- bytes = bytes.subarray(2, bytes.length - 1);
- url.query += "%26%23" + infra_1.byteSequence.isomorphicDecode(bytes) + "%3B";
- }
- else {
- /**
- * 3.5. Otherwise, for each byte in bytes:
- * 3.5.1. If one of the following is true
- * - byte is less than 0x21 (!)
- * - byte is greater than 0x7E (~)
- * - byte is 0x22 ("), 0x23 (#), 0x3C (<), or 0x3E (>)
- * - byte is 0x27 (') and url is special
- * then append byte, percent encoded, to url’s query.
- * 3.5.2. Otherwise, append a code point whose value is byte to
- * url’s query.
- */
- for (const byte of bytes) {
- if (byte < 0x21 || byte > 0x7E || byte === 0x22 ||
- byte === 0x23 || byte === 0x3C || byte === 0x3E ||
- (byte === 0x27 && isSpecial(url))) {
- url.query += percentEncode(byte);
- }
- else {
- url.query += String.fromCharCode(byte);
- }
- }
- }
- }
- break;
- case interfaces_1.ParserState.Fragment:
- /**
- * Switching on c:
- * - The EOF code point
- * Do nothing.
- * - U+0000 NULL
- * Validation error.
- * - Otherwise
- * 1. If c is not a URL code point and not U+0025 (%), validation
- * error.
- * 2. If c is U+0025 (%) and remaining does not start with two ASCII
- * hex digits, validation error.
- * 3. UTF-8 percent encode c using the fragment percent-encode set and
- * append the result to url’s fragment.
- */
- if (walker.c() === EOF) {
- //
- }
- else if (walker.c() === "\u0000") {
- validationError("NULL character in input string.");
- }
- else {
- if (!_urlCodePoints.test(walker.c()) && walker.c() !== '%') {
- validationError("Unexpected character in fragment string.");
- }
- if (walker.c() === '%' && !/^[A-Za-z0-9][A-Za-z0-9]/.test(walker.remaining())) {
- validationError("Unexpected character in fragment string.");
- }
- url.fragment += utf8PercentEncode(walker.c(), _fragmentPercentEncodeSet);
- }
- break;
- }
- if (walker.eof)
- break;
- else
- walker.pointer++;
- }
- /**
- * 12. Return url.
- */
- return url;
-}
-/**
- * Sets a URL's username.
- *
- * @param url - a URL
- * @param username - username string
- */
-function setTheUsername(url, username) {
- /**
- * 1. Set url’s username to the empty string.
- * 2. For each code point in username, UTF-8 percent encode it using the
- * userinfo percent-encode set, and append the result to url’s username.
- */
- let result = "";
- for (const codePoint of username) {
- result += utf8PercentEncode(codePoint, _userInfoPercentEncodeSet);
- }
- url.username = result;
-}
-/**
- * Sets a URL's password.
- *
- * @param url - a URL
- * @param username - password string
- */
-function setThePassword(url, password) {
- /**
- * 1. Set url’s password to the empty string.
- * 2. For each code point in password, UTF-8 percent encode it using the
- * userinfo percent-encode set, and append the result to url’s password.
- */
- let result = "";
- for (const codePoint of password) {
- result += utf8PercentEncode(codePoint, _userInfoPercentEncodeSet);
- }
- url.password = result;
-}
-/**
- * Determines if the string represents a single dot path.
- *
- * @param str - a string
- */
-function isSingleDotPathSegment(str) {
- return str === '.' || str.toLowerCase() === "%2e";
-}
-/**
- * Determines if the string represents a double dot path.
- *
- * @param str - a string
- */
-function isDoubleDotPathSegment(str) {
- const lowerStr = str.toLowerCase();
- return lowerStr === ".." || lowerStr === ".%2e" ||
- lowerStr === "%2e." || lowerStr === "%2e%2e";
-}
-/**
- * Shorten's URL's path.
- *
- * @param url - an URL
- */
-function shorten(url) {
- /**
- * 1. Let path be url’s path.
- * 2. If path is empty, then return.
- * 3. If url’s scheme is "file", path’s size is 1, and path[0] is a
- * normalized Windows drive letter, then return.
- * 4. Remove path’s last item.
- */
- const path = url.path;
- if (path.length === 0)
- return;
- if (url.scheme === "file" && path.length === 1 &&
- isNormalizedWindowsDriveLetter(path[0]))
- return;
- url.path.splice(url.path.length - 1, 1);
-}
-/**
- * Determines if a string is a normalized Windows drive letter.
- *
- * @param str - a string
- */
-function isNormalizedWindowsDriveLetter(str) {
- /**
- * A normalized Windows drive letter is a Windows drive letter of which the
- * second code point is U+003A (:).
- */
- return str.length >= 2 && infra_1.codePoint.ASCIIAlpha.test(str[0]) &&
- str[1] === ':';
-}
-/**
- * Determines if a string is a Windows drive letter.
- *
- * @param str - a string
- */
-function isWindowsDriveLetter(str) {
- /**
- * A Windows drive letter is two code points, of which the first is an ASCII
- * alpha and the second is either U+003A (:) or U+007C (|).
- */
- return str.length >= 2 && infra_1.codePoint.ASCIIAlpha.test(str[0]) &&
- (str[1] === ':' || str[1] === '|');
-}
-/**
- * Determines if a string starts with a Windows drive letter.
- *
- * @param str - a string
- */
-function startsWithAWindowsDriveLetter(str) {
- /**
- * A string starts with a Windows drive letter if all of the following are
- * true:
- * - its length is greater than or equal to 2
- * - its first two code points are a Windows drive letter
- * - its length is 2 or its third code point is U+002F (/), U+005C (\),
- * U+003F (?), or U+0023 (#).
- */
- return str.length >= 2 && isWindowsDriveLetter(str) &&
- (str.length === 2 || (str[2] === '/' || str[2] === '\\' ||
- str[2] === '?' || str[2] === '#'));
-}
-/**
- * Parses a host string.
- *
- * @param input - input string
- * @param isNotSpecial - `true` if the source URL is not special; otherwise
- * `false`.
- */
-function hostParser(input, isNotSpecial = false) {
- /**
- * 1. If isNotSpecial is not given, then set isNotSpecial to false.
- * 2. If input starts with U+005B ([), then:
- * 2.1. If input does not end with U+005D (]), validation error, return
- * failure.
- * 2.2. Return the result of IPv6 parsing input with its leading U+005B ([)
- * and trailing U+005D (]) removed.
- */
- if (input.startsWith('[')) {
- if (!input.endsWith(']')) {
- validationError("Expected ']' after '['.");
- return null;
- }
- return iPv6Parser(input.substring(1, input.length - 1));
- }
- /**
- * 3. If isNotSpecial is true, then return the result of opaque-host parsing
- * input.
- */
- if (isNotSpecial) {
- return opaqueHostParser(input);
- }
- /**
- * 4. Let domain be the result of running UTF-8 decode without BOM on the
- * string percent decoding of input.
- * _Note:_ Alternatively UTF-8 decode without BOM or fail can be used,
- * coupled with an early return for failure, as domain to ASCII fails
- * on U+FFFD REPLACEMENT CHARACTER.
- */
- const domain = (0, util_1.utf8Decode)(stringPercentDecode(input));
- /**
- * 5. Let asciiDomain be the result of running domain to ASCII on domain.
- * 6. If asciiDomain is failure, validation error, return failure.
- * 7. If asciiDomain contains a forbidden host code point, validation error,
- * return failure.
- */
- const asciiDomain = domainToASCII(domain);
- if (asciiDomain === null) {
- validationError("Invalid domain.");
- return null;
- }
- if (_forbiddenHostCodePoint.test(asciiDomain)) {
- validationError("Invalid domain.");
- return null;
- }
- /**
- * 8. Let ipv4Host be the result of IPv4 parsing asciiDomain.
- * 9. If ipv4Host is an IPv4 address or failure, return ipv4Host.
- * 10. Return asciiDomain.
- */
- const ipv4Host = iPv4Parser(asciiDomain);
- if (ipv4Host === null || (0, util_1.isNumber)(ipv4Host))
- return ipv4Host;
- return asciiDomain;
-}
-/**
- * Parses a string containing an IP v4 address.
- *
- * @param input - input string
- * @param isNotSpecial - `true` if the source URL is not special; otherwise
- * `false`.
- */
-function iPv4NumberParser(input, validationErrorFlag = { value: false }) {
- /**
- * 1. Let R be 10.
- */
- let R = 10;
- if (input.startsWith("0x") || input.startsWith("0X")) {
- /**
- * 2. If input contains at least two code points and the first two code
- * points are either "0x" or "0X", then:
- * 2.1. Set validationErrorFlag.
- * 2.2. Remove the first two code points from input.
- * 2.3. Set R to 16.
- */
- validationErrorFlag.value = true;
- input = input.substr(2);
- R = 16;
- }
- else if (input.length >= 2 && input[0] === '0') {
- /**
- * 3. Otherwise, if input contains at least two code points and the first
- * code point is U+0030 (0), then:
- * 3.1. Set validationErrorFlag.
- * 3.2. Remove the first code point from input.
- * 3.3. Set R to 8.
- */
- validationErrorFlag.value = true;
- input = input.substr(1);
- R = 8;
- }
- /**
- * 4. If input is the empty string, then return zero.
- * 5. If input contains a code point that is not a radix-R digit, then
- * return failure.
- */
- if (input === "")
- return 0;
- const radixRDigits = (R === 10 ? /^[0-9]+$/ : (R === 16 ? /^[0-9A-Fa-f]+$/ : /^[0-7]+$/));
- if (!radixRDigits.test(input))
- return null;
- /**
- * 6. Return the mathematical integer value that is represented by input in
- * radix-R notation, using ASCII hex digits for digits with values
- * 0 through 15.
- */
- return parseInt(input, R);
-}
-/**
- * Parses a string containing an IP v4 address.
- *
- * @param input - input string
- */
-function iPv4Parser(input) {
- /**
- * 1. Let validationErrorFlag be unset.
- * 2. Let parts be input split on U+002E (.).
- */
- const validationErrorFlag = { value: false };
- const parts = input.split('.');
- /**
- * 3. If the last item in parts is the empty string, then:
- * 3.1. Set validationErrorFlag.
- * 3.2. If parts has more than one item, then remove the last item from
- * parts.
- */
- if (parts[parts.length - 1] === "") {
- validationErrorFlag.value = true;
- if (parts.length > 1)
- parts.pop();
- }
- /**
- * 4. If parts has more than four items, return input.
- */
- if (parts.length > 4)
- return input;
- /**
- * 5. Let numbers be the empty list.
- * 6. For each part in parts:
- * 6.1. If part is the empty string, return input.
- * 6.2. Let n be the result of parsing part using validationErrorFlag.
- * 6.3. If n is failure, return input.
- * 6.4. Append n to numbers.
- */
- const numbers = [];
- for (const part of parts) {
- if (part === "")
- return input;
- const n = iPv4NumberParser(part, validationErrorFlag);
- if (n === null)
- return input;
- numbers.push(n);
- }
- /**
- * 7. If validationErrorFlag is set, validation error.
- * 8. If any item in numbers is greater than 255, validation error.
- * 9. If any but the last item in numbers is greater than 255, return
- * failure.
- * 10. If the last item in numbers is greater than or equal to
- * 256**(5 − the number of items in numbers), validation error, return failure.
- */
- if (validationErrorFlag.value)
- validationError("Invalid IP v4 address.");
- for (let i = 0; i < numbers.length; i++) {
- const item = numbers[i];
- if (item > 255) {
- validationError("Invalid IP v4 address.");
- if (i < numbers.length - 1)
- return null;
- }
- }
- if (numbers[numbers.length - 1] >= Math.pow(256, 5 - numbers.length)) {
- validationError("Invalid IP v4 address.");
- return null;
- }
- /**
- * 11. Let ipv4 be the last item in numbers.
- * 12. Remove the last item from numbers.
- */
- let ipv4 = numbers[numbers.length - 1];
- numbers.pop();
- /**
- * 13. Let counter be zero.
- * 14. For each n in numbers:
- * 14.2. Increment ipv4 by n × 256**(3 − counter).
- * 14.2. Increment counter by 1.
- */
- let counter = 0;
- for (const n of numbers) {
- ipv4 += n * Math.pow(256, 3 - counter);
- counter++;
- }
- /**
- * 15. Return ipv4.
- */
- return ipv4;
-}
-/**
- * Parses a string containing an IP v6 address.
- *
- * @param input - input string
- */
-function iPv6Parser(input) {
- /**
- * 1. Let address be a new IPv6 address whose IPv6 pieces are all 0.
- * 2. Let pieceIndex be 0.
- * 3. Let compress be null.
- * 4. Let pointer be a pointer into input, initially 0 (pointing to the
- * first code point).
- */
- const EOF = "";
- const address = [0, 0, 0, 0, 0, 0, 0, 0];
- let pieceIndex = 0;
- let compress = null;
- const walker = new util_1.StringWalker(input);
- /**
- * 5. If c is U+003A (:), then:
- * 5.1. If remaining does not start with U+003A (:), validation error,
- * return failure.
- * 5.2. Increase pointer by 2.
- * 5.3. Increase pieceIndex by 1 and then set compress to pieceIndex.
- */
- if (walker.c() === ':') {
- if (!walker.remaining().startsWith(':')) {
- validationError("Invalid IP v6 address.");
- return null;
- }
- walker.pointer += 2;
- pieceIndex += 1;
- compress = pieceIndex;
- }
- /**
- * 6. While c is not the EOF code point:
- */
- while (walker.c() !== EOF) {
- /**
- * 6.1. If pieceIndex is 8, validation error, return failure.
- */
- if (pieceIndex === 8) {
- validationError("Invalid IP v6 address.");
- return null;
- }
- /**
- * 6.2. If c is U+003A (:), then:
- * 6.2.1. If compress is non-null, validation error, return failure.
- * 6.2.2. Increase pointer and pieceIndex by 1, set compress to pieceIndex,
- * and then continue.
- */
- if (walker.c() === ':') {
- if (compress !== null) {
- validationError("Invalid IP v6 address.");
- return null;
- }
- walker.pointer++;
- pieceIndex++;
- compress = pieceIndex;
- continue;
- }
- /**
- * 6.3. Let value and length be 0.
- * 6.4. While length is less than 4 and c is an ASCII hex digit, set value
- * to value × 0x10 + c interpreted as hexadecimal number, and increase
- * pointer and length by 1.
- */
- let value = 0;
- let length = 0;
- while (length < 4 && infra_1.codePoint.ASCIIHexDigit.test(walker.c())) {
- value = value * 0x10 + parseInt(walker.c(), 16);
- walker.pointer++;
- length++;
- }
- /**
- * 6.5. If c is U+002E (.), then:
- */
- if (walker.c() === '.') {
- /**
- * 6.5.1. If length is 0, validation error, return failure.
- * 6.5.2. Decrease pointer by length.
- * 6.5.3. If pieceIndex is greater than 6, validation error, return
- * failure.
- * 6.5.4. Let numbersSeen be 0.
- */
- if (length === 0) {
- validationError("Invalid IP v6 address.");
- return null;
- }
- walker.pointer -= length;
- if (pieceIndex > 6) {
- validationError("Invalid IP v6 address.");
- return null;
- }
- let numbersSeen = 0;
- /**
- * 6.5.5. While c is not the EOF code point:
- */
- while (walker.c() !== EOF) {
- /**
- * 6.5.5.1. Let ipv4Piece be null.
- */
- let ipv4Piece = null;
- /**
- * 6.5.5.2. If numbersSeen is greater than 0, then:
- * 6.5.5.2.1. If c is a U+002E (.) and numbersSeen is less than 4, then
- * increase pointer by 1.
- * 6.5.5.2.1. Otherwise, validation error, return failure.
- */
- if (numbersSeen > 0) {
- if (walker.c() === '.' && numbersSeen < 4) {
- walker.pointer++;
- }
- else {
- validationError("Invalid IP v6 address.");
- return null;
- }
- }
- /**
- * 6.5.5.3. If c is not an ASCII digit, validation error, return
- * failure.
- */
- if (!infra_1.codePoint.ASCIIDigit.test(walker.c())) {
- validationError("Invalid IP v6 address.");
- return null;
- }
- /**
- * 6.5.5.4. While c is an ASCII digit:
- */
- while (infra_1.codePoint.ASCIIDigit.test(walker.c())) {
- /**
- * 6.5.5.4.1. Let number be c interpreted as decimal number.
- */
- const number = parseInt(walker.c(), 10);
- /**
- * 6.5.5.4.2. If ipv4Piece is null, then set ipv4Piece to number.
- * Otherwise, if ipv4Piece is 0, validation error, return failure.
- * Otherwise, set ipv4Piece to ipv4Piece × 10 + number.
- */
- if (ipv4Piece === null) {
- ipv4Piece = number;
- }
- else if (ipv4Piece === 0) {
- validationError("Invalid IP v6 address.");
- return null;
- }
- else {
- ipv4Piece = ipv4Piece * 10 + number;
- }
- /**
- * 6.5.5.4.3. If ipv4Piece is greater than 255, validation error, return failure.
- * 6.5.5.4.4. Increase pointer by 1.
- */
- if (ipv4Piece > 255) {
- validationError("Invalid IP v6 address.");
- return null;
- }
- walker.pointer++;
- }
- /**
- * 6.5.5.5. Set address[pieceIndex] to address[pieceIndex] × 0x100 + ipv4Piece.
- * 6.5.5.6. Increase numbersSeen by 1.
- * 6.5.5.7. If numbersSeen is 2 or 4, then increase pieceIndex by 1.
- */
- if (ipv4Piece === null) {
- validationError("Invalid IP v6 address.");
- return null;
- }
- address[pieceIndex] = address[pieceIndex] * 0x100 + ipv4Piece;
- numbersSeen++;
- if (numbersSeen === 2 || numbersSeen === 4)
- pieceIndex++;
- }
- /**
- * 6.5.6. If numbersSeen is not 4, validation error, return failure.
- */
- if (numbersSeen !== 4) {
- validationError("Invalid IP v6 address.");
- return null;
- }
- /**
- * 6.5.7. Break.
- */
- break;
- }
- else if (walker.c() === ':') {
- /**
- * 6.6. Otherwise, if c is U+003A (:):
- * 6.6.1. Increase pointer by 1.
- * 6.6.2. If c is the EOF code point, validation error, return failure.
- */
- walker.pointer++;
- if (walker.c() === EOF) {
- validationError("Invalid IP v6 address.");
- return null;
- }
- }
- else if (walker.c() !== EOF) {
- /**
- * 6.7. Otherwise, if c is not the EOF code point, validation error,
- * return failure.
- */
- validationError("Invalid IP v6 address.");
- return null;
- }
- /**
- * 6.8. Set address[pieceIndex] to value.
- * 6.9. Increase pieceIndex by 1.
- */
- address[pieceIndex] = value;
- pieceIndex++;
- }
- /**
- * 7. If compress is non-null, then:
- * 7.1. Let swaps be pieceIndex − compress.
- * 7.2. Set pieceIndex to 7.
- * 7.3. While pieceIndex is not 0 and swaps is greater than 0, swap
- * address[pieceIndex] with address[compress + swaps − 1], and then decrease
- * both pieceIndex and swaps by 1.
- */
- if (compress !== null) {
- let swaps = pieceIndex - compress;
- pieceIndex = 7;
- while (pieceIndex !== 0 && swaps > 0) {
- [address[pieceIndex], address[compress + swaps - 1]] =
- [address[compress + swaps - 1], address[pieceIndex]];
- pieceIndex--;
- swaps--;
- }
- }
- else if (compress === null && pieceIndex !== 8) {
- /**
- * 8. Otherwise, if compress is null and pieceIndex is not 8,
- * validation error, return failure.
- */
- validationError("Invalid IP v6 address.");
- return null;
- }
- /**
- * 9. Return address.
- */
- return address;
-}
-/**
- * Parses an opaque host string.
- *
- * @param input - a string
- */
-function opaqueHostParser(input) {
- /**
- * 1. If input contains a forbidden host code point excluding U+0025 (%),
- * validation error, return failure.
- * 2. Let output be the empty string.
- * 3. For each code point in input, UTF-8 percent encode it using the C0
- * control percent-encode set, and append the result to output.
- * 4. Return output.
- */
- const forbiddenChars = /[\x00\t\f\r #/:?@\[\\\]]/;
- if (forbiddenChars.test(input)) {
- validationError("Invalid host string.");
- return null;
- }
- let output = "";
- for (const codePoint of input) {
- output += utf8PercentEncode(codePoint, _c0ControlPercentEncodeSet);
- }
- return output;
-}
-/**
- * Resolves a Blob URL from the user agent's Blob URL store.
- * function is not implemented.
- * See: https://w3c.github.io/FileAPI/#blob-url-resolve
- *
- * @param url - an url
- */
-function resolveABlobURL(url) {
- return null;
-}
-/**
- * Percent encodes a byte.
- *
- * @param value - a byte
- */
-function percentEncode(value) {
- /**
- * To percent encode a byte into a percent-encoded byte, return a string
- * consisting of U+0025 (%), followed by two ASCII upper hex digits
- * representing byte.
- */
- return '%' + ('00' + value.toString(16).toUpperCase()).slice(-2);
-}
-/**
- * Percent decodes a byte sequence input.
- *
- * @param input - a byte sequence
- */
-function percentDecode(input) {
- const isHexDigit = (byte) => {
- return (byte >= 0x30 && byte <= 0x39) || (byte >= 0x41 && byte <= 0x46) ||
- (byte >= 0x61 && byte <= 0x66);
- };
- /**
- * 1. Let output be an empty byte sequence.
- * 2. For each byte byte in input:
- */
- const output = new Uint8Array(input.length);
- let n = 0;
- for (let i = 0; i < input.length; i++) {
- const byte = input[i];
- /**
- * 2.1. If byte is not 0x25 (%), then append byte to output.
- * 2.2. Otherwise, if byte is 0x25 (%) and the next two bytes after byte
- * in input are not in the ranges 0x30 (0) to 0x39 (9), 0x41 (A)
- * to 0x46 (F), and 0x61 (a) to 0x66 (f), all inclusive, append byte
- * to output.
- * 2.3. Otherwise:
- * 2.3.1. Let bytePoint be the two bytes after byte in input, decoded,
- * and then interpreted as hexadecimal number.
- * 2.3.2. Append a byte whose value is bytePoint to output.
- * 2.3.3. Skip the next two bytes in input.
- */
- if (byte !== 0x25) {
- output[n] = byte;
- n++;
- }
- else if (byte === 0x25 && i >= input.length - 2) {
- output[n] = byte;
- n++;
- }
- else if (byte === 0x25 && (!isHexDigit(input[i + 1]) || !isHexDigit(input[i + 2]))) {
- output[n] = byte;
- n++;
- }
- else {
- const bytePoint = parseInt((0, util_1.utf8Decode)(Uint8Array.of(input[i + 1], input[i + 2])), 16);
- output[n] = bytePoint;
- n++;
- i += 2;
- }
- }
- return output.subarray(0, n);
-}
-/**
- * String percent decodes a string.
- *
- * @param input - a string
- */
-function stringPercentDecode(input) {
- /**
- * 1. Let bytes be the UTF-8 encoding of input.
- * 2. Return the percent decoding of bytes.
- */
- return percentDecode((0, util_1.utf8Encode)(input));
-}
-/**
- * UTF-8 percent encodes a code point, using a percent encode set.
- *
- * @param codePoint - a code point
- * @param percentEncodeSet - a percent encode set
- */
-function utf8PercentEncode(codePoint, percentEncodeSet) {
- /**
- * 1. If codePoint is not in percentEncodeSet, then return codePoint.
- * 2. Let bytes be the result of running UTF-8 encode on codePoint.
- * 3. Percent encode each byte in bytes, and then return the results
- * concatenated, in the same order.
- */
- if (!percentEncodeSet.test(codePoint))
- return codePoint;
- const bytes = (0, util_1.utf8Encode)(codePoint);
- let result = "";
- for (const byte of bytes) {
- result += percentEncode(byte);
- }
- return result;
-}
-/**
- * Determines if two hosts are considered equal.
- *
- * @param hostA - a host
- * @param hostB - a host
- */
-function hostEquals(hostA, hostB) {
- return hostA === hostB;
-}
-/**
- * Determines if two URLs are considered equal.
- *
- * @param urlA - a URL
- * @param urlB - a URL
- * @param excludeFragmentsFlag - whether to ignore fragments while comparing
- */
-function urlEquals(urlA, urlB, excludeFragmentsFlag = false) {
- /**
- * 1. Let serializedA be the result of serializing A, with the exclude
- * fragment flag set if the exclude fragments flag is set.
- * 2. Let serializedB be the result of serializing B, with the exclude
- * fragment flag set if the exclude fragments flag is set.
- * 3. Return true if serializedA is serializedB, and false otherwise.
- */
- return urlSerializer(urlA, excludeFragmentsFlag) ===
- urlSerializer(urlB, excludeFragmentsFlag);
-}
-/**
- * Parses an `application/x-www-form-urlencoded` string.
- *
- * @param input - a string
- */
-function urlEncodedStringParser(input) {
- /**
- * The application/x-www-form-urlencoded string parser takes a string input,
- * UTF-8 encodes it, and then returns the result of
- * application/x-www-form-urlencoded parsing it.
- */
- return urlEncodedParser((0, util_1.utf8Encode)(input));
-}
-/**
- * Parses `application/x-www-form-urlencoded` bytes.
- *
- * @param input - a byte sequence
- */
-function urlEncodedParser(input) {
- /**
- * 1. Let sequences be the result of splitting input on 0x26 (&).
- */
- const sequences = [];
- let currentSequence = [];
- for (const byte of input) {
- if (byte === 0x26) {
- sequences.push(Uint8Array.from(currentSequence));
- currentSequence = [];
- }
- else {
- currentSequence.push(byte);
- }
- }
- if (currentSequence.length !== 0) {
- sequences.push(Uint8Array.from(currentSequence));
- }
- /**
- * 2. Let output be an initially empty list of name-value tuples where both name and value hold a string.
- */
- const output = [];
- /**
- * 3. For each byte sequence bytes in sequences:
- */
- for (const bytes of sequences) {
- /**
- * 3.1. If bytes is the empty byte sequence, then continue.
- */
- if (bytes.length === 0)
- continue;
- /**
- * 3.2. If bytes contains a 0x3D (=), then let name be the bytes from the
- * start of bytes up to but excluding its first 0x3D (=), and let value be
- * the bytes, if any, after the first 0x3D (=) up to the end of bytes.
- * If 0x3D (=) is the first byte, then name will be the empty byte
- * sequence. If it is the last, then value will be the empty byte sequence.
- * 3.3. Otherwise, let name have the value of bytes and let value be the
- * empty byte sequence.
- */
- const index = bytes.indexOf(0x3D);
- const name = (index !== -1 ? bytes.slice(0, index) : bytes);
- const value = (index !== -1 ? bytes.slice(index + 1) : new Uint8Array());
- /**
- * 3.4. Replace any 0x2B (+) in name and value with 0x20 (SP).
- */
- for (let i = 0; i < name.length; i++)
- if (name[i] === 0x2B)
- name[i] = 0x20;
- for (let i = 0; i < value.length; i++)
- if (value[i] === 0x2B)
- value[i] = 0x20;
- /**
- * 3.5. Let nameString and valueString be the result of running UTF-8
- * decode without BOM on the percent decoding of name and value,
- * respectively.
- */
- const nameString = (0, util_1.utf8Decode)(name);
- const valueString = (0, util_1.utf8Decode)(value);
- /**
- * 3.6. Append (nameString, valueString) to output.
- */
- output.push([nameString, valueString]);
- }
- /**
- * 4. Return output.
- */
- return output;
-}
-/**
- * Serializes `application/x-www-form-urlencoded` bytes.
- *
- * @param input - a byte sequence
- */
-function urlEncodedByteSerializer(input) {
- /**
- * 1. Let output be the empty string.
- * 2. For each byte in input, depending on byte:
- * 0x20 (SP)
- * Append U+002B (+) to output.
- *
- * 0x2A (*)
- * 0x2D (-)
- * 0x2E (.)
- * 0x30 (0) to 0x39 (9)
- * 0x41 (A) to 0x5A (Z)
- * 0x5F (_)
- * 0x61 (a) to 0x7A (z)
- * Append a code point whose value is byte to output.
- *
- * Otherwise
- * Append byte, percent encoded, to output.
- * 3. Return output.
- */
- let output = "";
- for (const byte of input) {
- if (byte === 0x20) {
- output += '+';
- }
- else if (byte === 0x2A || byte === 0x2D || byte === 0x2E ||
- (byte >= 0x30 && byte <= 0x39) || (byte >= 0x41 && byte <= 0x5A) ||
- byte === 0x5F || (byte >= 0x61 && byte <= 0x7A)) {
- output += String.fromCodePoint(byte);
- }
- else {
- output += percentEncode(byte);
- }
- }
- return output;
-}
-/**
- * Serializes `application/x-www-form-urlencoded` tuples.
- *
- * @param input - input tuple of name/value pairs
- * @param encodingOverride: encoding override
- */
-function urlEncodedSerializer(tuples, encodingOverride) {
- /**
- * 1. Let encoding be UTF-8.
- * 2. If encoding override is given, set encoding to the result of getting
- * an output encoding from encoding override.
- */
- const encoding = (encodingOverride === undefined ||
- encodingOverride === "replacement" || encodingOverride === "UTF-16BE" ||
- encodingOverride === "UTF-16LE" ? "UTF-8" : encodingOverride);
- if (encoding.toUpperCase() !== "UTF-8") {
- throw new Error("Only UTF-8 encoding is supported.");
- }
- /**
- * 3. Let output be the empty string.
- */
- let output = "";
- /**
- * 4. For each tuple in tuples:
- */
- for (const tuple of tuples) {
- /**
- * 4.1. Let name be the result of serializing the result of encoding
- * tuple’s name, using encoding.
- */
- const name = urlEncodedByteSerializer((0, util_1.utf8Encode)(tuple[0]));
- /**
- * 4.2. Let value be tuple’s value.
- */
- let value = tuple[1];
- /**
- * TODO:
- * 4.3. If value is a file, then set value to value’s filename.
- */
- /**
- * 4.4. Set value to the result of serializing the result of encoding
- * value, using encoding.
- */
- value = urlEncodedByteSerializer((0, util_1.utf8Encode)(value));
- /**
- * 4.5. If tuple is not the first pair in tuples, then append U+0026 (&)
- * to output.
- */
- if (output !== "")
- output += '&';
- /**
- * 4.6. Append name, followed by U+003D (=), followed by value, to output.
- */
- output += name + '=' + value;
- }
- /**
- * 5. Return output.
- */
- return output;
-}
-/**
- * Returns a URL's origin.
- *
- * @param url - a URL
- */
-function origin(url) {
- /**
- * A URL’s origin is the origin returned by running these steps, switching
- * on URL’s scheme:
- * "blob"
- * 1. If URL’s blob URL entry is non-null, then return URL’s blob URL
- * entry’s environment’s origin.
- * 2. Let url be the result of parsing URL’s path[0].
- * 3. Return a new opaque origin, if url is failure, and url’s origin
- * otherwise.
- * "ftp"
- * "http"
- * "https"
- * "ws"
- * "wss"
- * Return a tuple consisting of URL’s scheme, URL’s host, URL’s port, and
- * null.
- * "file"
- * Unfortunate as it is, is left as an exercise to the reader. When in
- * doubt, return a new opaque origin.
- * Otherwise
- * Return a new opaque origin.
- */
- switch (url.scheme) {
- case "blob":
- if (url._blobURLEntry !== null) {
- // TODO: return URL’s blob URL entry’s environment’s origin.
- }
- const parsedURL = basicURLParser(url.path[0]);
- if (parsedURL === null)
- return interfaces_1.OpaqueOrigin;
- else
- return origin(parsedURL);
- case "ftp":
- case "http":
- case "https":
- case "ws":
- case "wss":
- return [url.scheme, url.host === null ? "" : url.host, url.port, null];
- case "file":
- return interfaces_1.OpaqueOrigin;
- default:
- return interfaces_1.OpaqueOrigin;
- }
-}
-/**
- * Converts a domain string to ASCII.
- *
- * @param domain - a domain string
- */
-function domainToASCII(domain, beStrict = false) {
- /**
- * 1. If beStrict is not given, set it to false.
- * 2. Let result be the result of running Unicode ToASCII with domain_name
- * set to domain, UseSTD3ASCIIRules set to beStrict, CheckHyphens set to
- * false, CheckBidi set to true, CheckJoiners set to true,
- * Transitional_Processing set to false, and VerifyDnsLength set to beStrict.
- * 3. If result is a failure value, validation error, return failure.
- * 4. Return result.
- */
- // Use node.js function
- const result = (0, url_1.domainToASCII)(domain);
- if (result === "") {
- validationError("Invalid domain name.");
- return null;
- }
- return result;
-}
-/**
- * Converts a domain string to Unicode.
- *
- * @param domain - a domain string
- */
-function domainToUnicode(domain, beStrict = false) {
- /**
- * 1. Let result be the result of running Unicode ToUnicode with domain_name
- * set to domain, CheckHyphens set to false, CheckBidi set to true,
- * CheckJoiners set to true, UseSTD3ASCIIRules set to false, and
- * Transitional_Processing set to false.
- * 2. Signify validation errors for any returned errors, and then,
- * return result.
- */
- // Use node.js function
- const result = (0, url_1.domainToUnicode)(domain);
- if (result === "") {
- validationError("Invalid domain name.");
- }
- return result;
-}
-/**
- * Serializes an origin.
- * function is from the HTML spec:
- * https://html.spec.whatwg.org/#ascii-serialisation-of-an-origin
- *
- * @param origin - an origin
- */
-function asciiSerializationOfAnOrigin(origin) {
- /**
- * 1. If origin is an opaque origin, then return "null".
- * 2. Otherwise, let result be origin's scheme.
- * 3. Append "://" to result.
- * 4. Append origin's host, serialized, to result.
- * 5. If origin's port is non-null, append a U+003A COLON character (:),
- * and origin's port, serialized, to result.
- * 6. Return result.
- */
- if (origin[0] === "" && origin[1] === "" && origin[2] === null && origin[3] === null) {
- return "null";
- }
- let result = origin[0] + "://" + hostSerializer(origin[1]);
- if (origin[2] !== null)
- result += ":" + origin[2].toString();
- return result;
-}
-//# sourceMappingURL=URLAlgorithm.js.map
-
-/***/ }),
-
-/***/ 3904:
-/***/ ((__unused_webpack_module, exports) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.OpaqueOrigin = exports.ParserState = void 0;
-/**
- * Represents the state of the URL parser.
- */
-var ParserState;
-(function (ParserState) {
- ParserState[ParserState["SchemeStart"] = 0] = "SchemeStart";
- ParserState[ParserState["Scheme"] = 1] = "Scheme";
- ParserState[ParserState["NoScheme"] = 2] = "NoScheme";
- ParserState[ParserState["SpecialRelativeOrAuthority"] = 3] = "SpecialRelativeOrAuthority";
- ParserState[ParserState["PathOrAuthority"] = 4] = "PathOrAuthority";
- ParserState[ParserState["Relative"] = 5] = "Relative";
- ParserState[ParserState["RelativeSlash"] = 6] = "RelativeSlash";
- ParserState[ParserState["SpecialAuthoritySlashes"] = 7] = "SpecialAuthoritySlashes";
- ParserState[ParserState["SpecialAuthorityIgnoreSlashes"] = 8] = "SpecialAuthorityIgnoreSlashes";
- ParserState[ParserState["Authority"] = 9] = "Authority";
- ParserState[ParserState["Host"] = 10] = "Host";
- ParserState[ParserState["Hostname"] = 11] = "Hostname";
- ParserState[ParserState["Port"] = 12] = "Port";
- ParserState[ParserState["File"] = 13] = "File";
- ParserState[ParserState["FileSlash"] = 14] = "FileSlash";
- ParserState[ParserState["FileHost"] = 15] = "FileHost";
- ParserState[ParserState["PathStart"] = 16] = "PathStart";
- ParserState[ParserState["Path"] = 17] = "Path";
- ParserState[ParserState["CannotBeABaseURLPath"] = 18] = "CannotBeABaseURLPath";
- ParserState[ParserState["Query"] = 19] = "Query";
- ParserState[ParserState["Fragment"] = 20] = "Fragment";
-})(ParserState || (exports.ParserState = ParserState = {}));
-exports.OpaqueOrigin = ["", "", null, null];
-//# sourceMappingURL=interfaces.js.map
-
-/***/ }),
-
-/***/ 214:
-/***/ ((__unused_webpack_module, exports) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.CompareCache = void 0;
-/**
- * Represents a cache for storing order between equal objects.
- *
- * This cache is used when an algorithm compares two objects and finds them to
- * be equal but still needs to establish an order between those two objects.
- * When two such objects `a` and `b` are passed to the `check` method, a random
- * number is generated with `Math.random()`. If the random number is less than
- * `0.5` it is assumed that `a < b` otherwise `a > b`. The random number along
- * with `a` and `b` is stored in the cache, so that subsequent checks result
- * in the same consistent result.
- *
- * The cache has a size limit which is defined on initialization.
- */
-class CompareCache {
- _limit;
- _items = new Map();
- /**
- * Initializes a new instance of `CompareCache`.
- *
- * @param limit - maximum number of items to keep in the cache. When the limit
- * is exceeded the first item is removed from the cache.
- */
- constructor(limit = 1000) {
- this._limit = limit;
- }
- /**
- * Compares and caches the given objects. Returns `true` if `objA < objB` and
- * `false` otherwise.
- *
- * @param objA - an item to compare
- * @param objB - an item to compare
- */
- check(objA, objB) {
- if (this._items.get(objA) === objB)
- return true;
- else if (this._items.get(objB) === objA)
- return false;
- const result = (Math.random() < 0.5);
- if (result) {
- this._items.set(objA, objB);
- }
- else {
- this._items.set(objB, objA);
- }
- if (this._items.size > this._limit) {
- const it = this._items.keys().next();
- /* istanbul ignore else */
- if (!it.done) {
- this._items.delete(it.value);
- }
- }
- return result;
- }
-}
-exports.CompareCache = CompareCache;
-//# sourceMappingURL=CompareCache.js.map
-
-/***/ }),
-
-/***/ 3004:
-/***/ ((__unused_webpack_module, exports) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.FixedSizeSet = void 0;
-/**
- * Represents a set of objects with a size limit.
- */
-class FixedSizeSet {
- _limit;
- _items = new Set();
- /**
- * Initializes a new instance of `FixedSizeSet`.
- *
- * @param limit - maximum number of items to keep in the set. When the limit
- * is exceeded the first item is removed from the set.
- */
- constructor(limit = 1000) {
- this._limit = limit;
- }
- /**
- * Adds a new item to the set.
- *
- * @param item - an item
- */
- add(item) {
- this._items.add(item);
- if (this._items.size > this._limit) {
- const it = this._items.values().next();
- /* istanbul ignore else */
- if (!it.done) {
- this._items.delete(it.value);
- }
- }
- return this;
- }
- /**
- * Removes an item from the set.
- *
- * @param item - an item
- */
- delete(item) {
- return this._items.delete(item);
- }
- /**
- * Determines if an item is in the set.
- *
- * @param item - an item
- */
- has(item) {
- return this._items.has(item);
- }
- /**
- * Removes all items from the set.
- */
- clear() {
- this._items.clear();
- }
- /**
- * Gets the number of items in the set.
- */
- get size() { return this._items.size; }
- /**
- * Applies the given callback function to all elements of the set.
- */
- forEach(callback, thisArg) {
- this._items.forEach(e => callback.call(thisArg, e, e, this));
- }
- /**
- * Iterates through the items in the set.
- */
- *keys() {
- yield* this._items.keys();
- }
- /**
- * Iterates through the items in the set.
- */
- *values() {
- yield* this._items.values();
- }
- /**
- * Iterates through the items in the set.
- */
- *entries() {
- yield* this._items.entries();
- }
- /**
- * Iterates through the items in the set.
- */
- *[Symbol.iterator]() {
- yield* this._items;
- }
- /**
- * Returns the string tag of the set.
- */
- get [Symbol.toStringTag]() {
- return "FixedSizeSet";
- }
-}
-exports.FixedSizeSet = FixedSizeSet;
-//# sourceMappingURL=FixedSizeSet.js.map
-
-/***/ }),
-
-/***/ 1323:
-/***/ ((__unused_webpack_module, exports) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.Lazy = void 0;
-/**
- * Represents an object with lazy initialization.
- */
-class Lazy {
- _initialized = false;
- _initFunc;
- _value;
- /**
- * Initializes a new instance of `Lazy`.
- *
- * @param initFunc - initializer function
- */
- constructor(initFunc) {
- this._value = undefined;
- this._initFunc = initFunc;
- }
- /**
- * Gets the value of the object.
- */
- get value() {
- if (!this._initialized) {
- this._value = this._initFunc();
- this._initialized = true;
- }
- return this._value;
- }
-}
-exports.Lazy = Lazy;
-//# sourceMappingURL=Lazy.js.map
-
-/***/ }),
-
-/***/ 950:
-/***/ ((__unused_webpack_module, exports) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.ObjectCache = void 0;
-/**
- * Represents a cache of objects with a size limit.
- */
-class ObjectCache {
- _limit;
- _items = new Map();
- /**
- * Initializes a new instance of `ObjectCache`.
- *
- * @param limit - maximum number of items to keep in the cache. When the limit
- * is exceeded the first item is removed from the cache.
- */
- constructor(limit = 1000) {
- this._limit = limit;
- }
- /**
- * Gets an item from the cache.
- *
- * @param key - object key
- */
- get(key) {
- return this._items.get(key);
- }
- /**
- * Adds a new item to the cache.
- *
- * @param key - object key
- * @param value - object value
- */
- set(key, value) {
- this._items.set(key, value);
- if (this._items.size > this._limit) {
- const it = this._items.keys().next();
- /* istanbul ignore else */
- if (!it.done) {
- this._items.delete(it.value);
- }
- }
- }
- /**
- * Removes an item from the cache.
- *
- * @param item - an item
- */
- delete(key) {
- return this._items.delete(key);
- }
- /**
- * Determines if an item is in the cache.
- *
- * @param item - an item
- */
- has(key) {
- return this._items.has(key);
- }
- /**
- * Removes all items from the cache.
- */
- clear() {
- this._items.clear();
- }
- /**
- * Gets the number of items in the cache.
- */
- get size() { return this._items.size; }
- /**
- * Applies the given callback function to all elements of the cache.
- */
- forEach(callback, thisArg) {
- this._items.forEach((v, k) => callback.call(thisArg, k, v));
- }
- /**
- * Iterates through the items in the set.
- */
- *keys() {
- yield* this._items.keys();
- }
- /**
- * Iterates through the items in the set.
- */
- *values() {
- yield* this._items.values();
- }
- /**
- * Iterates through the items in the set.
- */
- *entries() {
- yield* this._items.entries();
- }
- /**
- * Iterates through the items in the set.
- */
- *[Symbol.iterator]() {
- yield* this._items;
- }
- /**
- * Returns the string tag of the cache.
- */
- get [Symbol.toStringTag]() {
- return "ObjectCache";
- }
-}
-exports.ObjectCache = ObjectCache;
-//# sourceMappingURL=ObjectCache.js.map
-
-/***/ }),
-
-/***/ 9262:
-/***/ ((__unused_webpack_module, exports) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.StringWalker = void 0;
-/**
- * Walks through the code points of a string.
- */
-class StringWalker {
- _chars;
- _length;
- _pointer = 0;
- _codePoint;
- _c;
- _remaining;
- _substring;
- /**
- * Initializes a new `StringWalker`.
- *
- * @param input - input string
- */
- constructor(input) {
- this._chars = Array.from(input);
- this._length = this._chars.length;
- }
- /**
- * Determines if the current position is beyond the end of string.
- */
- get eof() { return this._pointer >= this._length; }
- /**
- * Returns the number of code points in the input string.
- */
- get length() { return this._length; }
- /**
- * Returns the current code point. Returns `-1` if the position is beyond
- * the end of string.
- */
- codePoint() {
- if (this._codePoint === undefined) {
- if (this.eof) {
- this._codePoint = -1;
- }
- else {
- const cp = this._chars[this._pointer].codePointAt(0);
- /* istanbul ignore else */
- if (cp !== undefined) {
- this._codePoint = cp;
- }
- else {
- this._codePoint = -1;
- }
- }
- }
- return this._codePoint;
- }
- /**
- * Returns the current character. Returns an empty string if the position is
- * beyond the end of string.
- */
- c() {
- if (this._c === undefined) {
- this._c = (this.eof ? "" : this._chars[this._pointer]);
- }
- return this._c;
- }
- /**
- * Returns the remaining string.
- */
- remaining() {
- if (this._remaining === undefined) {
- this._remaining = (this.eof ?
- "" : this._chars.slice(this._pointer + 1).join(''));
- }
- return this._remaining;
- }
- /**
- * Returns the substring from the current character to the end of string.
- */
- substring() {
- if (this._substring === undefined) {
- this._substring = (this.eof ?
- "" : this._chars.slice(this._pointer).join(''));
- }
- return this._substring;
- }
- /**
- * Gets or sets the current position.
- */
- get pointer() { return this._pointer; }
- set pointer(val) {
- if (val === this._pointer)
- return;
- this._pointer = val;
- this._codePoint = undefined;
- this._c = undefined;
- this._remaining = undefined;
- this._substring = undefined;
- }
-}
-exports.StringWalker = StringWalker;
-//# sourceMappingURL=StringWalker.js.map
-
-/***/ }),
-
-/***/ 7061:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.StringWalker = exports.Lazy = exports.CompareCache = exports.ObjectCache = exports.FixedSizeSet = void 0;
-exports.applyMixin = applyMixin;
-exports.applyDefaults = applyDefaults;
-exports.forEachArray = forEachArray;
-exports.forEachObject = forEachObject;
-exports.arrayLength = arrayLength;
-exports.objectLength = objectLength;
-exports.getObjectValue = getObjectValue;
-exports.removeObjectValue = removeObjectValue;
-exports.clone = clone;
-exports.isBoolean = isBoolean;
-exports.isNumber = isNumber;
-exports.isString = isString;
-exports.isFunction = isFunction;
-exports.isObject = isObject;
-exports.isArray = isArray;
-exports.isSet = isSet;
-exports.isMap = isMap;
-exports.isEmpty = isEmpty;
-exports.isPlainObject = isPlainObject;
-exports.isIterable = isIterable;
-exports.getValue = getValue;
-exports.utf8Encode = utf8Encode;
-exports.utf8Decode = utf8Decode;
-var FixedSizeSet_js_1 = __nccwpck_require__(3004);
-Object.defineProperty(exports, "FixedSizeSet", ({ enumerable: true, get: function () { return FixedSizeSet_js_1.FixedSizeSet; } }));
-var ObjectCache_js_1 = __nccwpck_require__(950);
-Object.defineProperty(exports, "ObjectCache", ({ enumerable: true, get: function () { return ObjectCache_js_1.ObjectCache; } }));
-var CompareCache_js_1 = __nccwpck_require__(214);
-Object.defineProperty(exports, "CompareCache", ({ enumerable: true, get: function () { return CompareCache_js_1.CompareCache; } }));
-var Lazy_js_1 = __nccwpck_require__(1323);
-Object.defineProperty(exports, "Lazy", ({ enumerable: true, get: function () { return Lazy_js_1.Lazy; } }));
-var StringWalker_js_1 = __nccwpck_require__(9262);
-Object.defineProperty(exports, "StringWalker", ({ enumerable: true, get: function () { return StringWalker_js_1.StringWalker; } }));
-/**
- * Applies the mixin to a given class.
- *
- * @param baseClass - class to receive the mixin
- * @param mixinClass - mixin class
- * @param overrides - an array with names of function overrides. Base class
- * functions whose names are in this array will be kept by prepending an
- * underscore to their names.
- */
-function applyMixin(baseClass, mixinClass, ...overrides) {
- Object.getOwnPropertyNames(mixinClass.prototype).forEach(name => {
- if (name !== "constructor") {
- if (overrides.indexOf(name) !== -1) {
- const orgPropDesc = Object.getOwnPropertyDescriptor(baseClass.prototype, name);
- /* istanbul ignore else */
- if (orgPropDesc) {
- Object.defineProperty(baseClass.prototype, "_" + name, orgPropDesc);
- }
- }
- const propDesc = Object.getOwnPropertyDescriptor(mixinClass.prototype, name);
- /* istanbul ignore else */
- if (propDesc) {
- Object.defineProperty(baseClass.prototype, name, propDesc);
- }
- }
- });
-}
-/**
- * Applies default values to the given object.
- *
- * @param obj - an object
- * @param defaults - an object with default values
- * @param overwrite - if set to `true` defaults object always overwrites object
- * values, whether they are `undefined` or not.
- */
-function applyDefaults(obj, defaults, overwrite = false) {
- const result = clone(obj || {});
- forEachObject(defaults, (key, val) => {
- if (isPlainObject(val)) {
- result[key] = applyDefaults(result[key], val, overwrite);
- }
- else if (overwrite || result[key] === undefined) {
- result[key] = val;
- }
- });
- return result;
-}
-/**
- * Iterates over items of an array or set.
- *
- * @param arr - array or set to iterate
- * @param callback - a callback function which receives each array item as its
- * single argument
- * @param thisArg - the value of this inside callback
- */
-function forEachArray(arr, callback, thisArg) {
- arr.forEach(callback, thisArg);
-}
-/**
- * Iterates over key/value pairs of a map or object.
- *
- * @param obj - map or object to iterate
- * @param callback - a callback function which receives object key as its first
- * argument and object value as its second argument
- * @param thisArg - the value of this inside callback
- */
-function forEachObject(obj, callback, thisArg) {
- if (isMap(obj)) {
- obj.forEach((value, key) => callback.call(thisArg, key, value));
- }
- else {
- for (const key in obj) {
- /* istanbul ignore else */
- if (obj.hasOwnProperty(key)) {
- callback.call(thisArg, key, obj[key]);
- }
- }
- }
-}
-/**
- * Returns the number of entries in an array or set.
- *
- * @param arr - array or set
- */
-function arrayLength(obj) {
- if (isSet(obj)) {
- return obj.size;
- }
- else {
- return obj.length;
- }
-}
-/**
- * Returns the number of entries in a map or object.
- *
- * @param obj - map or object
- */
-function objectLength(obj) {
- if (isMap(obj)) {
- return obj.size;
- }
- else {
- return Object.keys(obj).length;
- }
-}
-/**
- * Gets the value of a key from a map or object.
- *
- * @param obj - map or object
- * @param key - the key to retrieve
- */
-function getObjectValue(obj, key) {
- if (isMap(obj)) {
- return obj.get(key);
- }
- else {
- return obj[key];
- }
-}
-/**
- * Removes a property from a map or object.
- *
- * @param obj - map or object
- * @param key - the key to remove
- */
-function removeObjectValue(obj, key) {
- if (isMap(obj)) {
- obj.delete(key);
- }
- else {
- delete obj[key];
- }
-}
-/**
- * Deep clones the given object.
- *
- * @param obj - an object
- */
-function clone(obj) {
- if (isFunction(obj)) {
- return obj;
- }
- else if (isArray(obj)) {
- const result = [];
- for (const item of obj) {
- result.push(clone(item));
- }
- return result;
- }
- else if (isPlainObject(obj)) {
- const result = {};
- for (const key in obj) {
- /* istanbul ignore next */
- if (obj.hasOwnProperty(key)) {
- const val = obj[key];
- result[key] = clone(val);
- }
- }
- return result;
- }
- else {
- return obj;
- }
-}
-/**
- * Type guard for boolean types
- *
- * @param x - a variable to type check
- */
-function isBoolean(x) {
- return typeof x === "boolean";
-}
-/**
- * Type guard for numeric types
- *
- * @param x - a variable to type check
- */
-function isNumber(x) {
- return typeof x === "number";
-}
-/**
- * Type guard for strings
- *
- * @param x - a variable to type check
- */
-function isString(x) {
- return typeof x === "string";
-}
-/**
- * Type guard for function objects
- *
- * @param x - a variable to type check
- */
-function isFunction(x) {
- return !!x && typeof x === 'function';
-}
-/**
- * Type guard for JS objects
- *
- * _Note:_ Functions are objects too
- *
- * @param x - a variable to type check
- */
-function isObject(x) {
- const type = typeof x;
- return !!x && (type === 'function' || type === 'object');
-}
-/**
- * Type guard for arrays
- *
- * @param x - a variable to type check
- */
-function isArray(x) {
- return Array.isArray(x);
-}
-/**
- * Type guard for sets.
- *
- * @param x - a variable to check
- */
-function isSet(x) {
- return x instanceof Set;
-}
-/**
- * Type guard for maps.
- *
- * @param x - a variable to check
- */
-function isMap(x) {
- return x instanceof Map;
-}
-/**
- * Determines if `x` is an empty Array or an Object with no own properties.
- *
- * @param x - a variable to check
- */
-function isEmpty(x) {
- if (isArray(x)) {
- return !x.length;
- }
- else if (isSet(x)) {
- return !x.size;
- }
- else if (isMap(x)) {
- return !x.size;
- }
- else if (isObject(x)) {
- for (const key in x) {
- if (x.hasOwnProperty(key)) {
- return false;
- }
- }
- return true;
- }
- return false;
-}
-/**
- * Determines if `x` is a plain Object.
- *
- * @param x - a variable to check
- */
-function isPlainObject(x) {
- if (isObject(x)) {
- const proto = Object.getPrototypeOf(x);
- const ctor = proto.constructor;
- return proto && ctor &&
- (typeof ctor === 'function') && (ctor instanceof ctor) &&
- (Function.prototype.toString.call(ctor) === Function.prototype.toString.call(Object));
- }
- return false;
-}
-/**
- * Determines if `x` is an iterable Object.
- *
- * @param x - a variable to check
- */
-function isIterable(x) {
- return x && (typeof x[Symbol.iterator] === 'function');
-}
-/**
- * Gets the primitive value of an object.
- */
-function getValue(obj) {
- if (isFunction(obj.valueOf)) {
- return obj.valueOf();
- }
- else {
- return obj;
- }
-}
-/**
- * UTF-8 encodes the given string.
- *
- * @param input - a string
- */
-function utf8Encode(input) {
- const bytes = new Uint8Array(input.length * 4);
- let byteIndex = 0;
- for (let i = 0; i < input.length; i++) {
- let char = input.charCodeAt(i);
- if (char < 128) {
- bytes[byteIndex++] = char;
- continue;
- }
- else if (char < 2048) {
- bytes[byteIndex++] = char >> 6 | 192;
- }
- else {
- if (char > 0xd7ff && char < 0xdc00) {
- if (++i >= input.length) {
- throw new Error("Incomplete surrogate pair.");
- }
- const c2 = input.charCodeAt(i);
- if (c2 < 0xdc00 || c2 > 0xdfff) {
- throw new Error("Invalid surrogate character.");
- }
- char = 0x10000 + ((char & 0x03ff) << 10) + (c2 & 0x03ff);
- bytes[byteIndex++] = char >> 18 | 240;
- bytes[byteIndex++] = char >> 12 & 63 | 128;
- }
- else {
- bytes[byteIndex++] = char >> 12 | 224;
- }
- bytes[byteIndex++] = char >> 6 & 63 | 128;
- }
- bytes[byteIndex++] = char & 63 | 128;
- }
- return bytes.subarray(0, byteIndex);
-}
-/**
- * UTF-8 decodes the given byte sequence into a string.
- *
- * @param bytes - a byte sequence
- */
-function utf8Decode(bytes) {
- let result = "";
- let i = 0;
- while (i < bytes.length) {
- var c = bytes[i++];
- if (c > 127) {
- if (c > 191 && c < 224) {
- if (i >= bytes.length) {
- throw new Error("Incomplete 2-byte sequence.");
- }
- c = (c & 31) << 6 | bytes[i++] & 63;
- }
- else if (c > 223 && c < 240) {
- if (i + 1 >= bytes.length) {
- throw new Error("Incomplete 3-byte sequence.");
- }
- c = (c & 15) << 12 | (bytes[i++] & 63) << 6 | bytes[i++] & 63;
- }
- else if (c > 239 && c < 248) {
- if (i + 2 >= bytes.length) {
- throw new Error("Incomplete 4-byte sequence.");
- }
- c = (c & 7) << 18 | (bytes[i++] & 63) << 12 | (bytes[i++] & 63) << 6 | bytes[i++] & 63;
- }
- else {
- throw new Error("Unknown multi-byte start.");
- }
- }
- if (c <= 0xffff) {
- result += String.fromCharCode(c);
- }
- else if (c <= 0x10ffff) {
- c -= 0x10000;
- result += String.fromCharCode(c >> 10 | 0xd800);
- result += String.fromCharCode(c & 0x3FF | 0xdc00);
- }
- else {
- throw new Error("Code point exceeds UTF-16 limit.");
- }
- }
- return result;
-}
-//# sourceMappingURL=index.js.map
-
-/***/ }),
-
/***/ 9379:
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
@@ -21647,7 +143,7 @@ module.exports = Comparator
const parseOptions = __nccwpck_require__(356)
const { safeRe: re, t } = __nccwpck_require__(5471)
-const cmp = __nccwpck_require__(6265)
+const cmp = __nccwpck_require__(8646)
const debug = __nccwpck_require__(1159)
const SemVer = __nccwpck_require__(7163)
const Range = __nccwpck_require__(6782)
@@ -22611,7 +1107,7 @@ module.exports = clean
/***/ }),
-/***/ 6265:
+/***/ 8646:
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
@@ -22672,7 +1168,7 @@ module.exports = cmp
/***/ }),
-/***/ 7766:
+/***/ 5385:
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
@@ -23182,8 +1678,8 @@ const eq = __nccwpck_require__(5082)
const neq = __nccwpck_require__(4974)
const gte = __nccwpck_require__(1236)
const lte = __nccwpck_require__(6717)
-const cmp = __nccwpck_require__(6265)
-const coerce = __nccwpck_require__(7766)
+const cmp = __nccwpck_require__(8646)
+const coerce = __nccwpck_require__(5385)
const truncate = __nccwpck_require__(6114)
const Comparator = __nccwpck_require__(9379)
const Range = __nccwpck_require__(6782)
@@ -23192,7 +1688,7 @@ const toComparators = __nccwpck_require__(4750)
const maxSatisfying = __nccwpck_require__(5574)
const minSatisfying = __nccwpck_require__(8595)
const minVersion = __nccwpck_require__(1866)
-const validRange = __nccwpck_require__(7118)
+const validRange = __nccwpck_require__(4737)
const outside = __nccwpck_require__(280)
const gtr = __nccwpck_require__(2276)
const ltr = __nccwpck_require__(5213)
@@ -24249,7 +2745,7 @@ module.exports = toComparators
/***/ }),
-/***/ 7118:
+/***/ 4737:
/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
@@ -52266,4065 +30762,6 @@ module.exports = {
}
-/***/ }),
-
-/***/ 8771:
-/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
-
-
-
-const loader = __nccwpck_require__(7600)
-const dumper = __nccwpck_require__(5642)
-
-function renamed (from, to) {
- return function () {
- throw new Error('Function yaml.' + from + ' is removed in js-yaml 4. ' +
- 'Use yaml.' + to + ' instead, which is now safe by default.')
- }
-}
-
-module.exports.Type = __nccwpck_require__(1015)
-module.exports.Schema = __nccwpck_require__(8000)
-module.exports.FAILSAFE_SCHEMA = __nccwpck_require__(8334)
-module.exports.JSON_SCHEMA = __nccwpck_require__(9625)
-module.exports.CORE_SCHEMA = __nccwpck_require__(9568)
-module.exports.DEFAULT_SCHEMA = __nccwpck_require__(914)
-module.exports.load = loader.load
-module.exports.loadAll = loader.loadAll
-module.exports.dump = dumper.dump
-module.exports.YAMLException = __nccwpck_require__(3194)
-
-// Re-export all types in case user wants to create custom schema
-module.exports.types = {
- binary: __nccwpck_require__(1531),
- float: __nccwpck_require__(4334),
- map: __nccwpck_require__(9098),
- null: __nccwpck_require__(4427),
- pairs: __nccwpck_require__(5129),
- set: __nccwpck_require__(7344),
- timestamp: __nccwpck_require__(6856),
- bool: __nccwpck_require__(8246),
- int: __nccwpck_require__(2961),
- merge: __nccwpck_require__(4844),
- omap: __nccwpck_require__(5639),
- seq: __nccwpck_require__(4707),
- str: __nccwpck_require__(7055)
-}
-
-// Removed functions from JS-YAML 3.0.x
-module.exports.safeLoad = renamed('safeLoad', 'load')
-module.exports.safeLoadAll = renamed('safeLoadAll', 'loadAll')
-module.exports.safeDump = renamed('safeDump', 'dump')
-
-
-/***/ }),
-
-/***/ 1450:
-/***/ ((module) => {
-
-
-
-function isNothing (subject) {
- return (typeof subject === 'undefined') || (subject === null)
-}
-
-function isObject (subject) {
- return (typeof subject === 'object') && (subject !== null)
-}
-
-function toArray (sequence) {
- if (Array.isArray(sequence)) return sequence
- else if (isNothing(sequence)) return []
-
- return [sequence]
-}
-
-function extend (target, source) {
- if (source) {
- const sourceKeys = Object.keys(source)
-
- for (let index = 0, length = sourceKeys.length; index < length; index += 1) {
- const key = sourceKeys[index]
- target[key] = source[key]
- }
- }
-
- return target
-}
-
-function repeat (string, count) {
- let result = ''
-
- for (let cycle = 0; cycle < count; cycle += 1) {
- result += string
- }
-
- return result
-}
-
-function isNegativeZero (number) {
- return (number === 0) && (Number.NEGATIVE_INFINITY === 1 / number)
-}
-
-module.exports.isNothing = isNothing
-module.exports.isObject = isObject
-module.exports.toArray = toArray
-module.exports.repeat = repeat
-module.exports.isNegativeZero = isNegativeZero
-module.exports.extend = extend
-
-
-/***/ }),
-
-/***/ 5642:
-/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
-
-
-
-const common = __nccwpck_require__(1450)
-const YAMLException = __nccwpck_require__(3194)
-const DEFAULT_SCHEMA = __nccwpck_require__(914)
-
-const _toString = Object.prototype.toString
-const _hasOwnProperty = Object.prototype.hasOwnProperty
-
-const CHAR_BOM = 0xFEFF
-const CHAR_TAB = 0x09 /* Tab */
-const CHAR_LINE_FEED = 0x0A /* LF */
-const CHAR_CARRIAGE_RETURN = 0x0D /* CR */
-const CHAR_SPACE = 0x20 /* Space */
-const CHAR_EXCLAMATION = 0x21 /* ! */
-const CHAR_DOUBLE_QUOTE = 0x22 /* " */
-const CHAR_SHARP = 0x23 /* # */
-const CHAR_PERCENT = 0x25 /* % */
-const CHAR_AMPERSAND = 0x26 /* & */
-const CHAR_SINGLE_QUOTE = 0x27 /* ' */
-const CHAR_ASTERISK = 0x2A /* * */
-const CHAR_COMMA = 0x2C /* , */
-const CHAR_MINUS = 0x2D /* - */
-const CHAR_COLON = 0x3A /* : */
-const CHAR_EQUALS = 0x3D /* = */
-const CHAR_GREATER_THAN = 0x3E /* > */
-const CHAR_QUESTION = 0x3F /* ? */
-const CHAR_COMMERCIAL_AT = 0x40 /* @ */
-const CHAR_LEFT_SQUARE_BRACKET = 0x5B /* [ */
-const CHAR_RIGHT_SQUARE_BRACKET = 0x5D /* ] */
-const CHAR_GRAVE_ACCENT = 0x60 /* ` */
-const CHAR_LEFT_CURLY_BRACKET = 0x7B /* { */
-const CHAR_VERTICAL_LINE = 0x7C /* | */
-const CHAR_RIGHT_CURLY_BRACKET = 0x7D /* } */
-
-const ESCAPE_SEQUENCES = {}
-
-ESCAPE_SEQUENCES[0x00] = '\\0'
-ESCAPE_SEQUENCES[0x07] = '\\a'
-ESCAPE_SEQUENCES[0x08] = '\\b'
-ESCAPE_SEQUENCES[0x09] = '\\t'
-ESCAPE_SEQUENCES[0x0A] = '\\n'
-ESCAPE_SEQUENCES[0x0B] = '\\v'
-ESCAPE_SEQUENCES[0x0C] = '\\f'
-ESCAPE_SEQUENCES[0x0D] = '\\r'
-ESCAPE_SEQUENCES[0x1B] = '\\e'
-ESCAPE_SEQUENCES[0x22] = '\\"'
-ESCAPE_SEQUENCES[0x5C] = '\\\\'
-ESCAPE_SEQUENCES[0x85] = '\\N'
-ESCAPE_SEQUENCES[0xA0] = '\\_'
-ESCAPE_SEQUENCES[0x2028] = '\\L'
-ESCAPE_SEQUENCES[0x2029] = '\\P'
-
-const DEPRECATED_BOOLEANS_SYNTAX = [
- 'y', 'Y', 'yes', 'Yes', 'YES', 'on', 'On', 'ON',
- 'n', 'N', 'no', 'No', 'NO', 'off', 'Off', 'OFF'
-]
-
-const DEPRECATED_BASE60_SYNTAX = /^[-+]?[0-9_]+(?::[0-9_]+)+(?:\.[0-9_]*)?$/
-
-function compileStyleMap (schema, map) {
- if (map === null) return {}
-
- const result = {}
- const keys = Object.keys(map)
-
- for (let index = 0, length = keys.length; index < length; index += 1) {
- let tag = keys[index]
- let style = String(map[tag])
-
- if (tag.slice(0, 2) === '!!') {
- tag = 'tag:yaml.org,2002:' + tag.slice(2)
- }
- const type = schema.compiledTypeMap['fallback'][tag]
-
- if (type && _hasOwnProperty.call(type.styleAliases, style)) {
- style = type.styleAliases[style]
- }
-
- result[tag] = style
- }
-
- return result
-}
-
-function encodeHex (character) {
- let handle
- let length
-
- const string = character.toString(16).toUpperCase()
-
- if (character <= 0xFF) {
- handle = 'x'
- length = 2
- } else if (character <= 0xFFFF) {
- handle = 'u'
- length = 4
- } else if (character <= 0xFFFFFFFF) {
- handle = 'U'
- length = 8
- } else {
- throw new YAMLException('code point within a string may not be greater than 0xFFFFFFFF')
- }
-
- return '\\' + handle + common.repeat('0', length - string.length) + string
-}
-
-const QUOTING_TYPE_SINGLE = 1
-const QUOTING_TYPE_DOUBLE = 2
-
-function State (options) {
- this.schema = options['schema'] || DEFAULT_SCHEMA
- this.indent = Math.max(1, (options['indent'] || 2))
- this.noArrayIndent = options['noArrayIndent'] || false
- this.skipInvalid = options['skipInvalid'] || false
- this.flowLevel = (common.isNothing(options['flowLevel']) ? -1 : options['flowLevel'])
- this.styleMap = compileStyleMap(this.schema, options['styles'] || null)
- this.sortKeys = options['sortKeys'] || false
- this.lineWidth = options['lineWidth'] || 80
- this.noRefs = options['noRefs'] || false
- this.noCompatMode = options['noCompatMode'] || false
- this.condenseFlow = options['condenseFlow'] || false
- this.quotingType = options['quotingType'] === '"' ? QUOTING_TYPE_DOUBLE : QUOTING_TYPE_SINGLE
- this.forceQuotes = options['forceQuotes'] || false
- this.replacer = typeof options['replacer'] === 'function' ? options['replacer'] : null
-
- this.implicitTypes = this.schema.compiledImplicit
- this.explicitTypes = this.schema.compiledExplicit
-
- this.tag = null
- this.result = ''
-
- this.duplicates = []
- this.usedDuplicates = null
-}
-
-// Indents every line in a string. Empty lines (\n only) are not indented.
-function indentString (string, spaces) {
- const ind = common.repeat(' ', spaces)
- let position = 0
- let result = ''
- const length = string.length
-
- while (position < length) {
- let line
- const next = string.indexOf('\n', position)
- if (next === -1) {
- line = string.slice(position)
- position = length
- } else {
- line = string.slice(position, next + 1)
- position = next + 1
- }
-
- if (line.length && line !== '\n') result += ind
-
- result += line
- }
-
- return result
-}
-
-function generateNextLine (state, level) {
- return '\n' + common.repeat(' ', state.indent * level)
-}
-
-function testImplicitResolving (state, str) {
- for (let index = 0, length = state.implicitTypes.length; index < length; index += 1) {
- const type = state.implicitTypes[index]
-
- if (type.resolve(str)) {
- return true
- }
- }
-
- return false
-}
-
-// [33] s-white ::= s-space | s-tab
-function isWhitespace (c) {
- return c === CHAR_SPACE || c === CHAR_TAB
-}
-
-// Returns true if the character can be printed without escaping.
-// From YAML 1.2: "any allowed characters known to be non-printable
-// should also be escaped. [However,] This isn’t mandatory"
-// Derived from nb-char - \t - #x85 - #xA0 - #x2028 - #x2029.
-function isPrintable (c) {
- return (c >= 0x00020 && c <= 0x00007E) ||
- ((c >= 0x000A1 && c <= 0x00D7FF) && c !== 0x2028 && c !== 0x2029) ||
- ((c >= 0x0E000 && c <= 0x00FFFD) && c !== CHAR_BOM) ||
- (c >= 0x10000 && c <= 0x10FFFF)
-}
-
-// [34] ns-char ::= nb-char - s-white
-// [27] nb-char ::= c-printable - b-char - c-byte-order-mark
-// [26] b-char ::= b-line-feed | b-carriage-return
-// Including s-white (for some reason, examples doesn't match specs in this aspect)
-// ns-char ::= c-printable - b-line-feed - b-carriage-return - c-byte-order-mark
-function isNsCharOrWhitespace (c) {
- return isPrintable(c) &&
- c !== CHAR_BOM &&
- // - b-char
- c !== CHAR_CARRIAGE_RETURN &&
- c !== CHAR_LINE_FEED
-}
-
-// [127] ns-plain-safe(c) ::= c = flow-out ⇒ ns-plain-safe-out
-// c = flow-in ⇒ ns-plain-safe-in
-// c = block-key ⇒ ns-plain-safe-out
-// c = flow-key ⇒ ns-plain-safe-in
-// [128] ns-plain-safe-out ::= ns-char
-// [129] ns-plain-safe-in ::= ns-char - c-flow-indicator
-// [130] ns-plain-char(c) ::= ( ns-plain-safe(c) - “:” - “#” )
-// | ( /* An ns-char preceding */ “#” )
-// | ( “:” /* Followed by an ns-plain-safe(c) */ )
-function isPlainSafe (c, prev, inblock) {
- const cIsNsCharOrWhitespace = isNsCharOrWhitespace(c)
- const cIsNsChar = cIsNsCharOrWhitespace && !isWhitespace(c)
- return (
- (
- // ns-plain-safe
- inblock // c = flow-in
- ? cIsNsCharOrWhitespace
- : cIsNsCharOrWhitespace &&
- // - c-flow-indicator
- c !== CHAR_COMMA &&
- c !== CHAR_LEFT_SQUARE_BRACKET &&
- c !== CHAR_RIGHT_SQUARE_BRACKET &&
- c !== CHAR_LEFT_CURLY_BRACKET &&
- c !== CHAR_RIGHT_CURLY_BRACKET
- ) &&
- // ns-plain-char
- c !== CHAR_SHARP && // false on '#'
- !(prev === CHAR_COLON && !cIsNsChar)
- ) || // false on ': '
- (isNsCharOrWhitespace(prev) && !isWhitespace(prev) && c === CHAR_SHARP) || // change to true on '[^ ]#'
- (prev === CHAR_COLON && cIsNsChar) // change to true on ':[^ ]'
-}
-
-// Simplified test for values allowed as the first character in plain style.
-function isPlainSafeFirst (c) {
- // Uses a subset of ns-char - c-indicator
- // where ns-char = nb-char - s-white.
- // No support of ( ( “?” | “:” | “-” ) /* Followed by an ns-plain-safe(c)) */ ) part
- return isPrintable(c) &&
- c !== CHAR_BOM &&
- !isWhitespace(c) && // - s-white
- // - (c-indicator ::=
- // “-” | “?” | “:” | “,” | “[” | “]” | “{” | “}”
- c !== CHAR_MINUS &&
- c !== CHAR_QUESTION &&
- c !== CHAR_COLON &&
- c !== CHAR_COMMA &&
- c !== CHAR_LEFT_SQUARE_BRACKET &&
- c !== CHAR_RIGHT_SQUARE_BRACKET &&
- c !== CHAR_LEFT_CURLY_BRACKET &&
- c !== CHAR_RIGHT_CURLY_BRACKET &&
- // | “#” | “&” | “*” | “!” | “|” | “=” | “>” | “'” | “"”
- c !== CHAR_SHARP &&
- c !== CHAR_AMPERSAND &&
- c !== CHAR_ASTERISK &&
- c !== CHAR_EXCLAMATION &&
- c !== CHAR_VERTICAL_LINE &&
- c !== CHAR_EQUALS &&
- c !== CHAR_GREATER_THAN &&
- c !== CHAR_SINGLE_QUOTE &&
- c !== CHAR_DOUBLE_QUOTE &&
- // | “%” | “@” | “`”)
- c !== CHAR_PERCENT &&
- c !== CHAR_COMMERCIAL_AT &&
- c !== CHAR_GRAVE_ACCENT
-}
-
-// Simplified test for values allowed as the last character in plain style.
-function isPlainSafeLast (c) {
- // just not whitespace or colon, it will be checked to be plain character later
- return !isWhitespace(c) && c !== CHAR_COLON
-}
-
-// Same as 'string'.codePointAt(pos), but works in older browsers.
-function codePointAt (string, pos) {
- const first = string.charCodeAt(pos)
- let second
-
- if (first >= 0xD800 && first <= 0xDBFF && pos + 1 < string.length) {
- second = string.charCodeAt(pos + 1)
- if (second >= 0xDC00 && second <= 0xDFFF) {
- // https://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae
- return (first - 0xD800) * 0x400 + second - 0xDC00 + 0x10000
- }
- }
- return first
-}
-
-// Determines whether block indentation indicator is required.
-function needIndentIndicator (string) {
- const leadingSpaceRe = /^\n* /
- return leadingSpaceRe.test(string)
-}
-
-const STYLE_PLAIN = 1
-const STYLE_SINGLE = 2
-const STYLE_LITERAL = 3
-const STYLE_FOLDED = 4
-const STYLE_DOUBLE = 5
-
-// Determines which scalar styles are possible and returns the preferred style.
-// lineWidth = -1 => no limit.
-// Pre-conditions: str.length > 0.
-// Post-conditions:
-// STYLE_PLAIN or STYLE_SINGLE => no \n are in the string.
-// STYLE_LITERAL => no lines are suitable for folding (or lineWidth is -1).
-// STYLE_FOLDED => a line > lineWidth and can be folded (and lineWidth != -1).
-function chooseScalarStyle (string, singleLineOnly, indentPerLevel, lineWidth,
- testAmbiguousType, quotingType, forceQuotes, inblock) {
- let i
- let char = 0
- let prevChar = null
- let hasLineBreak = false
- let hasFoldableLine = false // only checked if shouldTrackWidth
- const shouldTrackWidth = lineWidth !== -1
- let previousLineBreak = -1 // count the first line correctly
- let plain = isPlainSafeFirst(codePointAt(string, 0)) &&
- isPlainSafeLast(codePointAt(string, string.length - 1))
-
- if (singleLineOnly || forceQuotes) {
- // Case: no block styles.
- // Check for disallowed characters to rule out plain and single.
- for (i = 0; i < string.length; char >= 0x10000 ? i += 2 : i++) {
- char = codePointAt(string, i)
- if (!isPrintable(char)) {
- return STYLE_DOUBLE
- }
- plain = plain && isPlainSafe(char, prevChar, inblock)
- prevChar = char
- }
- } else {
- // Case: block styles permitted.
- for (i = 0; i < string.length; char >= 0x10000 ? i += 2 : i++) {
- char = codePointAt(string, i)
- if (char === CHAR_LINE_FEED) {
- hasLineBreak = true
- // Check if any line can be folded.
- if (shouldTrackWidth) {
- hasFoldableLine = hasFoldableLine ||
- // Foldable line = too long, and not more-indented.
- (i - previousLineBreak - 1 > lineWidth &&
- string[previousLineBreak + 1] !== ' ')
- previousLineBreak = i
- }
- } else if (!isPrintable(char)) {
- return STYLE_DOUBLE
- }
- plain = plain && isPlainSafe(char, prevChar, inblock)
- prevChar = char
- }
- // in case the end is missing a \n
- hasFoldableLine = hasFoldableLine || (shouldTrackWidth &&
- (i - previousLineBreak - 1 > lineWidth &&
- string[previousLineBreak + 1] !== ' '))
- }
- // Although every style can represent \n without escaping, prefer block styles
- // for multiline, since they're more readable and they don't add empty lines.
- // Also prefer folding a super-long line.
- if (!hasLineBreak && !hasFoldableLine) {
- // Strings interpretable as another type have to be quoted;
- // e.g. the string 'true' vs. the boolean true.
- if (plain && !forceQuotes && !testAmbiguousType(string)) {
- return STYLE_PLAIN
- }
- return quotingType === QUOTING_TYPE_DOUBLE ? STYLE_DOUBLE : STYLE_SINGLE
- }
- // Edge case: block indentation indicator can only have one digit.
- if (indentPerLevel > 9 && needIndentIndicator(string)) {
- return STYLE_DOUBLE
- }
- // At this point we know block styles are valid.
- // Prefer literal style unless we want to fold.
- if (!forceQuotes) {
- return hasFoldableLine ? STYLE_FOLDED : STYLE_LITERAL
- }
- return quotingType === QUOTING_TYPE_DOUBLE ? STYLE_DOUBLE : STYLE_SINGLE
-}
-
-// Note: line breaking/folding is implemented for only the folded style.
-// NB. We drop the last trailing newline (if any) of a returned block scalar
-// since the dumper adds its own newline. This always works:
-// • No ending newline => unaffected; already using strip "-" chomping.
-// • Ending newline => removed then restored.
-// Importantly, this keeps the "+" chomp indicator from gaining an extra line.
-function writeScalar (state, string, level, iskey, inblock) {
- state.dump = (function () {
- if (string.length === 0) {
- return state.quotingType === QUOTING_TYPE_DOUBLE ? '""' : "''"
- }
- if (!state.noCompatMode) {
- if (DEPRECATED_BOOLEANS_SYNTAX.indexOf(string) !== -1 || DEPRECATED_BASE60_SYNTAX.test(string)) {
- return state.quotingType === QUOTING_TYPE_DOUBLE ? ('"' + string + '"') : ("'" + string + "'")
- }
- }
-
- const indent = state.indent * Math.max(1, level) // no 0-indent scalars
- // As indentation gets deeper, let the width decrease monotonically
- // to the lower bound min(state.lineWidth, 40).
- // Note that this implies
- // state.lineWidth ≤ 40 + state.indent: width is fixed at the lower bound.
- // state.lineWidth > 40 + state.indent: width decreases until the lower bound.
- // This behaves better than a constant minimum width which disallows narrower options,
- // or an indent threshold which causes the width to suddenly increase.
- const lineWidth = (state.lineWidth === -1)
- ? -1
- : Math.max(Math.min(state.lineWidth, 40), state.lineWidth - indent)
-
- // Without knowing if keys are implicit/explicit, assume implicit for safety.
- const singleLineOnly = iskey ||
- // No block styles in flow mode.
- (state.flowLevel > -1 && level >= state.flowLevel)
- function testAmbiguity (string) {
- return testImplicitResolving(state, string)
- }
-
- switch (chooseScalarStyle(string, singleLineOnly, state.indent, lineWidth,
- testAmbiguity, state.quotingType, state.forceQuotes && !iskey, inblock)) {
- case STYLE_PLAIN:
- return string
- case STYLE_SINGLE:
- return "'" + string.replace(/'/g, "''") + "'"
- case STYLE_LITERAL:
- return '|' + blockHeader(string, state.indent) +
- dropEndingNewline(indentString(string, indent))
- case STYLE_FOLDED:
- return '>' + blockHeader(string, state.indent) +
- dropEndingNewline(indentString(foldString(string, lineWidth), indent))
- case STYLE_DOUBLE:
- return '"' + escapeString(string, lineWidth) + '"'
- default:
- throw new YAMLException('impossible error: invalid scalar style')
- }
- }())
-}
-
-// Pre-conditions: string is valid for a block scalar, 1 <= indentPerLevel <= 9.
-function blockHeader (string, indentPerLevel) {
- const indentIndicator = needIndentIndicator(string) ? String(indentPerLevel) : ''
-
- // note the special case: the string '\n' counts as a "trailing" empty line.
- const clip = string[string.length - 1] === '\n'
- const keep = clip && (string[string.length - 2] === '\n' || string === '\n')
- const chomp = keep ? '+' : (clip ? '' : '-')
-
- return indentIndicator + chomp + '\n'
-}
-
-// (See the note for writeScalar.)
-function dropEndingNewline (string) {
- return string[string.length - 1] === '\n' ? string.slice(0, -1) : string
-}
-
-// Note: a long line without a suitable break point will exceed the width limit.
-// Pre-conditions: every char in str isPrintable, str.length > 0, width > 0.
-function foldString (string, width) {
- // In folded style, $k$ consecutive newlines output as $k+1$ newlines—
- // unless they're before or after a more-indented line, or at the very
- // beginning or end, in which case $k$ maps to $k$.
- // Therefore, parse each chunk as newline(s) followed by a content line.
- const lineRe = /(\n+)([^\n]*)/g
-
- // first line (possibly an empty line)
- let result = (function () {
- let nextLF = string.indexOf('\n')
- nextLF = nextLF !== -1 ? nextLF : string.length
- lineRe.lastIndex = nextLF
- return foldLine(string.slice(0, nextLF), width)
- }())
- // If we haven't reached the first content line yet, don't add an extra \n.
- let prevMoreIndented = string[0] === '\n' || string[0] === ' '
- let moreIndented
-
- // rest of the lines
- let match
- while ((match = lineRe.exec(string))) {
- const prefix = match[1]
- const line = match[2]
-
- moreIndented = (line[0] === ' ')
- result += prefix +
- ((!prevMoreIndented && !moreIndented && line !== '') ? '\n' : '') +
- foldLine(line, width)
- prevMoreIndented = moreIndented
- }
-
- return result
-}
-
-// Greedy line breaking.
-// Picks the longest line under the limit each time,
-// otherwise settles for the shortest line over the limit.
-// NB. More-indented lines *cannot* be folded, as that would add an extra \n.
-function foldLine (line, width) {
- if (line === '' || line[0] === ' ') return line
-
- // Since a more-indented line adds a \n, breaks can't be followed by a space.
- const breakRe = / [^ ]/g // note: the match index will always be <= length-2.
- let match
- // start is an inclusive index. end, curr, and next are exclusive.
- let start = 0
- let end
- let curr = 0
- let next = 0
- let result = ''
-
- // Invariants: 0 <= start <= length-1.
- // 0 <= curr <= next <= max(0, length-2). curr - start <= width.
- // Inside the loop:
- // A match implies length >= 2, so curr and next are <= length-2.
- while ((match = breakRe.exec(line))) {
- next = match.index
- // maintain invariant: curr - start <= width
- if (next - start > width) {
- end = (curr > start) ? curr : next // derive end <= length-2
- result += '\n' + line.slice(start, end)
- // skip the space that was output as \n
- start = end + 1 // derive start <= length-1
- }
- curr = next
- }
-
- // By the invariants, start <= length-1, so there is something left over.
- // It is either the whole string or a part starting from non-whitespace.
- result += '\n'
- // Insert a break if the remainder is too long and there is a break available.
- if (line.length - start > width && curr > start) {
- result += line.slice(start, curr) + '\n' + line.slice(curr + 1)
- } else {
- result += line.slice(start)
- }
-
- return result.slice(1) // drop extra \n joiner
-}
-
-// Escapes a double-quoted string.
-function escapeString (string) {
- let result = ''
- let char = 0
-
- for (let i = 0; i < string.length; char >= 0x10000 ? i += 2 : i++) {
- char = codePointAt(string, i)
- const escapeSeq = ESCAPE_SEQUENCES[char]
-
- if (!escapeSeq && isPrintable(char)) {
- result += string[i]
- if (char >= 0x10000) result += string[i + 1]
- } else {
- result += escapeSeq || encodeHex(char)
- }
- }
-
- return result
-}
-
-function writeFlowSequence (state, level, object) {
- let _result = ''
- const _tag = state.tag
-
- for (let index = 0, length = object.length; index < length; index += 1) {
- let value = object[index]
-
- if (state.replacer) {
- value = state.replacer.call(object, String(index), value)
- }
-
- // Write only valid elements, put null instead of invalid elements.
- if (writeNode(state, level, value, false, false) ||
- (typeof value === 'undefined' &&
- writeNode(state, level, null, false, false))) {
- if (_result !== '') _result += ',' + (!state.condenseFlow ? ' ' : '')
- _result += state.dump
- }
- }
-
- state.tag = _tag
- state.dump = '[' + _result + ']'
-}
-
-function writeBlockSequence (state, level, object, compact) {
- let _result = ''
- const _tag = state.tag
-
- for (let index = 0, length = object.length; index < length; index += 1) {
- let value = object[index]
-
- if (state.replacer) {
- value = state.replacer.call(object, String(index), value)
- }
-
- // Write only valid elements, put null instead of invalid elements.
- if (writeNode(state, level + 1, value, true, true, false, true) ||
- (typeof value === 'undefined' &&
- writeNode(state, level + 1, null, true, true, false, true))) {
- if (!compact || _result !== '') {
- _result += generateNextLine(state, level)
- }
-
- if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) {
- _result += '-'
- } else {
- _result += '- '
- }
-
- _result += state.dump
- }
- }
-
- state.tag = _tag
- state.dump = _result || '[]' // Empty sequence if no valid values.
-}
-
-function writeFlowMapping (state, level, object) {
- let _result = ''
- const _tag = state.tag
- const objectKeyList = Object.keys(object)
-
- for (let index = 0, length = objectKeyList.length; index < length; index += 1) {
- let pairBuffer = ''
- if (_result !== '') pairBuffer += ', '
-
- if (state.condenseFlow) pairBuffer += '"'
-
- const objectKey = objectKeyList[index]
- let objectValue = object[objectKey]
-
- if (state.replacer) {
- objectValue = state.replacer.call(object, objectKey, objectValue)
- }
-
- if (!writeNode(state, level, objectKey, false, false)) {
- continue // Skip this pair because of invalid key;
- }
-
- if (state.dump.length > 1024) pairBuffer += '? '
-
- pairBuffer += state.dump + (state.condenseFlow ? '"' : '') + ':' + (state.condenseFlow ? '' : ' ')
-
- if (!writeNode(state, level, objectValue, false, false)) {
- continue // Skip this pair because of invalid value.
- }
-
- pairBuffer += state.dump
-
- // Both key and value are valid.
- _result += pairBuffer
- }
-
- state.tag = _tag
- state.dump = '{' + _result + '}'
-}
-
-function writeBlockMapping (state, level, object, compact) {
- let _result = ''
- const _tag = state.tag
- const objectKeyList = Object.keys(object)
-
- // Allow sorting keys so that the output file is deterministic
- if (state.sortKeys === true) {
- // Default sorting
- objectKeyList.sort()
- } else if (typeof state.sortKeys === 'function') {
- // Custom sort function
- objectKeyList.sort(state.sortKeys)
- } else if (state.sortKeys) {
- // Something is wrong
- throw new YAMLException('sortKeys must be a boolean or a function')
- }
-
- for (let index = 0, length = objectKeyList.length; index < length; index += 1) {
- let pairBuffer = ''
-
- if (!compact || _result !== '') {
- pairBuffer += generateNextLine(state, level)
- }
-
- const objectKey = objectKeyList[index]
- let objectValue = object[objectKey]
-
- if (state.replacer) {
- objectValue = state.replacer.call(object, objectKey, objectValue)
- }
-
- if (!writeNode(state, level + 1, objectKey, true, true, true)) {
- continue // Skip this pair because of invalid key.
- }
-
- const explicitPair = (state.tag !== null && state.tag !== '?') ||
- (state.dump && state.dump.length > 1024)
-
- if (explicitPair) {
- if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) {
- pairBuffer += '?'
- } else {
- pairBuffer += '? '
- }
- }
-
- pairBuffer += state.dump
-
- if (explicitPair) {
- pairBuffer += generateNextLine(state, level)
- }
-
- if (!writeNode(state, level + 1, objectValue, true, explicitPair)) {
- continue // Skip this pair because of invalid value.
- }
-
- if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) {
- pairBuffer += ':'
- } else {
- pairBuffer += ': '
- }
-
- pairBuffer += state.dump
-
- // Both key and value are valid.
- _result += pairBuffer
- }
-
- state.tag = _tag
- state.dump = _result || '{}' // Empty mapping if no valid pairs.
-}
-
-function detectType (state, object, explicit) {
- const typeList = explicit ? state.explicitTypes : state.implicitTypes
-
- for (let index = 0, length = typeList.length; index < length; index += 1) {
- const type = typeList[index]
-
- if ((type.instanceOf || type.predicate) &&
- (!type.instanceOf || ((typeof object === 'object') && (object instanceof type.instanceOf))) &&
- (!type.predicate || type.predicate(object))) {
- if (explicit) {
- if (type.multi && type.representName) {
- state.tag = type.representName(object)
- } else {
- state.tag = type.tag
- }
- } else {
- state.tag = '?'
- }
-
- if (type.represent) {
- const style = state.styleMap[type.tag] || type.defaultStyle
-
- let _result
- if (_toString.call(type.represent) === '[object Function]') {
- _result = type.represent(object, style)
- } else if (_hasOwnProperty.call(type.represent, style)) {
- _result = type.represent[style](object, style)
- } else {
- throw new YAMLException('!<' + type.tag + '> tag resolver accepts not "' + style + '" style')
- }
-
- state.dump = _result
- }
-
- return true
- }
- }
-
- return false
-}
-
-// Serializes `object` and writes it to global `result`.
-// Returns true on success, or false on invalid object.
-//
-function writeNode (state, level, object, block, compact, iskey, isblockseq) {
- state.tag = null
- state.dump = object
-
- if (!detectType(state, object, false)) {
- detectType(state, object, true)
- }
-
- const type = _toString.call(state.dump)
- const inblock = block
-
- if (block) {
- block = (state.flowLevel < 0 || state.flowLevel > level)
- }
-
- const objectOrArray = type === '[object Object]' || type === '[object Array]'
- let duplicateIndex
- let duplicate
-
- if (objectOrArray) {
- duplicateIndex = state.duplicates.indexOf(object)
- duplicate = duplicateIndex !== -1
- }
-
- if ((state.tag !== null && state.tag !== '?') || duplicate || (state.indent !== 2 && level > 0)) {
- compact = false
- }
-
- if (duplicate && state.usedDuplicates[duplicateIndex]) {
- state.dump = '*ref_' + duplicateIndex
- } else {
- if (objectOrArray && duplicate && !state.usedDuplicates[duplicateIndex]) {
- state.usedDuplicates[duplicateIndex] = true
- }
- if (type === '[object Object]') {
- if (block && (Object.keys(state.dump).length !== 0)) {
- writeBlockMapping(state, level, state.dump, compact)
- if (duplicate) {
- state.dump = '&ref_' + duplicateIndex + state.dump
- }
- } else {
- writeFlowMapping(state, level, state.dump)
- if (duplicate) {
- state.dump = '&ref_' + duplicateIndex + ' ' + state.dump
- }
- }
- } else if (type === '[object Array]') {
- if (block && (state.dump.length !== 0)) {
- if (state.noArrayIndent && !isblockseq && level > 0) {
- writeBlockSequence(state, level - 1, state.dump, compact)
- } else {
- writeBlockSequence(state, level, state.dump, compact)
- }
- if (duplicate) {
- state.dump = '&ref_' + duplicateIndex + state.dump
- }
- } else {
- writeFlowSequence(state, level, state.dump)
- if (duplicate) {
- state.dump = '&ref_' + duplicateIndex + ' ' + state.dump
- }
- }
- } else if (type === '[object String]') {
- if (state.tag !== '?') {
- writeScalar(state, state.dump, level, iskey, inblock)
- }
- } else if (type === '[object Undefined]') {
- return false
- } else {
- if (state.skipInvalid) return false
- throw new YAMLException('unacceptable kind of an object to dump ' + type)
- }
-
- if (state.tag !== null && state.tag !== '?') {
- // Need to encode all characters except those allowed by the spec:
- //
- // [35] ns-dec-digit ::= [#x30-#x39] /* 0-9 */
- // [36] ns-hex-digit ::= ns-dec-digit
- // | [#x41-#x46] /* A-F */ | [#x61-#x66] /* a-f */
- // [37] ns-ascii-letter ::= [#x41-#x5A] /* A-Z */ | [#x61-#x7A] /* a-z */
- // [38] ns-word-char ::= ns-dec-digit | ns-ascii-letter | “-”
- // [39] ns-uri-char ::= “%” ns-hex-digit ns-hex-digit | ns-word-char | “#”
- // | “;” | “/” | “?” | “:” | “@” | “&” | “=” | “+” | “$” | “,”
- // | “_” | “.” | “!” | “~” | “*” | “'” | “(” | “)” | “[” | “]”
- //
- // Also need to encode '!' because it has special meaning (end of tag prefix).
- //
- let tagStr = encodeURI(
- state.tag[0] === '!' ? state.tag.slice(1) : state.tag
- ).replace(/!/g, '%21')
-
- if (state.tag[0] === '!') {
- tagStr = '!' + tagStr
- } else if (tagStr.slice(0, 18) === 'tag:yaml.org,2002:') {
- tagStr = '!!' + tagStr.slice(18)
- } else {
- tagStr = '!<' + tagStr + '>'
- }
-
- state.dump = tagStr + ' ' + state.dump
- }
- }
-
- return true
-}
-
-function getDuplicateReferences (object, state) {
- const objects = []
- const duplicatesIndexes = []
-
- inspectNode(object, objects, duplicatesIndexes)
-
- const length = duplicatesIndexes.length
- for (let index = 0; index < length; index += 1) {
- state.duplicates.push(objects[duplicatesIndexes[index]])
- }
- state.usedDuplicates = new Array(length)
-}
-
-function inspectNode (object, objects, duplicatesIndexes) {
- if (object !== null && typeof object === 'object') {
- const index = objects.indexOf(object)
- if (index !== -1) {
- if (duplicatesIndexes.indexOf(index) === -1) {
- duplicatesIndexes.push(index)
- }
- } else {
- objects.push(object)
-
- if (Array.isArray(object)) {
- for (let i = 0, length = object.length; i < length; i += 1) {
- inspectNode(object[i], objects, duplicatesIndexes)
- }
- } else {
- const objectKeyList = Object.keys(object)
-
- for (let i = 0, length = objectKeyList.length; i < length; i += 1) {
- inspectNode(object[objectKeyList[i]], objects, duplicatesIndexes)
- }
- }
- }
- }
-}
-
-function dump (input, options) {
- options = options || {}
-
- const state = new State(options)
-
- if (!state.noRefs) getDuplicateReferences(input, state)
-
- let value = input
-
- if (state.replacer) {
- value = state.replacer.call({ '': value }, '', value)
- }
-
- if (writeNode(state, 0, value, true, true)) return state.dump + '\n'
-
- return ''
-}
-
-module.exports.dump = dump
-
-
-/***/ }),
-
-/***/ 3194:
-/***/ ((module) => {
-
-// YAML error class. http://stackoverflow.com/questions/8458984
-//
-
-
-function formatError (exception, compact) {
- let where = ''
- const message = exception.reason || '(unknown reason)'
-
- if (!exception.mark) return message
-
- if (exception.mark.name) {
- where += 'in "' + exception.mark.name + '" '
- }
-
- where += '(' + (exception.mark.line + 1) + ':' + (exception.mark.column + 1) + ')'
-
- if (!compact && exception.mark.snippet) {
- where += '\n\n' + exception.mark.snippet
- }
-
- return message + ' ' + where
-}
-
-function YAMLException (reason, mark) {
- // Super constructor
- Error.call(this)
-
- this.name = 'YAMLException'
- this.reason = reason
- this.mark = mark
- this.message = formatError(this, false)
-
- // Include stack trace in error object
- if (Error.captureStackTrace) {
- // Chrome and NodeJS
- Error.captureStackTrace(this, this.constructor)
- } else {
- // FF, IE 10+ and Safari 6+. Fallback for others
- this.stack = (new Error()).stack || ''
- }
-}
-
-// Inherit from Error
-YAMLException.prototype = Object.create(Error.prototype)
-YAMLException.prototype.constructor = YAMLException
-
-YAMLException.prototype.toString = function toString (compact) {
- return this.name + ': ' + formatError(this, compact)
-}
-
-module.exports = YAMLException
-
-
-/***/ }),
-
-/***/ 7600:
-/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
-
-
-
-const common = __nccwpck_require__(1450)
-const YAMLException = __nccwpck_require__(3194)
-const makeSnippet = __nccwpck_require__(342)
-const DEFAULT_SCHEMA = __nccwpck_require__(914)
-
-const _hasOwnProperty = Object.prototype.hasOwnProperty
-
-const CONTEXT_FLOW_IN = 1
-const CONTEXT_FLOW_OUT = 2
-const CONTEXT_BLOCK_IN = 3
-const CONTEXT_BLOCK_OUT = 4
-
-const CHOMPING_CLIP = 1
-const CHOMPING_STRIP = 2
-const CHOMPING_KEEP = 3
-
-// eslint-disable-next-line no-control-regex
-const PATTERN_NON_PRINTABLE = /[\x00-\x08\x0B\x0C\x0E-\x1F\x7F-\x84\x86-\x9F\uFFFE\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/
-const PATTERN_NON_ASCII_LINE_BREAKS = /[\x85\u2028\u2029]/
-// eslint-disable-next-line no-useless-escape
-const PATTERN_FLOW_INDICATORS = /[,\[\]{}]/
-// eslint-disable-next-line no-useless-escape
-const PATTERN_TAG_HANDLE = /^(?:!|!!|![0-9A-Za-z-]+!)$/
-// eslint-disable-next-line no-useless-escape
-const PATTERN_TAG_URI = /^(?:!|[^,\[\]{}])(?:%[0-9a-f]{2}|[0-9a-z\-#;/?:@&=+$,_.!~*'()\[\]])*$/i
-
-function _class (obj) { return Object.prototype.toString.call(obj) }
-
-function isEol (c) {
- return (c === 0x0A/* LF */) || (c === 0x0D/* CR */)
-}
-
-function isWhiteSpace (c) {
- return (c === 0x09/* Tab */) || (c === 0x20/* Space */)
-}
-
-function isWsOrEol (c) {
- return (c === 0x09/* Tab */) ||
- (c === 0x20/* Space */) ||
- (c === 0x0A/* LF */) ||
- (c === 0x0D/* CR */)
-}
-
-function isFlowIndicator (c) {
- return c === 0x2C/* , */ ||
- c === 0x5B/* [ */ ||
- c === 0x5D/* ] */ ||
- c === 0x7B/* { */ ||
- c === 0x7D/* } */
-}
-
-function fromHexCode (c) {
- if ((c >= 0x30/* 0 */) && (c <= 0x39/* 9 */)) {
- return c - 0x30
- }
-
- const lc = c | 0x20
-
- if ((lc >= 0x61/* a */) && (lc <= 0x66/* f */)) {
- return lc - 0x61 + 10
- }
-
- return -1
-}
-
-function escapedHexLen (c) {
- if (c === 0x78/* x */) { return 2 }
- if (c === 0x75/* u */) { return 4 }
- if (c === 0x55/* U */) { return 8 }
- return 0
-}
-
-function fromDecimalCode (c) {
- if ((c >= 0x30/* 0 */) && (c <= 0x39/* 9 */)) {
- return c - 0x30
- }
-
- return -1
-}
-
-function simpleEscapeSequence (c) {
- switch (c) {
- case 0x30/* 0 */: return '\x00'
- case 0x61/* a */: return '\x07'
- case 0x62/* b */: return '\x08'
- case 0x74/* t */: return '\x09'
- case 0x09/* Tab */: return '\x09'
- case 0x6E/* n */: return '\x0A'
- case 0x76/* v */: return '\x0B'
- case 0x66/* f */: return '\x0C'
- case 0x72/* r */: return '\x0D'
- case 0x65/* e */: return '\x1B'
- case 0x20/* Space */: return ' '
- case 0x22/* " */: return '\x22'
- case 0x2F/* / */: return '/'
- case 0x5C/* \ */: return '\x5C'
- case 0x4E/* N */: return '\x85'
- case 0x5F/* _ */: return '\xA0'
- case 0x4C/* L */: return '\u2028'
- case 0x50/* P */: return '\u2029'
- default: return ''
- }
-}
-
-function charFromCodepoint (c) {
- if (c <= 0xFFFF) {
- return String.fromCharCode(c)
- }
- // Encode UTF-16 surrogate pair
- // https://en.wikipedia.org/wiki/UTF-16#Code_points_U.2B010000_to_U.2B10FFFF
- return String.fromCharCode(
- ((c - 0x010000) >> 10) + 0xD800,
- ((c - 0x010000) & 0x03FF) + 0xDC00
- )
-}
-
-// set a property of a literal object, while protecting against prototype pollution,
-// see https://github.com/nodeca/js-yaml/issues/164 for more details
-function setProperty (object, key, value) {
- // used for this specific key only because Object.defineProperty is slow
- if (key === '__proto__') {
- Object.defineProperty(object, key, {
- configurable: true,
- enumerable: true,
- writable: true,
- value: value
- })
- } else {
- object[key] = value
- }
-}
-
-const simpleEscapeCheck = new Array(256) // integer, for fast access
-const simpleEscapeMap = new Array(256)
-for (let i = 0; i < 256; i++) {
- simpleEscapeCheck[i] = simpleEscapeSequence(i) ? 1 : 0
- simpleEscapeMap[i] = simpleEscapeSequence(i)
-}
-
-function State (input, options) {
- this.input = input
-
- this.filename = options['filename'] || null
- this.schema = options['schema'] || DEFAULT_SCHEMA
- this.onWarning = options['onWarning'] || null
- // (Hidden) Remove? makes the loader to expect YAML 1.1 documents
- // if such documents have no explicit %YAML directive
- this.legacy = options['legacy'] || false
-
- this.json = options['json'] || false
- this.listener = options['listener'] || null
- this.maxDepth = typeof options['maxDepth'] === 'number' ? options['maxDepth'] : 100
- this.maxTotalMergeKeys = typeof options['maxTotalMergeKeys'] === 'number' ? options['maxTotalMergeKeys'] : 10000
-
- this.implicitTypes = this.schema.compiledImplicit
- this.typeMap = this.schema.compiledTypeMap
-
- this.length = input.length
- this.position = 0
- this.line = 0
- this.lineStart = 0
- this.lineIndent = 0
- this.depth = 0
- this.totalMergeKeys = 0
-
- // position of first leading tab in the current line,
- // used to make sure there are no tabs in the indentation
- this.firstTabInLine = -1
-
- this.documents = []
- this.anchorMapTransactions = []
-
- /*
- this.version;
- this.checkLineBreaks;
- this.tagMap;
- this.anchorMap;
- this.tag;
- this.anchor;
- this.kind;
- this.result; */
-}
-
-function generateError (state, message) {
- const mark = {
- name: state.filename,
- buffer: state.input.slice(0, -1), // omit trailing \0
- position: state.position,
- line: state.line,
- column: state.position - state.lineStart
- }
-
- mark.snippet = makeSnippet(mark)
-
- return new YAMLException(message, mark)
-}
-
-function throwError (state, message) {
- throw generateError(state, message)
-}
-
-function throwWarning (state, message) {
- if (state.onWarning) {
- state.onWarning.call(null, generateError(state, message))
- }
-}
-
-function storeAnchor (state, name, value) {
- const transactions = state.anchorMapTransactions
-
- if (transactions.length !== 0) {
- const transaction = transactions[transactions.length - 1]
-
- if (!_hasOwnProperty.call(transaction, name)) {
- transaction[name] = {
- existed: _hasOwnProperty.call(state.anchorMap, name),
- value: state.anchorMap[name]
- }
- }
- }
-
- state.anchorMap[name] = value
-}
-
-function beginAnchorTransaction (state) {
- state.anchorMapTransactions.push(Object.create(null))
-}
-
-function commitAnchorTransaction (state) {
- const transaction = state.anchorMapTransactions.pop()
- const transactions = state.anchorMapTransactions
-
- if (transactions.length === 0) return
-
- const parent = transactions[transactions.length - 1]
- const names = Object.keys(transaction)
-
- for (let index = 0, length = names.length; index < length; index += 1) {
- const name = names[index]
-
- if (!_hasOwnProperty.call(parent, name)) {
- parent[name] = transaction[name]
- }
- }
-}
-
-function rollbackAnchorTransaction (state) {
- const transaction = state.anchorMapTransactions.pop()
- const names = Object.keys(transaction)
-
- for (let index = names.length - 1; index >= 0; index -= 1) {
- const entry = transaction[names[index]]
-
- if (entry.existed) {
- state.anchorMap[names[index]] = entry.value
- } else {
- delete state.anchorMap[names[index]]
- }
- }
-}
-
-function snapshotState (state) {
- return {
- position: state.position,
- line: state.line,
- lineStart: state.lineStart,
- lineIndent: state.lineIndent,
- firstTabInLine: state.firstTabInLine,
- tag: state.tag,
- anchor: state.anchor,
- kind: state.kind,
- result: state.result
- }
-}
-
-function restoreState (state, snapshot) {
- state.position = snapshot.position
- state.line = snapshot.line
- state.lineStart = snapshot.lineStart
- state.lineIndent = snapshot.lineIndent
- state.firstTabInLine = snapshot.firstTabInLine
- state.tag = snapshot.tag
- state.anchor = snapshot.anchor
- state.kind = snapshot.kind
- state.result = snapshot.result
-}
-
-const directiveHandlers = {
-
- YAML: function handleYamlDirective (state, name, args) {
- if (state.version !== null) {
- throwError(state, 'duplication of %YAML directive')
- }
-
- if (args.length !== 1) {
- throwError(state, 'YAML directive accepts exactly one argument')
- }
-
- const match = /^([0-9]+)\.([0-9]+)$/.exec(args[0])
-
- if (match === null) {
- throwError(state, 'ill-formed argument of the YAML directive')
- }
-
- const major = parseInt(match[1], 10)
- const minor = parseInt(match[2], 10)
-
- if (major !== 1) {
- throwError(state, 'unacceptable YAML version of the document')
- }
-
- state.version = args[0]
- state.checkLineBreaks = (minor < 2)
-
- if (minor !== 1 && minor !== 2) {
- throwWarning(state, 'unsupported YAML version of the document')
- }
- },
-
- TAG: function handleTagDirective (state, name, args) {
- let prefix
-
- if (args.length !== 2) {
- throwError(state, 'TAG directive accepts exactly two arguments')
- }
-
- const handle = args[0]
- prefix = args[1]
-
- if (!PATTERN_TAG_HANDLE.test(handle)) {
- throwError(state, 'ill-formed tag handle (first argument) of the TAG directive')
- }
-
- if (_hasOwnProperty.call(state.tagMap, handle)) {
- throwError(state, 'there is a previously declared suffix for "' + handle + '" tag handle')
- }
-
- if (!PATTERN_TAG_URI.test(prefix)) {
- throwError(state, 'ill-formed tag prefix (second argument) of the TAG directive')
- }
-
- try {
- prefix = decodeURIComponent(prefix)
- } catch (err) {
- throwError(state, 'tag prefix is malformed: ' + prefix)
- }
-
- state.tagMap[handle] = prefix
- }
-}
-
-function captureSegment (state, start, end, checkJson) {
- if (start < end) {
- const _result = state.input.slice(start, end)
-
- if (checkJson) {
- for (let _position = 0, _length = _result.length; _position < _length; _position += 1) {
- const _character = _result.charCodeAt(_position)
- if (!(_character === 0x09 ||
- (_character >= 0x20 && _character <= 0x10FFFF))) {
- throwError(state, 'expected valid JSON character')
- }
- }
- } else if (PATTERN_NON_PRINTABLE.test(_result)) {
- throwError(state, 'the stream contains non-printable characters')
- }
-
- state.result += _result
- }
-}
-
-function mergeMappings (state, destination, source, overridableKeys) {
- if (!common.isObject(source)) {
- throwError(state, 'cannot merge mappings; the provided source object is unacceptable')
- }
-
- const sourceKeys = Object.keys(source)
-
- for (let index = 0, quantity = sourceKeys.length; index < quantity; index += 1) {
- const key = sourceKeys[index]
-
- if (state.maxTotalMergeKeys !== -1 && ++state.totalMergeKeys > state.maxTotalMergeKeys) {
- throwError(state, 'merge keys exceeded maxTotalMergeKeys (' + state.maxTotalMergeKeys + ')')
- }
-
- if (!_hasOwnProperty.call(destination, key)) {
- setProperty(destination, key, source[key])
- overridableKeys[key] = true
- }
- }
-}
-
-function storeMappingPair (state, _result, overridableKeys, keyTag, keyNode, valueNode,
- startLine, startLineStart, startPos) {
- // The output is a plain object here, so keys can only be strings.
- // We need to convert keyNode to a string, but doing so can hang the process
- // (deeply nested arrays that explode exponentially using aliases).
- if (Array.isArray(keyNode)) {
- keyNode = Array.prototype.slice.call(keyNode)
-
- for (let index = 0, quantity = keyNode.length; index < quantity; index += 1) {
- if (Array.isArray(keyNode[index])) {
- throwError(state, 'nested arrays are not supported inside keys')
- }
-
- if (typeof keyNode === 'object' && _class(keyNode[index]) === '[object Object]') {
- keyNode[index] = '[object Object]'
- }
- }
- }
-
- // Avoid code execution in load() via toString property
- // (still use its own toString for arrays, timestamps,
- // and whatever user schema extensions happen to have @@toStringTag)
- if (typeof keyNode === 'object' && _class(keyNode) === '[object Object]') {
- keyNode = '[object Object]'
- }
-
- keyNode = String(keyNode)
-
- if (_result === null) {
- _result = {}
- }
-
- if (keyTag === 'tag:yaml.org,2002:merge') {
- if (Array.isArray(valueNode)) {
- for (let index = 0, quantity = valueNode.length; index < quantity; index += 1) {
- mergeMappings(state, _result, valueNode[index], overridableKeys)
- }
- } else {
- mergeMappings(state, _result, valueNode, overridableKeys)
- }
- } else {
- if (!state.json &&
- !_hasOwnProperty.call(overridableKeys, keyNode) &&
- _hasOwnProperty.call(_result, keyNode)) {
- state.line = startLine || state.line
- state.lineStart = startLineStart || state.lineStart
- state.position = startPos || state.position
- throwError(state, 'duplicated mapping key')
- }
-
- setProperty(_result, keyNode, valueNode)
- delete overridableKeys[keyNode]
- }
-
- return _result
-}
-
-function readLineBreak (state) {
- const ch = state.input.charCodeAt(state.position)
-
- if (ch === 0x0A/* LF */) {
- state.position++
- } else if (ch === 0x0D/* CR */) {
- state.position++
- if (state.input.charCodeAt(state.position) === 0x0A/* LF */) {
- state.position++
- }
- } else {
- throwError(state, 'a line break is expected')
- }
-
- state.line += 1
- state.lineStart = state.position
- state.firstTabInLine = -1
-}
-
-function skipSeparationSpace (state, allowComments, checkIndent) {
- let lineBreaks = 0
- let ch = state.input.charCodeAt(state.position)
-
- while (ch !== 0) {
- while (isWhiteSpace(ch)) {
- if (ch === 0x09/* Tab */ && state.firstTabInLine === -1) {
- state.firstTabInLine = state.position
- }
- ch = state.input.charCodeAt(++state.position)
- }
-
- if (allowComments && ch === 0x23/* # */) {
- do {
- ch = state.input.charCodeAt(++state.position)
- } while (ch !== 0x0A/* LF */ && ch !== 0x0D/* CR */ && ch !== 0)
- }
-
- if (isEol(ch)) {
- readLineBreak(state)
-
- ch = state.input.charCodeAt(state.position)
- lineBreaks++
- state.lineIndent = 0
-
- while (ch === 0x20/* Space */) {
- state.lineIndent++
- ch = state.input.charCodeAt(++state.position)
- }
- } else {
- break
- }
- }
-
- if (checkIndent !== -1 && lineBreaks !== 0 && state.lineIndent < checkIndent) {
- throwWarning(state, 'deficient indentation')
- }
-
- return lineBreaks
-}
-
-function testDocumentSeparator (state) {
- let _position = state.position
- let ch = state.input.charCodeAt(_position)
-
- // Condition state.position === state.lineStart is tested
- // in parent on each call, for efficiency. No needs to test here again.
- if ((ch === 0x2D/* - */ || ch === 0x2E/* . */) &&
- ch === state.input.charCodeAt(_position + 1) &&
- ch === state.input.charCodeAt(_position + 2)) {
- _position += 3
-
- ch = state.input.charCodeAt(_position)
-
- if (ch === 0 || isWsOrEol(ch)) {
- return true
- }
- }
-
- return false
-}
-
-function writeFoldedLines (state, count) {
- if (count === 1) {
- state.result += ' '
- } else if (count > 1) {
- state.result += common.repeat('\n', count - 1)
- }
-}
-
-function readPlainScalar (state, nodeIndent, withinFlowCollection) {
- let captureStart
- let captureEnd
- let hasPendingContent
- let _line
- let _lineStart
- let _lineIndent
- const _kind = state.kind
- const _result = state.result
-
- let ch = state.input.charCodeAt(state.position)
-
- if (isWsOrEol(ch) ||
- isFlowIndicator(ch) ||
- ch === 0x23/* # */ ||
- ch === 0x26/* & */ ||
- ch === 0x2A/* * */ ||
- ch === 0x21/* ! */ ||
- ch === 0x7C/* | */ ||
- ch === 0x3E/* > */ ||
- ch === 0x27/* ' */ ||
- ch === 0x22/* " */ ||
- ch === 0x25/* % */ ||
- ch === 0x40/* @ */ ||
- ch === 0x60/* ` */) {
- return false
- }
-
- if (ch === 0x3F/* ? */ || ch === 0x2D/* - */) {
- const following = state.input.charCodeAt(state.position + 1)
-
- if (isWsOrEol(following) ||
- (withinFlowCollection && isFlowIndicator(following))) {
- return false
- }
- }
-
- state.kind = 'scalar'
- state.result = ''
- captureStart = captureEnd = state.position
- hasPendingContent = false
-
- while (ch !== 0) {
- if (ch === 0x3A/* : */) {
- const following = state.input.charCodeAt(state.position + 1)
-
- if (isWsOrEol(following) ||
- (withinFlowCollection && isFlowIndicator(following))) {
- break
- }
- } else if (ch === 0x23/* # */) {
- const preceding = state.input.charCodeAt(state.position - 1)
-
- if (isWsOrEol(preceding)) {
- break
- }
- } else if ((state.position === state.lineStart && testDocumentSeparator(state)) ||
- (withinFlowCollection && isFlowIndicator(ch))) {
- break
- } else if (isEol(ch)) {
- _line = state.line
- _lineStart = state.lineStart
- _lineIndent = state.lineIndent
- skipSeparationSpace(state, false, -1)
-
- if (state.lineIndent >= nodeIndent) {
- hasPendingContent = true
- ch = state.input.charCodeAt(state.position)
- continue
- } else {
- state.position = captureEnd
- state.line = _line
- state.lineStart = _lineStart
- state.lineIndent = _lineIndent
- break
- }
- }
-
- if (hasPendingContent) {
- captureSegment(state, captureStart, captureEnd, false)
- writeFoldedLines(state, state.line - _line)
- captureStart = captureEnd = state.position
- hasPendingContent = false
- }
-
- if (!isWhiteSpace(ch)) {
- captureEnd = state.position + 1
- }
-
- ch = state.input.charCodeAt(++state.position)
- }
-
- captureSegment(state, captureStart, captureEnd, false)
-
- if (state.result) {
- return true
- }
-
- state.kind = _kind
- state.result = _result
- return false
-}
-
-function readSingleQuotedScalar (state, nodeIndent) {
- let captureStart
- let captureEnd
-
- let ch = state.input.charCodeAt(state.position)
-
- if (ch !== 0x27/* ' */) {
- return false
- }
-
- state.kind = 'scalar'
- state.result = ''
- state.position++
- captureStart = captureEnd = state.position
-
- while ((ch = state.input.charCodeAt(state.position)) !== 0) {
- if (ch === 0x27/* ' */) {
- captureSegment(state, captureStart, state.position, true)
- ch = state.input.charCodeAt(++state.position)
-
- if (ch === 0x27/* ' */) {
- captureStart = state.position
- state.position++
- captureEnd = state.position
- } else {
- return true
- }
- } else if (isEol(ch)) {
- captureSegment(state, captureStart, captureEnd, true)
- writeFoldedLines(state, skipSeparationSpace(state, false, nodeIndent))
- captureStart = captureEnd = state.position
- } else if (state.position === state.lineStart && testDocumentSeparator(state)) {
- throwError(state, 'unexpected end of the document within a single quoted scalar')
- } else {
- state.position++
- if (!isWhiteSpace(ch)) {
- captureEnd = state.position
- }
- }
- }
-
- throwError(state, 'unexpected end of the stream within a single quoted scalar')
-}
-
-function readDoubleQuotedScalar (state, nodeIndent) {
- let captureStart
- let captureEnd
- let tmp
-
- let ch = state.input.charCodeAt(state.position)
-
- if (ch !== 0x22/* " */) {
- return false
- }
-
- state.kind = 'scalar'
- state.result = ''
- state.position++
- captureStart = captureEnd = state.position
-
- while ((ch = state.input.charCodeAt(state.position)) !== 0) {
- if (ch === 0x22/* " */) {
- captureSegment(state, captureStart, state.position, true)
- state.position++
- return true
- } else if (ch === 0x5C/* \ */) {
- captureSegment(state, captureStart, state.position, true)
- ch = state.input.charCodeAt(++state.position)
-
- if (isEol(ch)) {
- skipSeparationSpace(state, false, nodeIndent)
-
- // TODO: rework to inline fn with no type cast?
- } else if (ch < 256 && simpleEscapeCheck[ch]) {
- state.result += simpleEscapeMap[ch]
- state.position++
- } else if ((tmp = escapedHexLen(ch)) > 0) {
- let hexLength = tmp
- let hexResult = 0
-
- for (; hexLength > 0; hexLength--) {
- ch = state.input.charCodeAt(++state.position)
-
- if ((tmp = fromHexCode(ch)) >= 0) {
- hexResult = (hexResult << 4) + tmp
- } else {
- throwError(state, 'expected hexadecimal character')
- }
- }
-
- state.result += charFromCodepoint(hexResult)
-
- state.position++
- } else {
- throwError(state, 'unknown escape sequence')
- }
-
- captureStart = captureEnd = state.position
- } else if (isEol(ch)) {
- captureSegment(state, captureStart, captureEnd, true)
- writeFoldedLines(state, skipSeparationSpace(state, false, nodeIndent))
- captureStart = captureEnd = state.position
- } else if (state.position === state.lineStart && testDocumentSeparator(state)) {
- throwError(state, 'unexpected end of the document within a double quoted scalar')
- } else {
- state.position++
- if (!isWhiteSpace(ch)) {
- captureEnd = state.position
- }
- }
- }
-
- throwError(state, 'unexpected end of the stream within a double quoted scalar')
-}
-
-function readFlowCollection (state, nodeIndent) {
- let readNext = true
- let _line
- let _lineStart
- let _pos
- const _tag = state.tag
- let _result
- const _anchor = state.anchor
- let terminator
- let isPair
- let isExplicitPair
- let isMapping
- const overridableKeys = Object.create(null)
- let keyNode
- let keyTag
- let valueNode
-
- let ch = state.input.charCodeAt(state.position)
-
- if (ch === 0x5B/* [ */) {
- terminator = 0x5D/* ] */
- isMapping = false
- _result = []
- } else if (ch === 0x7B/* { */) {
- terminator = 0x7D/* } */
- isMapping = true
- _result = {}
- } else {
- return false
- }
-
- if (state.anchor !== null) {
- storeAnchor(state, state.anchor, _result)
- }
-
- ch = state.input.charCodeAt(++state.position)
-
- while (ch !== 0) {
- skipSeparationSpace(state, true, nodeIndent)
-
- ch = state.input.charCodeAt(state.position)
-
- if (ch === terminator) {
- state.position++
- state.tag = _tag
- state.anchor = _anchor
- state.kind = isMapping ? 'mapping' : 'sequence'
- state.result = _result
- return true
- } else if (!readNext) {
- throwError(state, 'missed comma between flow collection entries')
- } else if (ch === 0x2C/* , */) {
- // "flow collection entries can never be completely empty", as per YAML 1.2, section 7.4
- throwError(state, "expected the node content, but found ','")
- }
-
- keyTag = keyNode = valueNode = null
- isPair = isExplicitPair = false
-
- if (ch === 0x3F/* ? */) {
- const following = state.input.charCodeAt(state.position + 1)
-
- if (isWsOrEol(following)) {
- isPair = isExplicitPair = true
- state.position++
- skipSeparationSpace(state, true, nodeIndent)
- }
- }
-
- _line = state.line // Save the current line.
- _lineStart = state.lineStart
- _pos = state.position
- composeNode(state, nodeIndent, CONTEXT_FLOW_IN, false, true)
- keyTag = state.tag
- keyNode = state.result
- skipSeparationSpace(state, true, nodeIndent)
-
- ch = state.input.charCodeAt(state.position)
-
- if ((isExplicitPair || state.line === _line) && ch === 0x3A/* : */) {
- isPair = true
- ch = state.input.charCodeAt(++state.position)
- skipSeparationSpace(state, true, nodeIndent)
- composeNode(state, nodeIndent, CONTEXT_FLOW_IN, false, true)
- valueNode = state.result
- }
-
- if (isMapping) {
- storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode, _line, _lineStart, _pos)
- } else if (isPair) {
- _result.push(storeMappingPair(state, null, overridableKeys, keyTag, keyNode, valueNode, _line, _lineStart, _pos))
- } else {
- _result.push(keyNode)
- }
-
- skipSeparationSpace(state, true, nodeIndent)
-
- ch = state.input.charCodeAt(state.position)
-
- if (ch === 0x2C/* , */) {
- readNext = true
- ch = state.input.charCodeAt(++state.position)
- } else {
- readNext = false
- }
- }
-
- throwError(state, 'unexpected end of the stream within a flow collection')
-}
-
-function readBlockScalar (state, nodeIndent) {
- let folding
- let chomping = CHOMPING_CLIP
- let didReadContent = false
- let detectedIndent = false
- let textIndent = nodeIndent
- let emptyLines = 0
- let atMoreIndented = false
- let tmp
-
- let ch = state.input.charCodeAt(state.position)
-
- if (ch === 0x7C/* | */) {
- folding = false
- } else if (ch === 0x3E/* > */) {
- folding = true
- } else {
- return false
- }
-
- state.kind = 'scalar'
- state.result = ''
-
- while (ch !== 0) {
- ch = state.input.charCodeAt(++state.position)
-
- if (ch === 0x2B/* + */ || ch === 0x2D/* - */) {
- if (CHOMPING_CLIP === chomping) {
- chomping = (ch === 0x2B/* + */) ? CHOMPING_KEEP : CHOMPING_STRIP
- } else {
- throwError(state, 'repeat of a chomping mode identifier')
- }
- } else if ((tmp = fromDecimalCode(ch)) >= 0) {
- if (tmp === 0) {
- throwError(state, 'bad explicit indentation width of a block scalar; it cannot be less than one')
- } else if (!detectedIndent) {
- textIndent = nodeIndent + tmp - 1
- detectedIndent = true
- } else {
- throwError(state, 'repeat of an indentation width identifier')
- }
- } else {
- break
- }
- }
-
- if (isWhiteSpace(ch)) {
- do { ch = state.input.charCodeAt(++state.position) }
- while (isWhiteSpace(ch))
-
- if (ch === 0x23/* # */) {
- do { ch = state.input.charCodeAt(++state.position) }
- while (!isEol(ch) && (ch !== 0))
- }
- }
-
- while (ch !== 0) {
- readLineBreak(state)
- state.lineIndent = 0
-
- ch = state.input.charCodeAt(state.position)
-
- // eslint-disable-next-line no-unmodified-loop-condition
- while ((!detectedIndent || state.lineIndent < textIndent) &&
- (ch === 0x20/* Space */)) {
- state.lineIndent++
- ch = state.input.charCodeAt(++state.position)
- }
-
- if (!detectedIndent && state.lineIndent > textIndent) {
- textIndent = state.lineIndent
- }
-
- if (isEol(ch)) {
- emptyLines++
- continue
- }
-
- if (!detectedIndent && textIndent === 0) {
- throwError(state, 'missing indentation for block scalar')
- }
-
- // End of the scalar.
- if (state.lineIndent < textIndent) {
- // Perform the chomping.
- if (chomping === CHOMPING_KEEP) {
- state.result += common.repeat('\n', didReadContent ? 1 + emptyLines : emptyLines)
- } else if (chomping === CHOMPING_CLIP) {
- if (didReadContent) { // i.e. only if the scalar is not empty.
- state.result += '\n'
- }
- }
-
- // Break this `while` cycle and go to the funciton's epilogue.
- break
- }
-
- // Folded style: use fancy rules to handle line breaks.
- if (folding) {
- // Lines starting with white space characters (more-indented lines) are not folded.
- if (isWhiteSpace(ch)) {
- atMoreIndented = true
- // except for the first content line (cf. Example 8.1)
- state.result += common.repeat('\n', didReadContent ? 1 + emptyLines : emptyLines)
-
- // End of more-indented block.
- } else if (atMoreIndented) {
- atMoreIndented = false
- state.result += common.repeat('\n', emptyLines + 1)
-
- // Just one line break - perceive as the same line.
- } else if (emptyLines === 0) {
- if (didReadContent) { // i.e. only if we have already read some scalar content.
- state.result += ' '
- }
-
- // Several line breaks - perceive as different lines.
- } else {
- state.result += common.repeat('\n', emptyLines)
- }
-
- // Literal style: just add exact number of line breaks between content lines.
- } else {
- // Keep all line breaks except the header line break.
- state.result += common.repeat('\n', didReadContent ? 1 + emptyLines : emptyLines)
- }
-
- didReadContent = true
- detectedIndent = true
- emptyLines = 0
- const captureStart = state.position
-
- while (!isEol(ch) && (ch !== 0)) {
- ch = state.input.charCodeAt(++state.position)
- }
-
- captureSegment(state, captureStart, state.position, false)
- }
-
- return true
-}
-
-function readBlockSequence (state, nodeIndent) {
- const _tag = state.tag
- const _anchor = state.anchor
- const _result = []
- let detected = false
-
- // there is a leading tab before this token, so it can't be a block sequence/mapping;
- // it can still be flow sequence/mapping or a scalar
- if (state.firstTabInLine !== -1) return false
-
- if (state.anchor !== null) {
- storeAnchor(state, state.anchor, _result)
- }
-
- let ch = state.input.charCodeAt(state.position)
-
- while (ch !== 0) {
- if (state.firstTabInLine !== -1) {
- state.position = state.firstTabInLine
- throwError(state, 'tab characters must not be used in indentation')
- }
-
- if (ch !== 0x2D/* - */) {
- break
- }
-
- const following = state.input.charCodeAt(state.position + 1)
-
- if (!isWsOrEol(following)) {
- break
- }
-
- detected = true
- state.position++
-
- if (skipSeparationSpace(state, true, -1)) {
- if (state.lineIndent <= nodeIndent) {
- _result.push(null)
- ch = state.input.charCodeAt(state.position)
- continue
- }
- }
-
- const _line = state.line
- composeNode(state, nodeIndent, CONTEXT_BLOCK_IN, false, true)
- _result.push(state.result)
- skipSeparationSpace(state, true, -1)
-
- ch = state.input.charCodeAt(state.position)
-
- if ((state.line === _line || state.lineIndent > nodeIndent) && (ch !== 0)) {
- throwError(state, 'bad indentation of a sequence entry')
- } else if (state.lineIndent < nodeIndent) {
- break
- }
- }
-
- if (detected) {
- state.tag = _tag
- state.anchor = _anchor
- state.kind = 'sequence'
- state.result = _result
- return true
- }
- return false
-}
-
-function readBlockMapping (state, nodeIndent, flowIndent) {
- let allowCompact
- let _keyLine
- let _keyLineStart
- let _keyPos
- const _tag = state.tag
- const _anchor = state.anchor
- const _result = {}
- const overridableKeys = Object.create(null)
- let keyTag = null
- let keyNode = null
- let valueNode = null
- let atExplicitKey = false
- let detected = false
-
- // there is a leading tab before this token, so it can't be a block sequence/mapping;
- // it can still be flow sequence/mapping or a scalar
- if (state.firstTabInLine !== -1) return false
-
- if (state.anchor !== null) {
- storeAnchor(state, state.anchor, _result)
- }
-
- let ch = state.input.charCodeAt(state.position)
-
- while (ch !== 0) {
- if (!atExplicitKey && state.firstTabInLine !== -1) {
- state.position = state.firstTabInLine
- throwError(state, 'tab characters must not be used in indentation')
- }
-
- const following = state.input.charCodeAt(state.position + 1)
- const _line = state.line // Save the current line.
-
- //
- // Explicit notation case. There are two separate blocks:
- // first for the key (denoted by "?") and second for the value (denoted by ":")
- //
- if ((ch === 0x3F/* ? */ || ch === 0x3A/* : */) && isWsOrEol(following)) {
- if (ch === 0x3F/* ? */) {
- if (atExplicitKey) {
- storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null, _keyLine, _keyLineStart, _keyPos)
- keyTag = keyNode = valueNode = null
- }
-
- detected = true
- atExplicitKey = true
- allowCompact = true
- } else if (atExplicitKey) {
- // i.e. 0x3A/* : */ === character after the explicit key.
- atExplicitKey = false
- allowCompact = true
- } else {
- throwError(state, 'incomplete explicit mapping pair; a key node is missed; or followed by a non-tabulated empty line')
- }
-
- state.position += 1
- ch = following
-
- //
- // Implicit notation case. Flow-style node as the key first, then ":", and the value.
- //
- } else {
- _keyLine = state.line
- _keyLineStart = state.lineStart
- _keyPos = state.position
-
- if (!composeNode(state, flowIndent, CONTEXT_FLOW_OUT, false, true)) {
- // Neither implicit nor explicit notation.
- // Reading is done. Go to the epilogue.
- break
- }
-
- if (state.line === _line) {
- ch = state.input.charCodeAt(state.position)
-
- while (isWhiteSpace(ch)) {
- ch = state.input.charCodeAt(++state.position)
- }
-
- if (ch === 0x3A/* : */) {
- ch = state.input.charCodeAt(++state.position)
-
- if (!isWsOrEol(ch)) {
- throwError(state, 'a whitespace character is expected after the key-value separator within a block mapping')
- }
-
- if (atExplicitKey) {
- storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null, _keyLine, _keyLineStart, _keyPos)
- keyTag = keyNode = valueNode = null
- }
-
- detected = true
- atExplicitKey = false
- allowCompact = false
- keyTag = state.tag
- keyNode = state.result
- } else if (detected) {
- throwError(state, 'can not read an implicit mapping pair; a colon is missed')
- } else {
- state.tag = _tag
- state.anchor = _anchor
- return true // Keep the result of `composeNode`.
- }
- } else if (detected) {
- throwError(state, 'can not read a block mapping entry; a multiline key may not be an implicit key')
- } else {
- state.tag = _tag
- state.anchor = _anchor
- return true // Keep the result of `composeNode`.
- }
- }
-
- //
- // Common reading code for both explicit and implicit notations.
- //
- if (state.line === _line || state.lineIndent > nodeIndent) {
- if (atExplicitKey) {
- _keyLine = state.line
- _keyLineStart = state.lineStart
- _keyPos = state.position
- }
-
- if (composeNode(state, nodeIndent, CONTEXT_BLOCK_OUT, true, allowCompact)) {
- if (atExplicitKey) {
- keyNode = state.result
- } else {
- valueNode = state.result
- }
- }
-
- if (!atExplicitKey) {
- storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode, _keyLine, _keyLineStart, _keyPos)
- keyTag = keyNode = valueNode = null
- }
-
- skipSeparationSpace(state, true, -1)
- ch = state.input.charCodeAt(state.position)
- }
-
- if ((state.line === _line || state.lineIndent > nodeIndent) && (ch !== 0)) {
- throwError(state, 'bad indentation of a mapping entry')
- } else if (state.lineIndent < nodeIndent) {
- break
- }
- }
-
- //
- // Epilogue.
- //
-
- // Special case: last mapping's node contains only the key in explicit notation.
- if (atExplicitKey) {
- storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null, _keyLine, _keyLineStart, _keyPos)
- }
-
- // Expose the resulting mapping.
- if (detected) {
- state.tag = _tag
- state.anchor = _anchor
- state.kind = 'mapping'
- state.result = _result
- }
-
- return detected
-}
-
-function readTagProperty (state) {
- let isVerbatim = false
- let isNamed = false
- let tagHandle
- let tagName
-
- let ch = state.input.charCodeAt(state.position)
-
- if (ch !== 0x21/* ! */) return false
-
- if (state.tag !== null) {
- throwError(state, 'duplication of a tag property')
- }
-
- ch = state.input.charCodeAt(++state.position)
-
- if (ch === 0x3C/* < */) {
- isVerbatim = true
- ch = state.input.charCodeAt(++state.position)
- } else if (ch === 0x21/* ! */) {
- isNamed = true
- tagHandle = '!!'
- ch = state.input.charCodeAt(++state.position)
- } else {
- tagHandle = '!'
- }
-
- let _position = state.position
-
- if (isVerbatim) {
- do { ch = state.input.charCodeAt(++state.position) }
- while (ch !== 0 && ch !== 0x3E/* > */)
-
- if (state.position < state.length) {
- tagName = state.input.slice(_position, state.position)
- ch = state.input.charCodeAt(++state.position)
- } else {
- throwError(state, 'unexpected end of the stream within a verbatim tag')
- }
- } else {
- while (ch !== 0 && !isWsOrEol(ch)) {
- if (ch === 0x21/* ! */) {
- if (!isNamed) {
- tagHandle = state.input.slice(_position - 1, state.position + 1)
-
- if (!PATTERN_TAG_HANDLE.test(tagHandle)) {
- throwError(state, 'named tag handle cannot contain such characters')
- }
-
- isNamed = true
- _position = state.position + 1
- } else {
- throwError(state, 'tag suffix cannot contain exclamation marks')
- }
- }
-
- ch = state.input.charCodeAt(++state.position)
- }
-
- tagName = state.input.slice(_position, state.position)
-
- if (PATTERN_FLOW_INDICATORS.test(tagName)) {
- throwError(state, 'tag suffix cannot contain flow indicator characters')
- }
- }
-
- if (tagName && !PATTERN_TAG_URI.test(tagName)) {
- throwError(state, 'tag name cannot contain such characters: ' + tagName)
- }
-
- try {
- tagName = decodeURIComponent(tagName)
- } catch (err) {
- throwError(state, 'tag name is malformed: ' + tagName)
- }
-
- if (isVerbatim) {
- state.tag = tagName
- } else if (_hasOwnProperty.call(state.tagMap, tagHandle)) {
- state.tag = state.tagMap[tagHandle] + tagName
- } else if (tagHandle === '!') {
- state.tag = '!' + tagName
- } else if (tagHandle === '!!') {
- state.tag = 'tag:yaml.org,2002:' + tagName
- } else {
- throwError(state, 'undeclared tag handle "' + tagHandle + '"')
- }
-
- return true
-}
-
-function readAnchorProperty (state) {
- let ch = state.input.charCodeAt(state.position)
-
- if (ch !== 0x26/* & */) return false
-
- if (state.anchor !== null) {
- throwError(state, 'duplication of an anchor property')
- }
-
- ch = state.input.charCodeAt(++state.position)
- const _position = state.position
-
- while (ch !== 0 && !isWsOrEol(ch) && !isFlowIndicator(ch)) {
- ch = state.input.charCodeAt(++state.position)
- }
-
- if (state.position === _position) {
- throwError(state, 'name of an anchor node must contain at least one character')
- }
-
- state.anchor = state.input.slice(_position, state.position)
- return true
-}
-
-function readAlias (state) {
- let ch = state.input.charCodeAt(state.position)
-
- if (ch !== 0x2A/* * */) return false
-
- ch = state.input.charCodeAt(++state.position)
- const _position = state.position
-
- while (ch !== 0 && !isWsOrEol(ch) && !isFlowIndicator(ch)) {
- ch = state.input.charCodeAt(++state.position)
- }
-
- if (state.position === _position) {
- throwError(state, 'name of an alias node must contain at least one character')
- }
-
- const alias = state.input.slice(_position, state.position)
-
- if (!_hasOwnProperty.call(state.anchorMap, alias)) {
- throwError(state, 'unidentified alias "' + alias + '"')
- }
-
- state.result = state.anchorMap[alias]
- skipSeparationSpace(state, true, -1)
- return true
-}
-
-function tryReadBlockMappingFromProperty (state, propertyStart, nodeIndent, flowIndent) {
- const fallbackState = snapshotState(state)
-
- beginAnchorTransaction(state)
- restoreState(state, propertyStart)
-
- // Re-read the leading properties as part of the first implicit key, not as
- // properties of the current node.
- state.tag = null
- state.anchor = null
- state.kind = null
- state.result = null
-
- if (readBlockMapping(state, nodeIndent, flowIndent) && state.kind === 'mapping') {
- commitAnchorTransaction(state)
- return true
- }
-
- rollbackAnchorTransaction(state)
- restoreState(state, fallbackState)
- return false
-}
-
-function composeNode (state, parentIndent, nodeContext, allowToSeek, allowCompact) {
- let allowBlockScalars
- let allowBlockCollections
- let indentStatus = 1 // 1: this>parent, 0: this=parent, -1: this= state.maxDepth) {
- throwError(state, 'nesting exceeded maxDepth (' + state.maxDepth + ')')
- }
-
- state.depth += 1
-
- if (state.listener !== null) {
- state.listener('open', state)
- }
-
- state.tag = null
- state.anchor = null
- state.kind = null
- state.result = null
-
- const allowBlockStyles = allowBlockScalars = allowBlockCollections =
- CONTEXT_BLOCK_OUT === nodeContext ||
- CONTEXT_BLOCK_IN === nodeContext
-
- if (allowToSeek) {
- if (skipSeparationSpace(state, true, -1)) {
- atNewLine = true
-
- if (state.lineIndent > parentIndent) {
- indentStatus = 1
- } else if (state.lineIndent === parentIndent) {
- indentStatus = 0
- } else if (state.lineIndent < parentIndent) {
- indentStatus = -1
- }
- }
- }
-
- if (indentStatus === 1) {
- while (true) {
- const ch = state.input.charCodeAt(state.position)
- const propertyState = snapshotState(state)
-
- // A duplicate property token after a line break can be the first key of
- // a nested block mapping, e.g. `!!map\n !!str key: value`.
- if (atNewLine &&
- ((ch === 0x21/* ! */ && state.tag !== null) ||
- (ch === 0x26/* & */ && state.anchor !== null))) {
- break
- }
-
- if (!readTagProperty(state) && !readAnchorProperty(state)) {
- break
- }
-
- if (propertyStart === null) {
- propertyStart = propertyState
- }
-
- if (skipSeparationSpace(state, true, -1)) {
- atNewLine = true
- allowBlockCollections = allowBlockStyles
-
- if (state.lineIndent > parentIndent) {
- indentStatus = 1
- } else if (state.lineIndent === parentIndent) {
- indentStatus = 0
- } else if (state.lineIndent < parentIndent) {
- indentStatus = -1
- }
- } else {
- allowBlockCollections = false
- }
- }
- }
-
- if (allowBlockCollections) {
- allowBlockCollections = atNewLine || allowCompact
- }
-
- if (indentStatus === 1 || CONTEXT_BLOCK_OUT === nodeContext) {
- if (CONTEXT_FLOW_IN === nodeContext || CONTEXT_FLOW_OUT === nodeContext) {
- flowIndent = parentIndent
- } else {
- flowIndent = parentIndent + 1
- }
-
- blockIndent = state.position - state.lineStart
-
- if (indentStatus === 1) {
- if ((allowBlockCollections &&
- (readBlockSequence(state, blockIndent) || readBlockMapping(state, blockIndent, flowIndent))) ||
- readFlowCollection(state, flowIndent)) {
- hasContent = true
- } else {
- const ch = state.input.charCodeAt(state.position)
-
- if (propertyStart !== null && allowBlockStyles && !allowBlockCollections &&
- ch !== 0x7C/* | */ && ch !== 0x3E/* > */ &&
- tryReadBlockMappingFromProperty(
- state,
- propertyStart,
- propertyStart.position - propertyStart.lineStart,
- flowIndent
- )) {
- hasContent = true
- } else if ((allowBlockScalars && readBlockScalar(state, flowIndent)) ||
- readSingleQuotedScalar(state, flowIndent) ||
- readDoubleQuotedScalar(state, flowIndent)) {
- hasContent = true
- } else if (readAlias(state)) {
- hasContent = true
-
- if (state.tag !== null || state.anchor !== null) {
- throwError(state, 'alias node should not have any properties')
- }
- } else if (readPlainScalar(state, flowIndent, CONTEXT_FLOW_IN === nodeContext)) {
- hasContent = true
-
- if (state.tag === null) {
- state.tag = '?'
- }
- }
-
- if (state.anchor !== null) {
- storeAnchor(state, state.anchor, state.result)
- }
- }
- } else if (indentStatus === 0) {
- // Special case: block sequences are allowed to have same indentation level as the parent.
- // http://www.yaml.org/spec/1.2/spec.html#id2799784
- hasContent = allowBlockCollections && readBlockSequence(state, blockIndent)
- }
- }
-
- if (state.tag === null) {
- if (state.anchor !== null) {
- storeAnchor(state, state.anchor, state.result)
- }
- } else if (state.tag === '?') {
- // Implicit resolving is not allowed for non-scalar types, and '?'
- // non-specific tag is only automatically assigned to plain scalars.
- //
- // We only need to check kind conformity in case user explicitly assigns '?'
- // tag, for example like this: "! [0]"
- //
- if (state.result !== null && state.kind !== 'scalar') {
- throwError(state, 'unacceptable node kind for ! tag; it should be "scalar", not "' + state.kind + '"')
- }
-
- for (let typeIndex = 0, typeQuantity = state.implicitTypes.length; typeIndex < typeQuantity; typeIndex += 1) {
- type = state.implicitTypes[typeIndex]
-
- if (type.resolve(state.result)) { // `state.result` updated in resolver if matched
- state.result = type.construct(state.result)
- state.tag = type.tag
- if (state.anchor !== null) {
- storeAnchor(state, state.anchor, state.result)
- }
- break
- }
- }
- } else if (state.tag !== '!') {
- if (_hasOwnProperty.call(state.typeMap[state.kind || 'fallback'], state.tag)) {
- type = state.typeMap[state.kind || 'fallback'][state.tag]
- } else {
- // looking for multi type
- type = null
- const typeList = state.typeMap.multi[state.kind || 'fallback']
-
- for (let typeIndex = 0, typeQuantity = typeList.length; typeIndex < typeQuantity; typeIndex += 1) {
- if (state.tag.slice(0, typeList[typeIndex].tag.length) === typeList[typeIndex].tag) {
- type = typeList[typeIndex]
- break
- }
- }
- }
-
- if (!type) {
- throwError(state, 'unknown tag !<' + state.tag + '>')
- }
-
- if (state.result !== null && type.kind !== state.kind) {
- throwError(state, 'unacceptable node kind for !<' + state.tag + '> tag; it should be "' + type.kind + '", not "' + state.kind + '"')
- }
-
- if (!type.resolve(state.result, state.tag)) { // `state.result` updated in resolver if matched
- throwError(state, 'cannot resolve a node with !<' + state.tag + '> explicit tag')
- } else {
- state.result = type.construct(state.result, state.tag)
- if (state.anchor !== null) {
- storeAnchor(state, state.anchor, state.result)
- }
- }
- }
-
- if (state.listener !== null) {
- state.listener('close', state)
- }
-
- state.depth -= 1
- return state.tag !== null || state.anchor !== null || hasContent
-}
-
-function readDocument (state) {
- const documentStart = state.position
- let hasDirectives = false
- let ch
-
- state.version = null
- state.checkLineBreaks = state.legacy
- state.tagMap = Object.create(null)
- state.anchorMap = Object.create(null)
-
- while ((ch = state.input.charCodeAt(state.position)) !== 0) {
- skipSeparationSpace(state, true, -1)
-
- ch = state.input.charCodeAt(state.position)
-
- if (state.lineIndent > 0 || ch !== 0x25/* % */) {
- break
- }
-
- hasDirectives = true
- ch = state.input.charCodeAt(++state.position)
- let _position = state.position
-
- while (ch !== 0 && !isWsOrEol(ch)) {
- ch = state.input.charCodeAt(++state.position)
- }
-
- const directiveName = state.input.slice(_position, state.position)
- const directiveArgs = []
-
- if (directiveName.length < 1) {
- throwError(state, 'directive name must not be less than one character in length')
- }
-
- while (ch !== 0) {
- while (isWhiteSpace(ch)) {
- ch = state.input.charCodeAt(++state.position)
- }
-
- if (ch === 0x23/* # */) {
- do { ch = state.input.charCodeAt(++state.position) }
- while (ch !== 0 && !isEol(ch))
- break
- }
-
- if (isEol(ch)) break
-
- _position = state.position
-
- while (ch !== 0 && !isWsOrEol(ch)) {
- ch = state.input.charCodeAt(++state.position)
- }
-
- directiveArgs.push(state.input.slice(_position, state.position))
- }
-
- if (ch !== 0) readLineBreak(state)
-
- if (_hasOwnProperty.call(directiveHandlers, directiveName)) {
- directiveHandlers[directiveName](state, directiveName, directiveArgs)
- } else {
- throwWarning(state, 'unknown document directive "' + directiveName + '"')
- }
- }
-
- skipSeparationSpace(state, true, -1)
-
- if (state.lineIndent === 0 &&
- state.input.charCodeAt(state.position) === 0x2D/* - */ &&
- state.input.charCodeAt(state.position + 1) === 0x2D/* - */ &&
- state.input.charCodeAt(state.position + 2) === 0x2D/* - */) {
- state.position += 3
- skipSeparationSpace(state, true, -1)
- } else if (hasDirectives) {
- throwError(state, 'directives end mark is expected')
- }
-
- composeNode(state, state.lineIndent - 1, CONTEXT_BLOCK_OUT, false, true)
- skipSeparationSpace(state, true, -1)
-
- if (state.checkLineBreaks &&
- PATTERN_NON_ASCII_LINE_BREAKS.test(state.input.slice(documentStart, state.position))) {
- throwWarning(state, 'non-ASCII line breaks are interpreted as content')
- }
-
- state.documents.push(state.result)
-
- if (state.position === state.lineStart && testDocumentSeparator(state)) {
- if (state.input.charCodeAt(state.position) === 0x2E/* . */) {
- state.position += 3
- skipSeparationSpace(state, true, -1)
- }
- return
- }
-
- if (state.position < (state.length - 1)) {
- throwError(state, 'end of the stream or a document separator is expected')
- }
-}
-
-function loadDocuments (input, options) {
- input = String(input)
- options = options || {}
-
- if (input.length !== 0) {
- // Add tailing `\n` if not exists
- if (input.charCodeAt(input.length - 1) !== 0x0A/* LF */ &&
- input.charCodeAt(input.length - 1) !== 0x0D/* CR */) {
- input += '\n'
- }
-
- // Strip BOM
- if (input.charCodeAt(0) === 0xFEFF) {
- input = input.slice(1)
- }
- }
-
- const state = new State(input, options)
-
- const nullpos = input.indexOf('\0')
-
- if (nullpos !== -1) {
- state.position = nullpos
- throwError(state, 'null byte is not allowed in input')
- }
-
- // Use 0 as string terminator. That significantly simplifies bounds check.
- state.input += '\0'
-
- while (state.input.charCodeAt(state.position) === 0x20/* Space */) {
- state.lineIndent += 1
- state.position += 1
- }
-
- while (state.position < (state.length - 1)) {
- readDocument(state)
- }
-
- return state.documents
-}
-
-function loadAll (input, iterator, options) {
- if (iterator !== null && typeof iterator === 'object' && typeof options === 'undefined') {
- options = iterator
- iterator = null
- }
-
- const documents = loadDocuments(input, options)
-
- if (typeof iterator !== 'function') {
- return documents
- }
-
- for (let index = 0, length = documents.length; index < length; index += 1) {
- iterator(documents[index])
- }
-}
-
-function load (input, options) {
- const documents = loadDocuments(input, options)
-
- if (documents.length === 0) {
- return undefined
- } else if (documents.length === 1) {
- return documents[0]
- }
- throw new YAMLException('expected a single document in the stream, but found more')
-}
-
-module.exports.loadAll = loadAll
-module.exports.load = load
-
-
-/***/ }),
-
-/***/ 8000:
-/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
-
-
-
-const YAMLException = __nccwpck_require__(3194)
-const Type = __nccwpck_require__(1015)
-
-function compileList (schema, name) {
- const result = []
-
- schema[name].forEach(function (currentType) {
- let newIndex = result.length
-
- result.forEach(function (previousType, previousIndex) {
- if (previousType.tag === currentType.tag &&
- previousType.kind === currentType.kind &&
- previousType.multi === currentType.multi) {
- newIndex = previousIndex
- }
- })
-
- result[newIndex] = currentType
- })
-
- return result
-}
-
-function compileMap (/* lists... */) {
- const result = {
- scalar: {},
- sequence: {},
- mapping: {},
- fallback: {},
- multi: {
- scalar: [],
- sequence: [],
- mapping: [],
- fallback: []
- }
- }
- function collectType (type) {
- if (type.multi) {
- result.multi[type.kind].push(type)
- result.multi['fallback'].push(type)
- } else {
- result[type.kind][type.tag] = result['fallback'][type.tag] = type
- }
- }
-
- for (let index = 0, length = arguments.length; index < length; index += 1) {
- arguments[index].forEach(collectType)
- }
- return result
-}
-
-function Schema (definition) {
- return this.extend(definition)
-}
-
-Schema.prototype.extend = function extend (definition) {
- let implicit = []
- let explicit = []
-
- if (definition instanceof Type) {
- // Schema.extend(type)
- explicit.push(definition)
- } else if (Array.isArray(definition)) {
- // Schema.extend([ type1, type2, ... ])
- explicit = explicit.concat(definition)
- } else if (definition && (Array.isArray(definition.implicit) || Array.isArray(definition.explicit))) {
- // Schema.extend({ explicit: [ type1, type2, ... ], implicit: [ type1, type2, ... ] })
- if (definition.implicit) implicit = implicit.concat(definition.implicit)
- if (definition.explicit) explicit = explicit.concat(definition.explicit)
- } else {
- throw new YAMLException('Schema.extend argument should be a Type, [ Type ], ' +
- 'or a schema definition ({ implicit: [...], explicit: [...] })')
- }
-
- implicit.forEach(function (type) {
- if (!(type instanceof Type)) {
- throw new YAMLException('Specified list of YAML types (or a single Type object) contains a non-Type object.')
- }
-
- if (type.loadKind && type.loadKind !== 'scalar') {
- throw new YAMLException('There is a non-scalar type in the implicit list of a schema. Implicit resolving of such types is not supported.')
- }
-
- if (type.multi) {
- throw new YAMLException('There is a multi type in the implicit list of a schema. Multi tags can only be listed as explicit.')
- }
- })
-
- explicit.forEach(function (type) {
- if (!(type instanceof Type)) {
- throw new YAMLException('Specified list of YAML types (or a single Type object) contains a non-Type object.')
- }
- })
-
- const result = Object.create(Schema.prototype)
-
- result.implicit = (this.implicit || []).concat(implicit)
- result.explicit = (this.explicit || []).concat(explicit)
-
- result.compiledImplicit = compileList(result, 'implicit')
- result.compiledExplicit = compileList(result, 'explicit')
- result.compiledTypeMap = compileMap(result.compiledImplicit, result.compiledExplicit)
-
- return result
-}
-
-module.exports = Schema
-
-
-/***/ }),
-
-/***/ 9568:
-/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
-
-// Standard YAML's Core schema.
-// http://www.yaml.org/spec/1.2/spec.html#id2804923
-//
-// NOTE: JS-YAML does not support schema-specific tag resolution restrictions.
-// So, Core schema has no distinctions from JSON schema is JS-YAML.
-
-
-
-module.exports = __nccwpck_require__(9625)
-
-
-/***/ }),
-
-/***/ 914:
-/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
-
-// JS-YAML's default schema for `safeLoad` function.
-// It is not described in the YAML specification.
-//
-// This schema is based on standard YAML's Core schema and includes most of
-// extra types described at YAML tag repository. (http://yaml.org/type/)
-
-
-
-module.exports = (__nccwpck_require__(9568).extend)({
- implicit: [
- __nccwpck_require__(6856),
- __nccwpck_require__(4844)
- ],
- explicit: [
- __nccwpck_require__(1531),
- __nccwpck_require__(5639),
- __nccwpck_require__(5129),
- __nccwpck_require__(7344)
- ]
-})
-
-
-/***/ }),
-
-/***/ 8334:
-/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
-
-// Standard YAML's Failsafe schema.
-// http://www.yaml.org/spec/1.2/spec.html#id2802346
-
-
-
-const Schema = __nccwpck_require__(8000)
-
-module.exports = new Schema({
- explicit: [
- __nccwpck_require__(7055),
- __nccwpck_require__(4707),
- __nccwpck_require__(9098)
- ]
-})
-
-
-/***/ }),
-
-/***/ 9625:
-/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
-
-// Standard YAML's JSON schema.
-// http://www.yaml.org/spec/1.2/spec.html#id2803231
-//
-// NOTE: JS-YAML does not support schema-specific tag resolution restrictions.
-// So, this schema is not such strict as defined in the YAML specification.
-// It allows numbers in binary notaion, use `Null` and `NULL` as `null`, etc.
-
-
-
-module.exports = (__nccwpck_require__(8334).extend)({
- implicit: [
- __nccwpck_require__(4427),
- __nccwpck_require__(8246),
- __nccwpck_require__(2961),
- __nccwpck_require__(4334)
- ]
-})
-
-
-/***/ }),
-
-/***/ 342:
-/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
-
-
-
-const common = __nccwpck_require__(1450)
-
-// get snippet for a single line, respecting maxLength
-function getLine (buffer, lineStart, lineEnd, position, maxLineLength) {
- let head = ''
- let tail = ''
- const maxHalfLength = Math.floor(maxLineLength / 2) - 1
-
- if (position - lineStart > maxHalfLength) {
- head = ' ... '
- lineStart = position - maxHalfLength + head.length
- }
-
- if (lineEnd - position > maxHalfLength) {
- tail = ' ...'
- lineEnd = position + maxHalfLength - tail.length
- }
-
- return {
- str: head + buffer.slice(lineStart, lineEnd).replace(/\t/g, '→') + tail,
- pos: position - lineStart + head.length // relative position
- }
-}
-
-function padStart (string, max) {
- return common.repeat(' ', max - string.length) + string
-}
-
-function makeSnippet (mark, options) {
- options = Object.create(options || null)
-
- if (!mark.buffer) return null
-
- if (!options.maxLength) options.maxLength = 79
- if (typeof options.indent !== 'number') options.indent = 1
- if (typeof options.linesBefore !== 'number') options.linesBefore = 3
- if (typeof options.linesAfter !== 'number') options.linesAfter = 2
-
- const re = /\r?\n|\r|\0/g
- const lineStarts = [0]
- const lineEnds = []
- let match
- let foundLineNo = -1
-
- while ((match = re.exec(mark.buffer))) {
- lineEnds.push(match.index)
- lineStarts.push(match.index + match[0].length)
-
- if (mark.position <= match.index && foundLineNo < 0) {
- foundLineNo = lineStarts.length - 2
- }
- }
-
- if (foundLineNo < 0) foundLineNo = lineStarts.length - 1
-
- let result = ''
- const lineNoLength = Math.min(mark.line + options.linesAfter, lineEnds.length).toString().length
- const maxLineLength = options.maxLength - (options.indent + lineNoLength + 3)
-
- for (let i = 1; i <= options.linesBefore; i++) {
- if (foundLineNo - i < 0) break
- const line = getLine(
- mark.buffer,
- lineStarts[foundLineNo - i],
- lineEnds[foundLineNo - i],
- mark.position - (lineStarts[foundLineNo] - lineStarts[foundLineNo - i]),
- maxLineLength
- )
- result = common.repeat(' ', options.indent) + padStart((mark.line - i + 1).toString(), lineNoLength) +
- ' | ' + line.str + '\n' + result
- }
-
- const line = getLine(mark.buffer, lineStarts[foundLineNo], lineEnds[foundLineNo], mark.position, maxLineLength)
- result += common.repeat(' ', options.indent) + padStart((mark.line + 1).toString(), lineNoLength) +
- ' | ' + line.str + '\n'
- result += common.repeat('-', options.indent + lineNoLength + 3 + line.pos) + '^' + '\n'
-
- for (let i = 1; i <= options.linesAfter; i++) {
- if (foundLineNo + i >= lineEnds.length) break
- const line = getLine(
- mark.buffer,
- lineStarts[foundLineNo + i],
- lineEnds[foundLineNo + i],
- mark.position - (lineStarts[foundLineNo] - lineStarts[foundLineNo + i]),
- maxLineLength
- )
- result += common.repeat(' ', options.indent) + padStart((mark.line + i + 1).toString(), lineNoLength) +
- ' | ' + line.str + '\n'
- }
-
- return result.replace(/\n$/, '')
-}
-
-module.exports = makeSnippet
-
-
-/***/ }),
-
-/***/ 1015:
-/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
-
-
-
-const YAMLException = __nccwpck_require__(3194)
-
-const TYPE_CONSTRUCTOR_OPTIONS = [
- 'kind',
- 'multi',
- 'resolve',
- 'construct',
- 'instanceOf',
- 'predicate',
- 'represent',
- 'representName',
- 'defaultStyle',
- 'styleAliases'
-]
-
-const YAML_NODE_KINDS = [
- 'scalar',
- 'sequence',
- 'mapping'
-]
-
-function compileStyleAliases (map) {
- const result = {}
-
- if (map !== null) {
- Object.keys(map).forEach(function (style) {
- map[style].forEach(function (alias) {
- result[String(alias)] = style
- })
- })
- }
-
- return result
-}
-
-function Type (tag, options) {
- options = options || {}
-
- Object.keys(options).forEach(function (name) {
- if (TYPE_CONSTRUCTOR_OPTIONS.indexOf(name) === -1) {
- throw new YAMLException('Unknown option "' + name + '" is met in definition of "' + tag + '" YAML type.')
- }
- })
-
- // TODO: Add tag format check.
- this.options = options // keep original options in case user wants to extend this type later
- this.tag = tag
- this.kind = options['kind'] || null
- this.resolve = options['resolve'] || function () { return true }
- this.construct = options['construct'] || function (data) { return data }
- this.instanceOf = options['instanceOf'] || null
- this.predicate = options['predicate'] || null
- this.represent = options['represent'] || null
- this.representName = options['representName'] || null
- this.defaultStyle = options['defaultStyle'] || null
- this.multi = options['multi'] || false
- this.styleAliases = compileStyleAliases(options['styleAliases'] || null)
-
- if (YAML_NODE_KINDS.indexOf(this.kind) === -1) {
- throw new YAMLException('Unknown kind "' + this.kind + '" is specified for "' + tag + '" YAML type.')
- }
-}
-
-module.exports = Type
-
-
-/***/ }),
-
-/***/ 1531:
-/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
-
-
-
-const Type = __nccwpck_require__(1015)
-
-// [ 64, 65, 66 ] -> [ padding, CR, LF ]
-const BASE64_MAP = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=\n\r'
-
-function resolveYamlBinary (data) {
- if (data === null) return false
-
- let bitlen = 0
- const max = data.length
- const map = BASE64_MAP
-
- // Convert one by one.
- for (let idx = 0; idx < max; idx++) {
- const code = map.indexOf(data.charAt(idx))
-
- // Skip CR/LF
- if (code > 64) continue
-
- // Fail on illegal characters
- if (code < 0) return false
-
- bitlen += 6
- }
-
- // If there are any bits left, source was corrupted
- return (bitlen % 8) === 0
-}
-
-function constructYamlBinary (data) {
- const input = data.replace(/[\r\n=]/g, '') // remove CR/LF & padding to simplify scan
- const max = input.length
- const map = BASE64_MAP
- let bits = 0
- const result = []
-
- // Collect by 6*4 bits (3 bytes)
-
- for (let idx = 0; idx < max; idx++) {
- if ((idx % 4 === 0) && idx) {
- result.push((bits >> 16) & 0xFF)
- result.push((bits >> 8) & 0xFF)
- result.push(bits & 0xFF)
- }
-
- bits = (bits << 6) | map.indexOf(input.charAt(idx))
- }
-
- // Dump tail
-
- const tailbits = (max % 4) * 6
-
- if (tailbits === 0) {
- result.push((bits >> 16) & 0xFF)
- result.push((bits >> 8) & 0xFF)
- result.push(bits & 0xFF)
- } else if (tailbits === 18) {
- result.push((bits >> 10) & 0xFF)
- result.push((bits >> 2) & 0xFF)
- } else if (tailbits === 12) {
- result.push((bits >> 4) & 0xFF)
- }
-
- return new Uint8Array(result)
-}
-
-function representYamlBinary (object /*, style */) {
- let result = ''
- let bits = 0
- const max = object.length
- const map = BASE64_MAP
-
- // Convert every three bytes to 4 ASCII characters.
-
- for (let idx = 0; idx < max; idx++) {
- if ((idx % 3 === 0) && idx) {
- result += map[(bits >> 18) & 0x3F]
- result += map[(bits >> 12) & 0x3F]
- result += map[(bits >> 6) & 0x3F]
- result += map[bits & 0x3F]
- }
-
- bits = (bits << 8) + object[idx]
- }
-
- // Dump tail
-
- const tail = max % 3
-
- if (tail === 0) {
- result += map[(bits >> 18) & 0x3F]
- result += map[(bits >> 12) & 0x3F]
- result += map[(bits >> 6) & 0x3F]
- result += map[bits & 0x3F]
- } else if (tail === 2) {
- result += map[(bits >> 10) & 0x3F]
- result += map[(bits >> 4) & 0x3F]
- result += map[(bits << 2) & 0x3F]
- result += map[64]
- } else if (tail === 1) {
- result += map[(bits >> 2) & 0x3F]
- result += map[(bits << 4) & 0x3F]
- result += map[64]
- result += map[64]
- }
-
- return result
-}
-
-function isBinary (obj) {
- return Object.prototype.toString.call(obj) === '[object Uint8Array]'
-}
-
-module.exports = new Type('tag:yaml.org,2002:binary', {
- kind: 'scalar',
- resolve: resolveYamlBinary,
- construct: constructYamlBinary,
- predicate: isBinary,
- represent: representYamlBinary
-})
-
-
-/***/ }),
-
-/***/ 8246:
-/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
-
-
-
-const Type = __nccwpck_require__(1015)
-
-function resolveYamlBoolean (data) {
- if (data === null) return false
-
- const max = data.length
-
- return (max === 4 && (data === 'true' || data === 'True' || data === 'TRUE')) ||
- (max === 5 && (data === 'false' || data === 'False' || data === 'FALSE'))
-}
-
-function constructYamlBoolean (data) {
- return data === 'true' ||
- data === 'True' ||
- data === 'TRUE'
-}
-
-function isBoolean (object) {
- return Object.prototype.toString.call(object) === '[object Boolean]'
-}
-
-module.exports = new Type('tag:yaml.org,2002:bool', {
- kind: 'scalar',
- resolve: resolveYamlBoolean,
- construct: constructYamlBoolean,
- predicate: isBoolean,
- represent: {
- lowercase: function (object) { return object ? 'true' : 'false' },
- uppercase: function (object) { return object ? 'TRUE' : 'FALSE' },
- camelcase: function (object) { return object ? 'True' : 'False' }
- },
- defaultStyle: 'lowercase'
-})
-
-
-/***/ }),
-
-/***/ 4334:
-/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
-
-
-
-const common = __nccwpck_require__(1450)
-const Type = __nccwpck_require__(1015)
-
-const YAML_FLOAT_PATTERN = new RegExp(
- // 2.5e4, 2.5 and integers
- '^(?:[-+]?(?:[0-9]+)(?:\\.[0-9]*)?(?:[eE][-+]?[0-9]+)?' +
- // .2e4, .2
- // special case, seems not from spec
- '|\\.[0-9]+(?:[eE][-+]?[0-9]+)?' +
- // .inf
- '|[-+]?\\.(?:inf|Inf|INF)' +
- // .nan
- '|\\.(?:nan|NaN|NAN))$')
-
-const YAML_FLOAT_SPECIAL_PATTERN = new RegExp(
- '^(?:' +
- // .inf
- '[-+]?\\.(?:inf|Inf|INF)' +
- // .nan
- '|\\.(?:nan|NaN|NAN))$')
-
-function resolveYamlFloat (data) {
- if (data === null) return false
-
- if (!YAML_FLOAT_PATTERN.test(data)) {
- return false
- }
-
- if (isFinite(parseFloat(data, 10))) {
- return true
- }
-
- return YAML_FLOAT_SPECIAL_PATTERN.test(data)
-}
-
-function constructYamlFloat (data) {
- let value = data.toLowerCase()
- const sign = value[0] === '-' ? -1 : 1
-
- if ('+-'.indexOf(value[0]) >= 0) {
- value = value.slice(1)
- }
-
- if (value === '.inf') {
- return (sign === 1) ? Number.POSITIVE_INFINITY : Number.NEGATIVE_INFINITY
- } else if (value === '.nan') {
- return NaN
- }
- return sign * parseFloat(value, 10)
-}
-
-const SCIENTIFIC_WITHOUT_DOT = /^[-+]?[0-9]+e/
-
-function representYamlFloat (object, style) {
- if (isNaN(object)) {
- switch (style) {
- case 'lowercase': return '.nan'
- case 'uppercase': return '.NAN'
- case 'camelcase': return '.NaN'
- }
- } else if (Number.POSITIVE_INFINITY === object) {
- switch (style) {
- case 'lowercase': return '.inf'
- case 'uppercase': return '.INF'
- case 'camelcase': return '.Inf'
- }
- } else if (Number.NEGATIVE_INFINITY === object) {
- switch (style) {
- case 'lowercase': return '-.inf'
- case 'uppercase': return '-.INF'
- case 'camelcase': return '-.Inf'
- }
- } else if (common.isNegativeZero(object)) {
- return '-0.0'
- }
-
- const res = object.toString(10)
-
- // JS stringifier can build scientific format without dots: 5e-100,
- // while YAML requres dot: 5.e-100. Fix it with simple hack
-
- return SCIENTIFIC_WITHOUT_DOT.test(res) ? res.replace('e', '.e') : res
-}
-
-function isFloat (object) {
- return (Object.prototype.toString.call(object) === '[object Number]') &&
- (object % 1 !== 0 || common.isNegativeZero(object))
-}
-
-module.exports = new Type('tag:yaml.org,2002:float', {
- kind: 'scalar',
- resolve: resolveYamlFloat,
- construct: constructYamlFloat,
- predicate: isFloat,
- represent: representYamlFloat,
- defaultStyle: 'lowercase'
-})
-
-
-/***/ }),
-
-/***/ 2961:
-/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
-
-
-
-const common = __nccwpck_require__(1450)
-const Type = __nccwpck_require__(1015)
-
-function isHexCode (c) {
- return ((c >= 0x30/* 0 */) && (c <= 0x39/* 9 */)) ||
- ((c >= 0x41/* A */) && (c <= 0x46/* F */)) ||
- ((c >= 0x61/* a */) && (c <= 0x66/* f */))
-}
-
-function isOctCode (c) {
- return ((c >= 0x30/* 0 */) && (c <= 0x37/* 7 */))
-}
-
-function isDecCode (c) {
- return ((c >= 0x30/* 0 */) && (c <= 0x39/* 9 */))
-}
-
-function resolveYamlInteger (data) {
- if (data === null) return false
-
- const max = data.length
- let index = 0
- let hasDigits = false
-
- if (!max) return false
-
- let ch = data[index]
-
- // sign
- if (ch === '-' || ch === '+') {
- ch = data[++index]
- }
-
- if (ch === '0') {
- // 0
- if (index + 1 === max) return true
- ch = data[++index]
-
- // base 2, base 8, base 16
-
- if (ch === 'b') {
- // base 2
- index++
-
- for (; index < max; index++) {
- ch = data[index]
- if (ch !== '0' && ch !== '1') return false
- hasDigits = true
- }
- return hasDigits && isFinite(parseYamlInteger(data))
- }
-
- if (ch === 'x') {
- // base 16
- index++
-
- for (; index < max; index++) {
- if (!isHexCode(data.charCodeAt(index))) return false
- hasDigits = true
- }
- return hasDigits && isFinite(parseYamlInteger(data))
- }
-
- if (ch === 'o') {
- // base 8
- index++
-
- for (; index < max; index++) {
- if (!isOctCode(data.charCodeAt(index))) return false
- hasDigits = true
- }
- return hasDigits && isFinite(parseYamlInteger(data))
- }
- }
-
- // base 10 (except 0)
-
- for (; index < max; index++) {
- if (!isDecCode(data.charCodeAt(index))) {
- return false
- }
- hasDigits = true
- }
-
- if (!hasDigits) return false
-
- return isFinite(parseYamlInteger(data))
-}
-
-function parseYamlInteger (data) {
- let value = data
- let sign = 1
-
- let ch = value[0]
-
- if (ch === '-' || ch === '+') {
- if (ch === '-') sign = -1
- value = value.slice(1)
- ch = value[0]
- }
-
- if (value === '0') return 0
-
- if (ch === '0') {
- if (value[1] === 'b') return sign * parseInt(value.slice(2), 2)
- if (value[1] === 'x') return sign * parseInt(value.slice(2), 16)
- if (value[1] === 'o') return sign * parseInt(value.slice(2), 8)
- }
-
- return sign * parseInt(value, 10)
-}
-
-function constructYamlInteger (data) {
- return parseYamlInteger(data)
-}
-
-function isInteger (object) {
- return (Object.prototype.toString.call(object)) === '[object Number]' &&
- (object % 1 === 0 && !common.isNegativeZero(object))
-}
-
-module.exports = new Type('tag:yaml.org,2002:int', {
- kind: 'scalar',
- resolve: resolveYamlInteger,
- construct: constructYamlInteger,
- predicate: isInteger,
- represent: {
- binary: function (obj) { return obj >= 0 ? '0b' + obj.toString(2) : '-0b' + obj.toString(2).slice(1) },
- octal: function (obj) { return obj >= 0 ? '0o' + obj.toString(8) : '-0o' + obj.toString(8).slice(1) },
- decimal: function (obj) { return obj.toString(10) },
- hexadecimal: function (obj) { return obj >= 0 ? '0x' + obj.toString(16).toUpperCase() : '-0x' + obj.toString(16).toUpperCase().slice(1) }
- },
- defaultStyle: 'decimal',
- styleAliases: {
- binary: [2, 'bin'],
- octal: [8, 'oct'],
- decimal: [10, 'dec'],
- hexadecimal: [16, 'hex']
- }
-})
-
-
-/***/ }),
-
-/***/ 9098:
-/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
-
-
-
-const Type = __nccwpck_require__(1015)
-
-module.exports = new Type('tag:yaml.org,2002:map', {
- kind: 'mapping',
- construct: function (data) { return data !== null ? data : {} }
-})
-
-
-/***/ }),
-
-/***/ 4844:
-/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
-
-
-
-const Type = __nccwpck_require__(1015)
-
-function resolveYamlMerge (data) {
- return data === '<<' || data === null
-}
-
-module.exports = new Type('tag:yaml.org,2002:merge', {
- kind: 'scalar',
- resolve: resolveYamlMerge
-})
-
-
-/***/ }),
-
-/***/ 4427:
-/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
-
-
-
-const Type = __nccwpck_require__(1015)
-
-function resolveYamlNull (data) {
- if (data === null) return true
-
- const max = data.length
-
- return (max === 1 && data === '~') ||
- (max === 4 && (data === 'null' || data === 'Null' || data === 'NULL'))
-}
-
-function constructYamlNull () {
- return null
-}
-
-function isNull (object) {
- return object === null
-}
-
-module.exports = new Type('tag:yaml.org,2002:null', {
- kind: 'scalar',
- resolve: resolveYamlNull,
- construct: constructYamlNull,
- predicate: isNull,
- represent: {
- canonical: function () { return '~' },
- lowercase: function () { return 'null' },
- uppercase: function () { return 'NULL' },
- camelcase: function () { return 'Null' },
- empty: function () { return '' }
- },
- defaultStyle: 'lowercase'
-})
-
-
-/***/ }),
-
-/***/ 5639:
-/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
-
-
-
-const Type = __nccwpck_require__(1015)
-
-const _hasOwnProperty = Object.prototype.hasOwnProperty
-const _toString = Object.prototype.toString
-
-function resolveYamlOmap (data) {
- if (data === null) return true
-
- const objectKeys = []
- const object = data
-
- for (let index = 0, length = object.length; index < length; index += 1) {
- const pair = object[index]
- let pairHasKey = false
-
- if (_toString.call(pair) !== '[object Object]') return false
-
- let pairKey
- for (pairKey in pair) {
- if (_hasOwnProperty.call(pair, pairKey)) {
- if (!pairHasKey) pairHasKey = true
- else return false
- }
- }
-
- if (!pairHasKey) return false
-
- if (objectKeys.indexOf(pairKey) === -1) objectKeys.push(pairKey)
- else return false
- }
-
- return true
-}
-
-function constructYamlOmap (data) {
- return data !== null ? data : []
-}
-
-module.exports = new Type('tag:yaml.org,2002:omap', {
- kind: 'sequence',
- resolve: resolveYamlOmap,
- construct: constructYamlOmap
-})
-
-
-/***/ }),
-
-/***/ 5129:
-/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
-
-
-
-const Type = __nccwpck_require__(1015)
-
-const _toString = Object.prototype.toString
-
-function resolveYamlPairs (data) {
- if (data === null) return true
-
- const object = data
-
- const result = new Array(object.length)
-
- for (let index = 0, length = object.length; index < length; index += 1) {
- const pair = object[index]
-
- if (_toString.call(pair) !== '[object Object]') return false
-
- const keys = Object.keys(pair)
-
- if (keys.length !== 1) return false
-
- result[index] = [keys[0], pair[keys[0]]]
- }
-
- return true
-}
-
-function constructYamlPairs (data) {
- if (data === null) return []
-
- const object = data
- const result = new Array(object.length)
-
- for (let index = 0, length = object.length; index < length; index += 1) {
- const pair = object[index]
-
- const keys = Object.keys(pair)
-
- result[index] = [keys[0], pair[keys[0]]]
- }
-
- return result
-}
-
-module.exports = new Type('tag:yaml.org,2002:pairs', {
- kind: 'sequence',
- resolve: resolveYamlPairs,
- construct: constructYamlPairs
-})
-
-
-/***/ }),
-
-/***/ 4707:
-/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
-
-
-
-const Type = __nccwpck_require__(1015)
-
-module.exports = new Type('tag:yaml.org,2002:seq', {
- kind: 'sequence',
- construct: function (data) { return data !== null ? data : [] }
-})
-
-
-/***/ }),
-
-/***/ 7344:
-/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
-
-
-
-const Type = __nccwpck_require__(1015)
-
-const _hasOwnProperty = Object.prototype.hasOwnProperty
-
-function resolveYamlSet (data) {
- if (data === null) return true
-
- const object = data
-
- for (const key in object) {
- if (_hasOwnProperty.call(object, key)) {
- if (object[key] !== null) return false
- }
- }
-
- return true
-}
-
-function constructYamlSet (data) {
- return data !== null ? data : {}
-}
-
-module.exports = new Type('tag:yaml.org,2002:set', {
- kind: 'mapping',
- resolve: resolveYamlSet,
- construct: constructYamlSet
-})
-
-
-/***/ }),
-
-/***/ 7055:
-/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
-
-
-
-const Type = __nccwpck_require__(1015)
-
-module.exports = new Type('tag:yaml.org,2002:str', {
- kind: 'scalar',
- construct: function (data) { return data !== null ? data : '' }
-})
-
-
-/***/ }),
-
-/***/ 6856:
-/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
-
-
-
-const Type = __nccwpck_require__(1015)
-
-const YAML_DATE_REGEXP = new RegExp(
- '^([0-9][0-9][0-9][0-9])' + // [1] year
- '-([0-9][0-9])' + // [2] month
- '-([0-9][0-9])$') // [3] day
-
-const YAML_TIMESTAMP_REGEXP = new RegExp(
- '^([0-9][0-9][0-9][0-9])' + // [1] year
- '-([0-9][0-9]?)' + // [2] month
- '-([0-9][0-9]?)' + // [3] day
- '(?:[Tt]|[ \\t]+)' + // ...
- '([0-9][0-9]?)' + // [4] hour
- ':([0-9][0-9])' + // [5] minute
- ':([0-9][0-9])' + // [6] second
- '(?:\\.([0-9]*))?' + // [7] fraction
- '(?:[ \\t]*(Z|([-+])([0-9][0-9]?)' + // [8] tz [9] tz_sign [10] tzHour
- '(?::([0-9][0-9]))?))?$') // [11] tzMinute
-
-function resolveYamlTimestamp (data) {
- if (data === null) return false
- if (YAML_DATE_REGEXP.exec(data) !== null) return true
- if (YAML_TIMESTAMP_REGEXP.exec(data) !== null) return true
- return false
-}
-
-function constructYamlTimestamp (data) {
- let fraction = 0
- let delta = null
-
- let match = YAML_DATE_REGEXP.exec(data)
- if (match === null) match = YAML_TIMESTAMP_REGEXP.exec(data)
-
- if (match === null) throw new Error('Date resolve error')
-
- // match: [1] year [2] month [3] day
-
- const year = +(match[1])
- const month = +(match[2]) - 1 // JS month starts with 0
- const day = +(match[3])
-
- if (!match[4]) { // no hour
- return new Date(Date.UTC(year, month, day))
- }
-
- // match: [4] hour [5] minute [6] second [7] fraction
-
- const hour = +(match[4])
- const minute = +(match[5])
- const second = +(match[6])
-
- if (match[7]) {
- fraction = match[7].slice(0, 3)
- while (fraction.length < 3) { // milli-seconds
- fraction += '0'
- }
- fraction = +fraction
- }
-
- // match: [8] tz [9] tz_sign [10] tzHour [11] tzMinute
-
- if (match[9]) {
- const tzHour = +(match[10])
- const tzMinute = +(match[11] || 0)
- delta = (tzHour * 60 + tzMinute) * 60000 // delta in mili-seconds
- if (match[9] === '-') delta = -delta
- }
-
- const date = new Date(Date.UTC(year, month, day, hour, minute, second, fraction))
-
- if (delta) date.setTime(date.getTime() - delta)
-
- return date
-}
-
-function representYamlTimestamp (object /*, style */) {
- return object.toISOString()
-}
-
-module.exports = new Type('tag:yaml.org,2002:timestamp', {
- kind: 'scalar',
- resolve: resolveYamlTimestamp,
- construct: constructYamlTimestamp,
- instanceOf: Date,
- represent: representYamlTimestamp
-})
-
-
/***/ }),
/***/ 7242:
@@ -56801,109 +31238,19 @@ function formatSupportedCombinations(capability) {
/***/ }),
-/***/ 8343:
+/***/ 7083:
/***/ ((__unused_webpack_module, __webpack_exports__, __nccwpck_require__) => {
/* harmony export */ __nccwpck_require__.d(__webpack_exports__, {
-/* harmony export */ Fh: () => (/* binding */ importKey),
-/* harmony export */ Yi: () => (/* binding */ verifyPackageSignature)
+/* harmony export */ O: () => (/* binding */ validateToolchainIds)
/* harmony export */ });
-/* unused harmony exports PRIVATE_KEY_FILE, toGpgPath, deleteKey */
-/* harmony import */ var fs__WEBPACK_IMPORTED_MODULE_0__ = __nccwpck_require__(9896);
-/* harmony import */ var fs__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__nccwpck_require__.n(fs__WEBPACK_IMPORTED_MODULE_0__);
-/* harmony import */ var path__WEBPACK_IMPORTED_MODULE_1__ = __nccwpck_require__(6928);
-/* harmony import */ var path__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__nccwpck_require__.n(path__WEBPACK_IMPORTED_MODULE_1__);
-/* harmony import */ var _actions_io__WEBPACK_IMPORTED_MODULE_2__ = __nccwpck_require__(8701);
-/* harmony import */ var _actions_exec__WEBPACK_IMPORTED_MODULE_3__ = __nccwpck_require__(5260);
-/* harmony import */ var _actions_tool_cache__WEBPACK_IMPORTED_MODULE_4__ = __nccwpck_require__(9805);
-/* harmony import */ var _util_js__WEBPACK_IMPORTED_MODULE_5__ = __nccwpck_require__(4527);
-
-
-
-
-
-
-const PRIVATE_KEY_FILE = path__WEBPACK_IMPORTED_MODULE_1__.join(_util_js__WEBPACK_IMPORTED_MODULE_5__/* .getTempDir */ .G4(), 'private-key.asc');
-const PRIVATE_KEY_FINGERPRINT_REGEX = /\w{40}/;
-// Convert a Windows path (D:\a\_temp\...) to a POSIX path (/d/a/_temp/...).
-// The Git-bundled GPG on Windows (MSYS2-based) uses POSIX path conventions
-// internally. Passing Windows paths with backslashes can cause fatal GPG errors
-// (exit code 2), so all paths passed to GPG must be in POSIX format on Windows.
-function toGpgPath(p) {
- if (process.platform !== 'win32')
- return p;
- return p
- .replace(/\\/g, '/')
- .replace(/^([A-Za-z]):\//, (_, drive) => `/${drive.toLowerCase()}/`);
-}
-async function importKey(privateKey) {
- fs__WEBPACK_IMPORTED_MODULE_0__.writeFileSync(PRIVATE_KEY_FILE, privateKey, {
- encoding: 'utf-8',
- flag: 'w'
- });
- let output = '';
- const options = {
- silent: true,
- listeners: {
- stdout: (data) => {
- output += data.toString();
- }
- }
- };
- await _actions_exec__WEBPACK_IMPORTED_MODULE_3__/* .exec */ .m('gpg', [
- '--batch',
- '--import-options',
- 'import-show',
- '--import',
- PRIVATE_KEY_FILE
- ], options);
- await _actions_io__WEBPACK_IMPORTED_MODULE_2__/* .rmRF */ .Yz(PRIVATE_KEY_FILE);
- const match = output.match(PRIVATE_KEY_FINGERPRINT_REGEX);
- return match && match[0];
-}
-async function deleteKey(keyFingerprint) {
- await exec.exec('gpg', ['--batch', '--yes', '--delete-secret-and-public-key', keyFingerprint], {
- silent: true
- });
-}
-async function verifyPackageSignature(archivePath, signatureUrl, publicKeyContent) {
- const signaturePath = await _actions_tool_cache__WEBPACK_IMPORTED_MODULE_4__/* .downloadTool */ .bq(signatureUrl);
- let gpgHome;
- try {
- gpgHome = fs__WEBPACK_IMPORTED_MODULE_0__.mkdtempSync(path__WEBPACK_IMPORTED_MODULE_1__.join(_util_js__WEBPACK_IMPORTED_MODULE_5__/* .getTempDir */ .G4(), 'verify-signature-gpg-home-'));
+function validateToolchainIds(versions, versionFile, toolchainIds) {
+ if (!toolchainIds.length) {
+ return;
}
- catch (error) {
- try {
- await _actions_io__WEBPACK_IMPORTED_MODULE_2__/* .rmRF */ .Yz(signaturePath);
- }
- catch {
- // ignore cleanup failures
- }
- throw new Error(`Failed to create temporary GPG home directory for signature verification: ${error.message}`, { cause: error });
- }
- try {
- const publicKeyFile = path__WEBPACK_IMPORTED_MODULE_1__.join(gpgHome, 'public-key.asc');
- fs__WEBPACK_IMPORTED_MODULE_0__.writeFileSync(publicKeyFile, publicKeyContent, { encoding: 'utf-8' });
- const options = { silent: true };
- await _actions_exec__WEBPACK_IMPORTED_MODULE_3__/* .exec */ .m('gpg', [
- '--homedir',
- toGpgPath(gpgHome),
- '--batch',
- '--import',
- toGpgPath(publicKeyFile)
- ], options);
- await _actions_exec__WEBPACK_IMPORTED_MODULE_3__/* .exec */ .m('gpg', [
- '--homedir',
- toGpgPath(gpgHome),
- '--batch',
- '--verify',
- toGpgPath(signaturePath),
- toGpgPath(archivePath)
- ], options);
- }
- finally {
- await _actions_io__WEBPACK_IMPORTED_MODULE_2__/* .rmRF */ .Yz(signaturePath);
- await _actions_io__WEBPACK_IMPORTED_MODULE_2__/* .rmRF */ .Yz(gpgHome);
+ const versionCount = versions.length || (versionFile ? 1 : 0);
+ if (versionCount !== toolchainIds.length) {
+ throw new Error(`The number of Maven toolchain IDs (${toolchainIds.length}) must match the number of Java versions (${versionCount})`);
}
}
@@ -57516,7 +31863,7 @@ module.exports = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("stream");
/***/ }),
-/***/ 4548:
+/***/ 9786:
/***/ ((module) => {
module.exports = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("stream/promises");
@@ -57558,5441 +31905,6 @@ module.exports = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("util");
/***/ }),
-/***/ 9373:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.builder = builder;
-exports.create = create;
-exports.fragment = fragment;
-exports.convert = convert;
-const interfaces_1 = __nccwpck_require__(5385);
-const util_1 = __nccwpck_require__(7061);
-const util_2 = __nccwpck_require__(8247);
-const _1 = __nccwpck_require__(957);
-const dom_1 = __nccwpck_require__(2869);
-/** @inheritdoc */
-function builder(p1, p2) {
- const options = formatBuilderOptions(isXMLBuilderCreateOptions(p1) ? p1 : interfaces_1.DefaultBuilderOptions);
- const nodes = util_2.Guard.isNode(p1) || (0, util_1.isArray)(p1) ? p1 : p2;
- if (nodes === undefined) {
- throw new Error("Invalid arguments.");
- }
- if ((0, util_1.isArray)(nodes)) {
- const builders = [];
- for (let i = 0; i < nodes.length; i++) {
- const builder = new _1.XMLBuilderImpl(nodes[i]);
- builder.set(options);
- builders.push(builder);
- }
- return builders;
- }
- else {
- const builder = new _1.XMLBuilderImpl(nodes);
- builder.set(options);
- return builder;
- }
-}
-/** @inheritdoc */
-function create(p1, p2) {
- const options = formatBuilderOptions(p1 === undefined || isXMLBuilderCreateOptions(p1) ?
- p1 : interfaces_1.DefaultBuilderOptions);
- const contents = isXMLBuilderCreateOptions(p1) ? p2 : p1;
- const doc = (0, dom_1.createDocument)();
- setOptions(doc, options);
- const builder = new _1.XMLBuilderImpl(doc);
- if (contents !== undefined) {
- // parse contents
- builder.ele(contents);
- }
- return builder;
-}
-/** @inheritdoc */
-function fragment(p1, p2) {
- const options = formatBuilderOptions(p1 === undefined || isXMLBuilderCreateOptions(p1) ?
- p1 : interfaces_1.DefaultBuilderOptions);
- const contents = isXMLBuilderCreateOptions(p1) ? p2 : p1;
- const doc = (0, dom_1.createDocument)();
- setOptions(doc, options, true);
- const builder = new _1.XMLBuilderImpl(doc.createDocumentFragment());
- if (contents !== undefined) {
- // parse contents
- builder.ele(contents);
- }
- return builder;
-}
-/** @inheritdoc */
-function convert(p1, p2, p3) {
- let builderOptions;
- let contents;
- let convertOptions;
- if (isXMLBuilderCreateOptions(p1) && p2 !== undefined) {
- builderOptions = p1;
- contents = p2;
- convertOptions = p3;
- }
- else {
- builderOptions = interfaces_1.DefaultBuilderOptions;
- contents = p1;
- convertOptions = p2 || undefined;
- }
- return create(builderOptions, contents).end(convertOptions);
-}
-function isXMLBuilderCreateOptions(obj) {
- if (!(0, util_1.isPlainObject)(obj))
- return false;
- for (const key in obj) {
- /* istanbul ignore else */
- if (obj.hasOwnProperty(key)) {
- if (!interfaces_1.XMLBuilderOptionKeys.has(key))
- return false;
- }
- }
- return true;
-}
-function formatBuilderOptions(createOptions = {}) {
- const options = (0, util_1.applyDefaults)(createOptions, interfaces_1.DefaultBuilderOptions);
- if (options.convert.att.length === 0 ||
- options.convert.ins.length === 0 ||
- options.convert.text.length === 0 ||
- options.convert.cdata.length === 0 ||
- options.convert.comment.length === 0) {
- throw new Error("JS object converter strings cannot be zero length.");
- }
- return options;
-}
-function setOptions(doc, options, isFragment) {
- const docWithSettings = doc;
- docWithSettings._xmlBuilderOptions = options;
- docWithSettings._isFragment = isFragment;
-}
-//# sourceMappingURL=BuilderFunctions.js.map
-
-/***/ }),
-
-/***/ 336:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.createCB = createCB;
-exports.fragmentCB = fragmentCB;
-const _1 = __nccwpck_require__(957);
-/**
- * Creates an XML builder which serializes the document in chunks.
- *
- * @param options - callback builder options
- *
- * @returns callback builder
- */
-function createCB(options) {
- return new _1.XMLBuilderCBImpl(options);
-}
-/**
- * Creates an XML builder which serializes the fragment in chunks.
- *
- * @param options - callback builder options
- *
- * @returns callback builder
- */
-function fragmentCB(options) {
- return new _1.XMLBuilderCBImpl(options, true);
-}
-//# sourceMappingURL=BuilderFunctionsCB.js.map
-
-/***/ }),
-
-/***/ 8862:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.XMLBuilderCBImpl = void 0;
-const interfaces_1 = __nccwpck_require__(5385);
-const util_1 = __nccwpck_require__(7061);
-const BuilderFunctions_1 = __nccwpck_require__(9373);
-const algorithm_1 = __nccwpck_require__(6573);
-const infra_1 = __nccwpck_require__(4737);
-const NamespacePrefixMap_1 = __nccwpck_require__(8377);
-const LocalNameSet_1 = __nccwpck_require__(7830);
-const util_2 = __nccwpck_require__(8247);
-const XMLCBWriter_1 = __nccwpck_require__(9341);
-const JSONCBWriter_1 = __nccwpck_require__(6108);
-const YAMLCBWriter_1 = __nccwpck_require__(2233);
-const events_1 = __nccwpck_require__(4434);
-/**
- * Represents a readable XML document stream.
- */
-class XMLBuilderCBImpl extends events_1.EventEmitter {
- static _VoidElementNames = new Set(['area', 'base', 'basefont',
- 'bgsound', 'br', 'col', 'embed', 'frame', 'hr', 'img', 'input', 'keygen',
- 'link', 'menuitem', 'meta', 'param', 'source', 'track', 'wbr']);
- _options;
- _builderOptions;
- _writer;
- _fragment;
- _hasDeclaration = false;
- _docTypeName = "";
- _hasDocumentElement = false;
- _currentElement;
- _currentElementSerialized = false;
- _openTags = [];
- _prefixMap;
- _prefixIndex;
- _ended = false;
- /**
- * Initializes a new instance of `XMLStream`.
- *
- * @param options - stream writer options
- * @param fragment - whether to create fragment stream or a document stream
- *
- * @returns XML stream
- */
- constructor(options, fragment = false) {
- super();
- this._fragment = fragment;
- // provide default options
- this._options = (0, util_1.applyDefaults)(options || {}, interfaces_1.DefaultXMLBuilderCBOptions);
- this._builderOptions = {
- defaultNamespace: this._options.defaultNamespace,
- namespaceAlias: this._options.namespaceAlias
- };
- if (this._options.format === "json") {
- this._writer = new JSONCBWriter_1.JSONCBWriter(this._options);
- }
- else if (this._options.format === "yaml") {
- this._writer = new YAMLCBWriter_1.YAMLCBWriter(this._options);
- }
- else {
- this._writer = new XMLCBWriter_1.XMLCBWriter(this._options);
- }
- // automatically create listeners for callbacks passed via options
- if (this._options.data !== undefined) {
- this.on("data", this._options.data);
- }
- if (this._options.end !== undefined) {
- this.on("end", this._options.end);
- }
- if (this._options.error !== undefined) {
- this.on("error", this._options.error);
- }
- this._prefixMap = new NamespacePrefixMap_1.NamespacePrefixMap();
- this._prefixMap.set("xml", infra_1.namespace.XML);
- this._prefixIndex = { value: 1 };
- this._push(this._writer.frontMatter());
- }
- /** @inheritdoc */
- ele(p1, p2, p3) {
- // parse if JS object or XML or JSON string
- if ((0, util_1.isObject)(p1) || ((0, util_1.isString)(p1) && (/^\s*/g, '>');
- this._push(this._writer.text(markup));
- const lastEl = this._openTags[this._openTags.length - 1];
- // edge case: text on top level.
- if (lastEl) {
- lastEl[lastEl.length - 1] = true;
- }
- return this;
- }
- /** @inheritdoc */
- ins(target, content = '') {
- this._serializeOpenTag(true);
- let node;
- try {
- node = (0, BuilderFunctions_1.fragment)(this._builderOptions).ins(target, content).first().node;
- }
- catch (err) {
- /* istanbul ignore next */
- this.emit("error", err);
- /* istanbul ignore next */
- return this;
- }
- if (this._options.wellFormed && (node.target.indexOf(":") !== -1 || (/^xml$/i).test(node.target))) {
- this.emit("error", new Error("Processing instruction target contains invalid characters (well-formed required)."));
- return this;
- }
- if (this._options.wellFormed && !(0, algorithm_1.xml_isLegalChar)(node.data)) {
- this.emit("error", Error("Processing instruction data contains invalid characters (well-formed required)."));
- return this;
- }
- this._push(this._writer.instruction(node.target, node.data));
- return this;
- }
- /** @inheritdoc */
- dat(content) {
- this._serializeOpenTag(true);
- let node;
- try {
- node = (0, BuilderFunctions_1.fragment)(this._builderOptions).dat(content).first().node;
- }
- catch (err) {
- this.emit("error", err);
- return this;
- }
- this._push(this._writer.cdata(node.data));
- return this;
- }
- /** @inheritdoc */
- dec(options = { version: "1.0" }) {
- if (this._fragment) {
- this.emit("error", Error("Cannot insert an XML declaration into a document fragment."));
- return this;
- }
- if (this._hasDeclaration) {
- this.emit("error", Error("XML declaration is already inserted."));
- return this;
- }
- this._push(this._writer.declaration(options.version || "1.0", options.encoding, options.standalone));
- this._hasDeclaration = true;
- return this;
- }
- /** @inheritdoc */
- dtd(options) {
- if (this._fragment) {
- this.emit("error", Error("Cannot insert a DocType declaration into a document fragment."));
- return this;
- }
- if (this._docTypeName !== "") {
- this.emit("error", new Error("DocType declaration is already inserted."));
- return this;
- }
- if (this._hasDocumentElement) {
- this.emit("error", new Error("Cannot insert DocType declaration after document element."));
- return this;
- }
- let node;
- try {
- node = (0, BuilderFunctions_1.create)().dtd(options).first().node;
- }
- catch (err) {
- this.emit("error", err);
- return this;
- }
- if (this._options.wellFormed && !(0, algorithm_1.xml_isPubidChar)(node.publicId)) {
- this.emit("error", new Error("DocType public identifier does not match PubidChar construct (well-formed required)."));
- return this;
- }
- if (this._options.wellFormed &&
- (!(0, algorithm_1.xml_isLegalChar)(node.systemId) ||
- (node.systemId.indexOf('"') !== -1 && node.systemId.indexOf("'") !== -1))) {
- this.emit("error", new Error("DocType system identifier contains invalid characters (well-formed required)."));
- return this;
- }
- this._docTypeName = options.name;
- this._push(this._writer.docType(options.name, node.publicId, node.systemId));
- return this;
- }
- /** @inheritdoc */
- import(node) {
- const frag = (0, BuilderFunctions_1.fragment)().set(this._options);
- try {
- frag.import(node);
- }
- catch (err) {
- this.emit("error", err);
- return this;
- }
- for (const node of frag.node.childNodes) {
- this._fromNode(node);
- }
- return this;
- }
- /** @inheritdoc */
- up() {
- this._serializeOpenTag(false);
- this._serializeCloseTag();
- return this;
- }
- /** @inheritdoc */
- end() {
- this._serializeOpenTag(false);
- while (this._openTags.length > 0) {
- this._serializeCloseTag();
- }
- this._push(null);
- return this;
- }
- /**
- * Serializes the opening tag of an element node.
- *
- * @param hasChildren - whether the element node has child nodes
- */
- _serializeOpenTag(hasChildren) {
- if (this._currentElementSerialized)
- return;
- if (this._currentElement === undefined)
- return;
- const node = this._currentElement.node;
- if (this._options.wellFormed && (node.localName.indexOf(":") !== -1 ||
- !(0, algorithm_1.xml_isName)(node.localName))) {
- this.emit("error", new Error("Node local name contains invalid characters (well-formed required)."));
- return;
- }
- let qualifiedName = "";
- let ignoreNamespaceDefinitionAttribute = false;
- let map = this._prefixMap.copy();
- let localPrefixesMap = {};
- let localDefaultNamespace = this._recordNamespaceInformation(node, map, localPrefixesMap);
- let inheritedNS = this._openTags.length === 0 ? null : this._openTags[this._openTags.length - 1][1];
- let ns = node.namespaceURI;
- if (ns === null)
- ns = inheritedNS;
- if (inheritedNS === ns) {
- if (localDefaultNamespace !== null) {
- ignoreNamespaceDefinitionAttribute = true;
- }
- if (ns === infra_1.namespace.XML) {
- qualifiedName = "xml:" + node.localName;
- }
- else {
- qualifiedName = node.localName;
- }
- this._writer.beginElement(qualifiedName);
- this._push(this._writer.openTagBegin(qualifiedName));
- }
- else {
- let prefix = node.prefix;
- let candidatePrefix = null;
- if (prefix !== null || ns !== localDefaultNamespace) {
- candidatePrefix = map.get(prefix, ns);
- }
- if (prefix === "xmlns") {
- if (this._options.wellFormed) {
- this.emit("error", new Error("An element cannot have the 'xmlns' prefix (well-formed required)."));
- return;
- }
- candidatePrefix = prefix;
- }
- if (candidatePrefix !== null) {
- qualifiedName = candidatePrefix + ':' + node.localName;
- if (localDefaultNamespace !== null && localDefaultNamespace !== infra_1.namespace.XML) {
- inheritedNS = localDefaultNamespace || null;
- }
- this._writer.beginElement(qualifiedName);
- this._push(this._writer.openTagBegin(qualifiedName));
- }
- else if (prefix !== null) {
- if (prefix in localPrefixesMap) {
- prefix = this._generatePrefix(ns, map, this._prefixIndex);
- }
- map.set(prefix, ns);
- qualifiedName += prefix + ':' + node.localName;
- this._writer.beginElement(qualifiedName);
- this._push(this._writer.openTagBegin(qualifiedName));
- this._push(this._writer.attribute("xmlns:" + prefix, this._serializeAttributeValue(ns, this._options.wellFormed)));
- if (localDefaultNamespace !== null) {
- inheritedNS = localDefaultNamespace || null;
- }
- }
- else if (localDefaultNamespace === null ||
- (localDefaultNamespace !== null && localDefaultNamespace !== ns)) {
- ignoreNamespaceDefinitionAttribute = true;
- qualifiedName += node.localName;
- inheritedNS = ns;
- this._writer.beginElement(qualifiedName);
- this._push(this._writer.openTagBegin(qualifiedName));
- this._push(this._writer.attribute("xmlns", this._serializeAttributeValue(ns, this._options.wellFormed)));
- }
- else {
- qualifiedName += node.localName;
- inheritedNS = ns;
- this._writer.beginElement(qualifiedName);
- this._push(this._writer.openTagBegin(qualifiedName));
- }
- }
- this._serializeAttributes(node, map, this._prefixIndex, localPrefixesMap, ignoreNamespaceDefinitionAttribute, this._options.wellFormed);
- const isHTML = (ns === infra_1.namespace.HTML);
- if (isHTML && !hasChildren &&
- XMLBuilderCBImpl._VoidElementNames.has(node.localName)) {
- this._push(this._writer.openTagEnd(qualifiedName, true, true));
- this._writer.endElement(qualifiedName);
- }
- else if (!isHTML && !hasChildren) {
- this._push(this._writer.openTagEnd(qualifiedName, true, false));
- this._writer.endElement(qualifiedName);
- }
- else {
- this._push(this._writer.openTagEnd(qualifiedName, false, false));
- }
- this._currentElementSerialized = true;
- /**
- * Save qualified name, original inherited ns, original prefix map, and
- * hasChildren flag.
- */
- this._openTags.push([qualifiedName, inheritedNS, this._prefixMap, hasChildren, undefined]);
- /**
- * New values of inherited namespace and prefix map will be used while
- * serializing child nodes. They will be returned to their original values
- * when this node is closed using the _openTags array item we saved above.
- */
- if (this._isPrefixMapModified(this._prefixMap, map)) {
- this._prefixMap = map;
- }
- /**
- * Calls following this will either serialize child nodes or close this tag.
- */
- this._writer.level++;
- }
- /**
- * Serializes the closing tag of an element node.
- */
- _serializeCloseTag() {
- this._writer.level--;
- const lastEle = this._openTags.pop();
- /* istanbul ignore next */
- if (lastEle === undefined) {
- this.emit("error", new Error("Last element is undefined."));
- return;
- }
- const [qualifiedName, ns, map, hasChildren, hasTextPayload] = lastEle;
- /**
- * Restore original values of inherited namespace and prefix map.
- */
- this._prefixMap = map;
- if (!hasChildren)
- return;
- this._push(this._writer.closeTag(qualifiedName, hasTextPayload));
- this._writer.endElement(qualifiedName);
- }
- /**
- * Pushes data to internal buffer.
- *
- * @param data - data
- */
- _push(data) {
- if (data === null) {
- this._ended = true;
- this.emit("end");
- }
- else if (this._ended) {
- this.emit("error", new Error("Cannot push to ended stream."));
- }
- else if (data.length !== 0) {
- this._writer.hasData = true;
- this.emit("data", data, this._writer.level);
- }
- }
- /**
- * Reads and serializes an XML tree.
- *
- * @param node - root node
- */
- _fromNode(node) {
- if (util_2.Guard.isElementNode(node)) {
- const name = node.prefix ? node.prefix + ":" + node.localName : node.localName;
- if (node.namespaceURI !== null) {
- this.ele(node.namespaceURI, name);
- }
- else {
- this.ele(name);
- }
- for (const attr of node.attributes) {
- const name = attr.prefix ? attr.prefix + ":" + attr.localName : attr.localName;
- if (attr.namespaceURI !== null) {
- this.att(attr.namespaceURI, name, attr.value);
- }
- else {
- this.att(name, attr.value);
- }
- }
- for (const child of node.childNodes) {
- this._fromNode(child);
- }
- this.up();
- }
- else if (util_2.Guard.isExclusiveTextNode(node) && node.data) {
- this.txt(node.data);
- }
- else if (util_2.Guard.isCommentNode(node)) {
- this.com(node.data);
- }
- else if (util_2.Guard.isCDATASectionNode(node)) {
- this.dat(node.data);
- }
- else if (util_2.Guard.isProcessingInstructionNode(node)) {
- this.ins(node.target, node.data);
- }
- }
- /**
- * Produces an XML serialization of the attributes of an element node.
- *
- * @param node - node to serialize
- * @param map - namespace prefix map
- * @param prefixIndex - generated namespace prefix index
- * @param localPrefixesMap - local prefixes map
- * @param ignoreNamespaceDefinitionAttribute - whether to ignore namespace
- * attributes
- * @param requireWellFormed - whether to check conformance
- */
- _serializeAttributes(node, map, prefixIndex, localPrefixesMap, ignoreNamespaceDefinitionAttribute, requireWellFormed) {
- const localNameSet = requireWellFormed ? new LocalNameSet_1.LocalNameSet() : undefined;
- for (const attr of node.attributes) {
- // Optimize common case
- if (!requireWellFormed && !ignoreNamespaceDefinitionAttribute && attr.namespaceURI === null) {
- this._push(this._writer.attribute(attr.localName, this._serializeAttributeValue(attr.value, this._options.wellFormed)));
- continue;
- }
- if (requireWellFormed && localNameSet && localNameSet.has(attr.namespaceURI, attr.localName)) {
- this.emit("error", new Error("Element contains duplicate attributes (well-formed required)."));
- return;
- }
- if (requireWellFormed && localNameSet)
- localNameSet.set(attr.namespaceURI, attr.localName);
- let attributeNamespace = attr.namespaceURI;
- let candidatePrefix = null;
- if (attributeNamespace !== null) {
- candidatePrefix = map.get(attr.prefix, attributeNamespace);
- if (attributeNamespace === infra_1.namespace.XMLNS) {
- if (attr.value === infra_1.namespace.XML ||
- (attr.prefix === null && ignoreNamespaceDefinitionAttribute) ||
- (attr.prefix !== null && (!(attr.localName in localPrefixesMap) ||
- localPrefixesMap[attr.localName] !== attr.value) &&
- map.has(attr.localName, attr.value)))
- continue;
- if (requireWellFormed && attr.value === infra_1.namespace.XMLNS) {
- this.emit("error", new Error("XMLNS namespace is reserved (well-formed required)."));
- return;
- }
- if (requireWellFormed && attr.value === '') {
- this.emit("error", new Error("Namespace prefix declarations cannot be used to undeclare a namespace (well-formed required)."));
- return;
- }
- if (attr.prefix === 'xmlns')
- candidatePrefix = 'xmlns';
- /**
- * _Note:_ The (candidatePrefix === null) check is not in the spec.
- * We deviate from the spec here. Otherwise a prefix is generated for
- * all attributes with namespaces.
- */
- }
- else if (candidatePrefix === null) {
- if (attr.prefix !== null &&
- (!map.hasPrefix(attr.prefix) ||
- map.has(attr.prefix, attributeNamespace))) {
- /**
- * Check if we can use the attribute's own prefix.
- * We deviate from the spec here.
- * TODO: This is not an efficient way of searching for prefixes.
- * Follow developments to the spec.
- */
- candidatePrefix = attr.prefix;
- }
- else {
- candidatePrefix = this._generatePrefix(attributeNamespace, map, prefixIndex);
- }
- this._push(this._writer.attribute("xmlns:" + candidatePrefix, this._serializeAttributeValue(attributeNamespace, this._options.wellFormed)));
- }
- }
- if (requireWellFormed && (attr.localName.indexOf(":") !== -1 ||
- !(0, algorithm_1.xml_isName)(attr.localName) ||
- (attr.localName === "xmlns" && attributeNamespace === null))) {
- this.emit("error", new Error("Attribute local name contains invalid characters (well-formed required)."));
- return;
- }
- this._push(this._writer.attribute((candidatePrefix !== null ? candidatePrefix + ":" : "") + attr.localName, this._serializeAttributeValue(attr.value, this._options.wellFormed)));
- }
- }
- /**
- * Produces an XML serialization of an attribute value.
- *
- * @param value - attribute value
- * @param requireWellFormed - whether to check conformance
- */
- _serializeAttributeValue(value, requireWellFormed) {
- if (requireWellFormed && value !== null && !(0, algorithm_1.xml_isLegalChar)(value)) {
- this.emit("error", new Error("Invalid characters in attribute value."));
- return "";
- }
- if (value === null)
- return "";
- return value.replace(/(?!&(lt|gt|amp|apos|quot);)&/g, '&')
- .replace(//g, '>')
- .replace(/"/g, '"');
- }
- /**
- * Records namespace information for the given element and returns the
- * default namespace attribute value.
- *
- * @param node - element node to process
- * @param map - namespace prefix map
- * @param localPrefixesMap - local prefixes map
- */
- _recordNamespaceInformation(node, map, localPrefixesMap) {
- let defaultNamespaceAttrValue = null;
- for (const attr of node.attributes) {
- let attributeNamespace = attr.namespaceURI;
- let attributePrefix = attr.prefix;
- if (attributeNamespace === infra_1.namespace.XMLNS) {
- if (attributePrefix === null) {
- defaultNamespaceAttrValue = attr.value;
- continue;
- }
- else {
- let prefixDefinition = attr.localName;
- let namespaceDefinition = attr.value;
- if (namespaceDefinition === infra_1.namespace.XML) {
- continue;
- }
- if (namespaceDefinition === '') {
- namespaceDefinition = null;
- }
- if (map.has(prefixDefinition, namespaceDefinition)) {
- continue;
- }
- map.set(prefixDefinition, namespaceDefinition);
- localPrefixesMap[prefixDefinition] = namespaceDefinition || '';
- }
- }
- }
- return defaultNamespaceAttrValue;
- }
- /**
- * Generates a new prefix for the given namespace.
- *
- * @param newNamespace - a namespace to generate prefix for
- * @param prefixMap - namespace prefix map
- * @param prefixIndex - generated namespace prefix index
- */
- _generatePrefix(newNamespace, prefixMap, prefixIndex) {
- let generatedPrefix = "ns" + prefixIndex.value;
- prefixIndex.value++;
- prefixMap.set(generatedPrefix, newNamespace);
- return generatedPrefix;
- }
- /**
- * Determines if the namespace prefix map was modified from its original.
- *
- * @param originalMap - original namespace prefix map
- * @param newMap - new namespace prefix map
- */
- _isPrefixMapModified(originalMap, newMap) {
- const items1 = originalMap._items;
- const items2 = newMap._items;
- const nullItems1 = originalMap._nullItems;
- const nullItems2 = newMap._nullItems;
- for (const key in items2) {
- const arr1 = items1[key];
- if (arr1 === undefined)
- return true;
- const arr2 = items2[key];
- if (arr1.length !== arr2.length)
- return true;
- for (let i = 0; i < arr1.length; i++) {
- if (arr1[i] !== arr2[i])
- return true;
- }
- }
- if (nullItems1.length !== nullItems2.length)
- return true;
- for (let i = 0; i < nullItems1.length; i++) {
- if (nullItems1[i] !== nullItems2[i])
- return true;
- }
- return false;
- }
-}
-exports.XMLBuilderCBImpl = XMLBuilderCBImpl;
-//# sourceMappingURL=XMLBuilderCBImpl.js.map
-
-/***/ }),
-
-/***/ 6167:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.XMLBuilderImpl = void 0;
-const interfaces_1 = __nccwpck_require__(5385);
-const util_1 = __nccwpck_require__(7061);
-const writers_1 = __nccwpck_require__(2062);
-const interfaces_2 = __nccwpck_require__(9454);
-const util_2 = __nccwpck_require__(8247);
-const algorithm_1 = __nccwpck_require__(6573);
-const dom_1 = __nccwpck_require__(2869);
-const infra_1 = __nccwpck_require__(4737);
-const readers_1 = __nccwpck_require__(8526);
-/**
- * Represents a wrapper that extends XML nodes to implement easy to use and
- * chainable document builder methods.
- */
-class XMLBuilderImpl {
- _domNode;
- /**
- * Initializes a new instance of `XMLBuilderNodeImpl`.
- *
- * @param domNode - the DOM node to wrap
- */
- constructor(domNode) {
- this._domNode = domNode;
- }
- /** @inheritdoc */
- get node() { return this._domNode; }
- /** @inheritdoc */
- get options() { return this._options; }
- /** @inheritdoc */
- set(options) {
- this._options = (0, util_1.applyDefaults)((0, util_1.applyDefaults)(this._options, options, true), // apply user settings
- interfaces_1.DefaultBuilderOptions); // provide defaults
- return this;
- }
- /** @inheritdoc */
- ele(p1, p2, p3) {
- let namespace;
- let name;
- let attributes;
- if ((0, util_1.isObject)(p1)) {
- // ele(obj: ExpandObject)
- return new readers_1.ObjectReader(this._options).parse(this, p1);
- }
- else if ((0, util_1.isString)(p1) && p1 !== null && /^\s* this.att(attName, attValue), this);
- return this;
- }
- // get primitive values
- if (p1 !== undefined && p1 !== null)
- p1 = (0, util_1.getValue)(p1 + "");
- if (p2 !== undefined && p2 !== null)
- p2 = (0, util_1.getValue)(p2 + "");
- if (p3 !== undefined && p3 !== null)
- p3 = (0, util_1.getValue)(p3 + "");
- let namespace;
- let name;
- let value;
- if ((p1 === null || (0, util_1.isString)(p1)) && (0, util_1.isString)(p2) && (p3 === null || (0, util_1.isString)(p3))) {
- // att(namespace: string, name: string, value: string)
- [namespace, name, value] = [p1, p2, p3];
- }
- else if ((0, util_1.isString)(p1) && (p2 == null || (0, util_1.isString)(p2))) {
- // ele(name: string, value: string)
- [namespace, name, value] = [undefined, p1, p2];
- }
- else {
- throw new Error("Attribute name and value not specified. " + this._debugInfo());
- }
- if (this._options.keepNullAttributes && (value == null)) {
- // keep null attributes
- value = "";
- }
- else if (value == null) {
- // skip null|undefined attributes
- return this;
- }
- if (!util_2.Guard.isElementNode(this.node)) {
- throw new Error("An attribute can only be assigned to an element node.");
- }
- let ele = this.node;
- [namespace, name] = this._extractNamespace(namespace, name, false);
- name = (0, dom_1.sanitizeInput)(name, this._options.invalidCharReplacement);
- namespace = (0, dom_1.sanitizeInput)(namespace, this._options.invalidCharReplacement);
- value = (0, dom_1.sanitizeInput)(value, this._options.invalidCharReplacement);
- const [prefix, localName] = (0, algorithm_1.namespace_extractQName)(name);
- const [elePrefix] = (0, algorithm_1.namespace_extractQName)(ele.prefix ? ele.prefix + ':' + ele.localName : ele.localName);
- // check if this is a namespace declaration attribute
- // assign a new element namespace if it wasn't previously assigned
- let eleNamespace = null;
- if (prefix === "xmlns") {
- namespace = infra_1.namespace.XMLNS;
- if (ele.namespaceURI === null && elePrefix === localName) {
- eleNamespace = value;
- }
- }
- else if (prefix === null && localName === "xmlns" && elePrefix === null) {
- namespace = infra_1.namespace.XMLNS;
- eleNamespace = value;
- }
- // re-create the element node if its namespace changed
- // we can't simply change the namespaceURI since its read-only
- if (eleNamespace !== null) {
- this._updateNamespace(eleNamespace);
- ele = this.node;
- }
- if (namespace !== undefined) {
- ele.setAttributeNS(namespace, name, value);
- }
- else {
- ele.setAttribute(name, value);
- }
- return this;
- }
- /** @inheritdoc */
- removeAtt(p1, p2) {
- if (!util_2.Guard.isElementNode(this.node)) {
- throw new Error("An attribute can only be removed from an element node.");
- }
- // get primitive values
- p1 = (0, util_1.getValue)(p1);
- if (p2 !== undefined) {
- p2 = (0, util_1.getValue)(p2);
- }
- let namespace;
- let name;
- if (p1 !== null && p2 === undefined) {
- name = p1;
- }
- else if ((p1 === null || (0, util_1.isString)(p1)) && p2 !== undefined) {
- namespace = p1;
- name = p2;
- }
- else {
- throw new Error("Attribute namespace must be a string. " + this._debugInfo());
- }
- if ((0, util_1.isArray)(name) || (0, util_1.isSet)(name)) {
- // removeAtt(names: string[])
- // removeAtt(namespace: string, names: string[])
- (0, util_1.forEachArray)(name, attName => namespace === undefined ? this.removeAtt(attName) : this.removeAtt(namespace, attName), this);
- }
- else if (namespace !== undefined) {
- // removeAtt(namespace: string, name: string)
- name = (0, dom_1.sanitizeInput)(name, this._options.invalidCharReplacement);
- namespace = (0, dom_1.sanitizeInput)(namespace, this._options.invalidCharReplacement);
- this.node.removeAttributeNS(namespace, name);
- }
- else {
- // removeAtt(name: string)
- name = (0, dom_1.sanitizeInput)(name, this._options.invalidCharReplacement);
- this.node.removeAttribute(name);
- }
- return this;
- }
- /** @inheritdoc */
- txt(content) {
- if (content === null || content === undefined) {
- if (this._options.keepNullNodes) {
- // keep null nodes
- content = "";
- }
- else {
- // skip null|undefined nodes
- return this;
- }
- }
- const child = this._doc.createTextNode((0, dom_1.sanitizeInput)(content, this._options.invalidCharReplacement));
- this.node.appendChild(child);
- return this;
- }
- /** @inheritdoc */
- com(content) {
- if (content === null || content === undefined) {
- if (this._options.keepNullNodes) {
- // keep null nodes
- content = "";
- }
- else {
- // skip null|undefined nodes
- return this;
- }
- }
- const child = this._doc.createComment((0, dom_1.sanitizeInput)(content, this._options.invalidCharReplacement));
- this.node.appendChild(child);
- return this;
- }
- /** @inheritdoc */
- dat(content) {
- if (content === null || content === undefined) {
- if (this._options.keepNullNodes) {
- // keep null nodes
- content = "";
- }
- else {
- // skip null|undefined nodes
- return this;
- }
- }
- const child = this._doc.createCDATASection((0, dom_1.sanitizeInput)(content, this._options.invalidCharReplacement));
- this.node.appendChild(child);
- return this;
- }
- /** @inheritdoc */
- ins(target, content = '') {
- if (content === null || content === undefined) {
- if (this._options.keepNullNodes) {
- // keep null nodes
- content = "";
- }
- else {
- // skip null|undefined nodes
- return this;
- }
- }
- if ((0, util_1.isArray)(target) || (0, util_1.isSet)(target)) {
- (0, util_1.forEachArray)(target, item => {
- item += "";
- const insIndex = item.indexOf(' ');
- const insTarget = (insIndex === -1 ? item : item.substr(0, insIndex));
- const insValue = (insIndex === -1 ? '' : item.substr(insIndex + 1));
- this.ins(insTarget, insValue);
- }, this);
- }
- else if ((0, util_1.isMap)(target) || (0, util_1.isObject)(target)) {
- (0, util_1.forEachObject)(target, (insTarget, insValue) => this.ins(insTarget, insValue), this);
- }
- else {
- const child = this._doc.createProcessingInstruction((0, dom_1.sanitizeInput)(target, this._options.invalidCharReplacement), (0, dom_1.sanitizeInput)(content, this._options.invalidCharReplacement));
- this.node.appendChild(child);
- }
- return this;
- }
- /** @inheritdoc */
- dec(options) {
- this._options.version = options.version || "1.0";
- this._options.encoding = options.encoding;
- this._options.standalone = options.standalone;
- return this;
- }
- /** @inheritdoc */
- dtd(options) {
- const name = (0, dom_1.sanitizeInput)((options && options.name) || (this._doc.documentElement ? this._doc.documentElement.tagName : "ROOT"), this._options.invalidCharReplacement);
- const pubID = (0, dom_1.sanitizeInput)((options && options.pubID) || "", this._options.invalidCharReplacement);
- const sysID = (0, dom_1.sanitizeInput)((options && options.sysID) || "", this._options.invalidCharReplacement);
- // name must match document element
- if (this._doc.documentElement !== null && name !== this._doc.documentElement.tagName) {
- throw new Error("DocType name does not match document element name.");
- }
- // create doctype node
- const docType = this._doc.implementation.createDocumentType(name, pubID, sysID);
- if (this._doc.doctype !== null) {
- // replace existing doctype
- this._doc.replaceChild(docType, this._doc.doctype);
- }
- else {
- // insert before document element node or append to end
- this._doc.insertBefore(docType, this._doc.documentElement);
- }
- return this;
- }
- /** @inheritdoc */
- import(node) {
- const hostNode = this._domNode;
- const hostDoc = this._doc;
- const importedNode = node.node;
- const updateImportedNodeNs = (clone) => {
- // update namespace of imported node only when not specified
- if (!clone._namespace) {
- const [prefix] = (0, algorithm_1.namespace_extractQName)(clone.prefix ? clone.prefix + ':' + clone.localName : clone.localName);
- const namespace = hostNode.lookupNamespaceURI(prefix);
- new XMLBuilderImpl(clone)._updateNamespace(namespace);
- }
- };
- if (util_2.Guard.isDocumentNode(importedNode)) {
- // import document node
- const elementNode = importedNode.documentElement;
- if (elementNode === null) {
- throw new Error("Imported document has no document element node. " + this._debugInfo());
- }
- const clone = hostDoc.importNode(elementNode, true);
- hostNode.appendChild(clone);
- updateImportedNodeNs(clone);
- }
- else if (util_2.Guard.isDocumentFragmentNode(importedNode)) {
- // import child nodes
- for (const childNode of importedNode.childNodes) {
- const clone = hostDoc.importNode(childNode, true);
- hostNode.appendChild(clone);
- if (util_2.Guard.isElementNode(clone)) {
- updateImportedNodeNs(clone);
- }
- }
- }
- else {
- // import node
- const clone = hostDoc.importNode(importedNode, true);
- hostNode.appendChild(clone);
- if (util_2.Guard.isElementNode(clone)) {
- updateImportedNodeNs(clone);
- }
- }
- return this;
- }
- /** @inheritdoc */
- doc() {
- if (this._doc._isFragment) {
- let node = this.node;
- while (node && node.nodeType !== interfaces_2.NodeType.DocumentFragment) {
- node = node.parentNode;
- }
- /* istanbul ignore next */
- if (node === null) {
- throw new Error("Node has no parent node while searching for document fragment ancestor. " + this._debugInfo());
- }
- return new XMLBuilderImpl(node);
- }
- else {
- return new XMLBuilderImpl(this._doc);
- }
- }
- /** @inheritdoc */
- root() {
- const ele = this._doc.documentElement;
- if (!ele) {
- throw new Error("Document root element is null. " + this._debugInfo());
- }
- return new XMLBuilderImpl(ele);
- }
- /** @inheritdoc */
- up() {
- const parent = this._domNode.parentNode;
- if (!parent) {
- throw new Error("Parent node is null. " + this._debugInfo());
- }
- return new XMLBuilderImpl(parent);
- }
- /** @inheritdoc */
- prev() {
- const node = this._domNode.previousSibling;
- if (!node) {
- throw new Error("Previous sibling node is null. " + this._debugInfo());
- }
- return new XMLBuilderImpl(node);
- }
- /** @inheritdoc */
- next() {
- const node = this._domNode.nextSibling;
- if (!node) {
- throw new Error("Next sibling node is null. " + this._debugInfo());
- }
- return new XMLBuilderImpl(node);
- }
- /** @inheritdoc */
- first() {
- const node = this._domNode.firstChild;
- if (!node) {
- throw new Error("First child node is null. " + this._debugInfo());
- }
- return new XMLBuilderImpl(node);
- }
- /** @inheritdoc */
- last() {
- const node = this._domNode.lastChild;
- if (!node) {
- throw new Error("Last child node is null. " + this._debugInfo());
- }
- return new XMLBuilderImpl(node);
- }
- /** @inheritdoc */
- each(callback, self = false, recursive = false, thisArg) {
- let result = this._getFirstDescendantNode(this._domNode, self, recursive);
- while (result[0]) {
- const nextResult = this._getNextDescendantNode(this._domNode, result[0], recursive, result[1], result[2]);
- callback.call(thisArg, new XMLBuilderImpl(result[0]), result[1], result[2]);
- result = nextResult;
- }
- return this;
- }
- /** @inheritdoc */
- map(callback, self = false, recursive = false, thisArg) {
- let result = [];
- this.each((node, index, level) => result.push(callback.call(thisArg, node, index, level)), self, recursive);
- return result;
- }
- /** @inheritdoc */
- reduce(callback, initialValue, self = false, recursive = false, thisArg) {
- let value = initialValue;
- this.each((node, index, level) => value = callback.call(thisArg, value, node, index, level), self, recursive);
- return value;
- }
- /** @inheritdoc */
- find(predicate, self = false, recursive = false, thisArg) {
- let result = this._getFirstDescendantNode(this._domNode, self, recursive);
- while (result[0]) {
- const builder = new XMLBuilderImpl(result[0]);
- if (predicate.call(thisArg, builder, result[1], result[2])) {
- return builder;
- }
- result = this._getNextDescendantNode(this._domNode, result[0], recursive, result[1], result[2]);
- }
- return undefined;
- }
- /** @inheritdoc */
- filter(predicate, self = false, recursive = false, thisArg) {
- let result = [];
- this.each((node, index, level) => {
- if (predicate.call(thisArg, node, index, level)) {
- result.push(node);
- }
- }, self, recursive);
- return result;
- }
- /** @inheritdoc */
- every(predicate, self = false, recursive = false, thisArg) {
- let result = this._getFirstDescendantNode(this._domNode, self, recursive);
- while (result[0]) {
- const builder = new XMLBuilderImpl(result[0]);
- if (!predicate.call(thisArg, builder, result[1], result[2])) {
- return false;
- }
- result = this._getNextDescendantNode(this._domNode, result[0], recursive, result[1], result[2]);
- }
- return true;
- }
- /** @inheritdoc */
- some(predicate, self = false, recursive = false, thisArg) {
- let result = this._getFirstDescendantNode(this._domNode, self, recursive);
- while (result[0]) {
- const builder = new XMLBuilderImpl(result[0]);
- if (predicate.call(thisArg, builder, result[1], result[2])) {
- return true;
- }
- result = this._getNextDescendantNode(this._domNode, result[0], recursive, result[1], result[2]);
- }
- return false;
- }
- /** @inheritdoc */
- toArray(self = false, recursive = false) {
- let result = [];
- this.each(node => result.push(node), self, recursive);
- return result;
- }
- /** @inheritdoc */
- toString(writerOptions) {
- writerOptions = writerOptions || {};
- if (writerOptions.format === undefined) {
- writerOptions.format = "xml";
- }
- return this._serialize(writerOptions);
- }
- /** @inheritdoc */
- toObject(writerOptions) {
- writerOptions = writerOptions || {};
- if (writerOptions.format === undefined) {
- writerOptions.format = "object";
- }
- return this._serialize(writerOptions);
- }
- /** @inheritdoc */
- end(writerOptions) {
- writerOptions = writerOptions || {};
- if (writerOptions.format === undefined) {
- writerOptions.format = "xml";
- }
- return this.doc()._serialize(writerOptions);
- }
- /**
- * Gets the next descendant of the given node of the tree rooted at `root`
- * in depth-first pre-order. Returns a three-tuple with
- * [descendant, descendant_index, descendant_level].
- *
- * @param root - root node of the tree
- * @param self - whether to visit the current node along with child nodes
- * @param recursive - whether to visit all descendant nodes in tree-order or
- * only the immediate child nodes
- */
- _getFirstDescendantNode(root, self, recursive) {
- if (self)
- return [this._domNode, 0, 0];
- else if (recursive)
- return this._getNextDescendantNode(root, root, recursive, 0, 0);
- else
- return [this._domNode.firstChild, 0, 1];
- }
- /**
- * Gets the next descendant of the given node of the tree rooted at `root`
- * in depth-first pre-order. Returns a three-tuple with
- * [descendant, descendant_index, descendant_level].
- *
- * @param root - root node of the tree
- * @param node - current node
- * @param recursive - whether to visit all descendant nodes in tree-order or
- * only the immediate child nodes
- * @param index - child node index
- * @param level - current depth of the XML tree
- */
- _getNextDescendantNode(root, node, recursive, index, level) {
- if (recursive) {
- // traverse child nodes
- if (node.firstChild)
- return [node.firstChild, 0, level + 1];
- if (node === root)
- return [null, -1, -1];
- // traverse siblings
- if (node.nextSibling)
- return [node.nextSibling, index + 1, level];
- // traverse parent's next sibling
- let parent = node.parentNode;
- while (parent && parent !== root) {
- if (parent.nextSibling)
- return [parent.nextSibling, (0, algorithm_1.tree_index)(parent.nextSibling), level - 1];
- parent = parent.parentNode;
- level--;
- }
- }
- else {
- if (root === node)
- return [node.firstChild, 0, level + 1];
- else
- return [node.nextSibling, index + 1, level];
- }
- return [null, -1, -1];
- }
- /**
- * Converts the node into its string or object representation.
- *
- * @param options - serialization options
- */
- _serialize(writerOptions) {
- if (writerOptions.format === "xml") {
- const writer = new writers_1.XMLWriter(this._options, writerOptions);
- return writer.serialize(this.node);
- }
- else if (writerOptions.format === "map") {
- const writer = new writers_1.MapWriter(this._options, writerOptions);
- return writer.serialize(this.node);
- }
- else if (writerOptions.format === "object") {
- const writer = new writers_1.ObjectWriter(this._options, writerOptions);
- return writer.serialize(this.node);
- }
- else if (writerOptions.format === "json") {
- const writer = new writers_1.JSONWriter(this._options, writerOptions);
- return writer.serialize(this.node);
- }
- else if (writerOptions.format === "yaml") {
- const writer = new writers_1.YAMLWriter(this._options, writerOptions);
- return writer.serialize(this.node);
- }
- else {
- throw new Error("Invalid writer format: " + writerOptions.format + ". " + this._debugInfo());
- }
- }
- /**
- * Extracts a namespace and name from the given string.
- *
- * @param namespace - namespace
- * @param name - a string containing both a name and namespace separated by an
- * `'@'` character
- * @param ele - `true` if this is an element namespace; otherwise `false`
- */
- _extractNamespace(namespace, name, ele) {
- // extract from name
- const atIndex = name.indexOf("@");
- if (atIndex > 0) {
- if (namespace === undefined)
- namespace = name.slice(atIndex + 1);
- name = name.slice(0, atIndex);
- }
- if (namespace === undefined) {
- // look-up default namespace
- namespace = (ele ? this._options.defaultNamespace.ele : this._options.defaultNamespace.att);
- }
- else if (namespace !== null && namespace[0] === "@") {
- // look-up namespace aliases
- const alias = namespace.slice(1);
- namespace = this._options.namespaceAlias[alias];
- if (namespace === undefined) {
- throw new Error("Namespace alias `" + alias + "` is not defined. " + this._debugInfo());
- }
- }
- return [namespace, name];
- }
- /**
- * Updates the element's namespace.
- *
- * @param ns - new namespace
- */
- _updateNamespace(ns) {
- const ele = this._domNode;
- if (util_2.Guard.isElementNode(ele) && ns !== null && ele.namespaceURI !== ns) {
- const [elePrefix, eleLocalName] = (0, algorithm_1.namespace_extractQName)(ele.prefix ? ele.prefix + ':' + ele.localName : ele.localName);
- // re-create the element node if its namespace changed
- // we can't simply change the namespaceURI since its read-only
- const newEle = (0, algorithm_1.create_element)(this._doc, eleLocalName, ns, elePrefix);
- for (const attr of ele.attributes) {
- const attrQName = attr.prefix ? attr.prefix + ':' + attr.localName : attr.localName;
- const [attrPrefix] = (0, algorithm_1.namespace_extractQName)(attrQName);
- let newAttrNS = attr.namespaceURI;
- if (newAttrNS === null && attrPrefix !== null) {
- newAttrNS = ele.lookupNamespaceURI(attrPrefix);
- }
- if (newAttrNS === null) {
- newEle.setAttribute(attrQName, attr.value);
- }
- else {
- newEle.setAttributeNS(newAttrNS, attrQName, attr.value);
- }
- }
- // replace the new node in parent node
- const parent = ele.parentNode;
- /* istanbul ignore next */
- if (parent === null) {
- throw new Error("Parent node is null." + this._debugInfo());
- }
- parent.replaceChild(newEle, ele);
- this._domNode = newEle;
- // check child nodes
- for (const childNode of ele.childNodes) {
- const newChildNode = childNode.cloneNode(true);
- newEle.appendChild(newChildNode);
- if (util_2.Guard.isElementNode(newChildNode) && !newChildNode._namespace) {
- const [newChildNodePrefix] = (0, algorithm_1.namespace_extractQName)(newChildNode.prefix ? newChildNode.prefix + ':' + newChildNode.localName : newChildNode.localName);
- const newChildNodeNS = newEle.lookupNamespaceURI(newChildNodePrefix);
- new XMLBuilderImpl(newChildNode)._updateNamespace(newChildNodeNS);
- }
- }
- }
- }
- /**
- * Returns the document owning this node.
- */
- get _doc() {
- const node = this.node;
- if (util_2.Guard.isDocumentNode(node)) {
- return node;
- }
- else {
- const docNode = node.ownerDocument;
- /* istanbul ignore next */
- if (!docNode)
- throw new Error("Owner document is null. " + this._debugInfo());
- return docNode;
- }
- }
- /**
- * Returns debug information for this node.
- *
- * @param name - node name
- */
- _debugInfo(name) {
- const node = this.node;
- const parentNode = node.parentNode;
- name = name || node.nodeName;
- const parentName = parentNode ? parentNode.nodeName : '';
- if (!parentName) {
- return "node: <" + name + ">";
- }
- else {
- return "node: <" + name + ">, parent: <" + parentName + ">";
- }
- }
- /**
- * Gets or sets builder options.
- */
- get _options() {
- const doc = this._doc;
- /* istanbul ignore next */
- if (doc._xmlBuilderOptions === undefined) {
- throw new Error("Builder options is not set.");
- }
- return doc._xmlBuilderOptions;
- }
- set _options(value) {
- const doc = this._doc;
- doc._xmlBuilderOptions = value;
- }
-}
-exports.XMLBuilderImpl = XMLBuilderImpl;
-//# sourceMappingURL=XMLBuilderImpl.js.map
-
-/***/ }),
-
-/***/ 2869:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.createDocument = createDocument;
-exports.sanitizeInput = sanitizeInput;
-const dom_1 = __nccwpck_require__(6371);
-const dom_2 = __nccwpck_require__(4204);
-const util_1 = __nccwpck_require__(7061);
-dom_2.dom.setFeatures(false);
-/**
- * Creates an XML document without any child nodes.
- */
-function createDocument() {
- const impl = new dom_1.DOMImplementation();
- const doc = impl.createDocument(null, 'root', null);
- /* istanbul ignore else */
- if (doc.documentElement) {
- doc.removeChild(doc.documentElement);
- }
- return doc;
-}
-/**
- * Sanitizes input strings with user supplied replacement characters.
- *
- * @param str - input string
- * @param replacement - replacement character or function
- */
-function sanitizeInput(str, replacement) {
- if (str == null) {
- return str;
- }
- else if (replacement === undefined) {
- return str + "";
- }
- else {
- let result = "";
- str = str + "";
- for (let i = 0; i < str.length; i++) {
- let n = str.charCodeAt(i);
- // #x9 | #xA | #xD | [#x20-#xD7FF] | [#xE000-#xFFFD] | [#x10000-#x10FFFF]
- if (n === 0x9 || n === 0xA || n === 0xD ||
- (n >= 0x20 && n <= 0xD7FF) ||
- (n >= 0xE000 && n <= 0xFFFD)) {
- // valid character - not surrogate pair
- result += str.charAt(i);
- }
- else if (n >= 0xD800 && n <= 0xDBFF && i < str.length - 1) {
- const n2 = str.charCodeAt(i + 1);
- if (n2 >= 0xDC00 && n2 <= 0xDFFF) {
- // valid surrogate pair
- n = (n - 0xD800) * 0x400 + n2 - 0xDC00 + 0x10000;
- result += String.fromCodePoint(n);
- i++;
- }
- else {
- // invalid lone surrogate
- result += (0, util_1.isString)(replacement) ? replacement : replacement(str.charAt(i), i, str);
- }
- }
- else {
- // invalid character
- result += (0, util_1.isString)(replacement) ? replacement : replacement(str.charAt(i), i, str);
- }
- }
- return result;
- }
-}
-//# sourceMappingURL=dom.js.map
-
-/***/ }),
-
-/***/ 957:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.fragmentCB = exports.createCB = exports.convert = exports.fragment = exports.create = exports.builder = exports.XMLBuilderCBImpl = exports.XMLBuilderImpl = void 0;
-var XMLBuilderImpl_1 = __nccwpck_require__(6167);
-Object.defineProperty(exports, "XMLBuilderImpl", ({ enumerable: true, get: function () { return XMLBuilderImpl_1.XMLBuilderImpl; } }));
-var XMLBuilderCBImpl_1 = __nccwpck_require__(8862);
-Object.defineProperty(exports, "XMLBuilderCBImpl", ({ enumerable: true, get: function () { return XMLBuilderCBImpl_1.XMLBuilderCBImpl; } }));
-var BuilderFunctions_1 = __nccwpck_require__(9373);
-Object.defineProperty(exports, "builder", ({ enumerable: true, get: function () { return BuilderFunctions_1.builder; } }));
-Object.defineProperty(exports, "create", ({ enumerable: true, get: function () { return BuilderFunctions_1.create; } }));
-Object.defineProperty(exports, "fragment", ({ enumerable: true, get: function () { return BuilderFunctions_1.fragment; } }));
-Object.defineProperty(exports, "convert", ({ enumerable: true, get: function () { return BuilderFunctions_1.convert; } }));
-var BuilderFunctionsCB_1 = __nccwpck_require__(336);
-Object.defineProperty(exports, "createCB", ({ enumerable: true, get: function () { return BuilderFunctionsCB_1.createCB; } }));
-Object.defineProperty(exports, "fragmentCB", ({ enumerable: true, get: function () { return BuilderFunctionsCB_1.fragmentCB; } }));
-//# sourceMappingURL=index.js.map
-
-/***/ }),
-
-/***/ 6032:
-/***/ ((__unused_webpack_module, exports) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.nonEntityAmpersandRegex = void 0;
-exports.nonEntityAmpersandRegex = /&(?![A-Za-z]+;|#\d+;)/g;
-//# sourceMappingURL=constants.js.map
-
-/***/ }),
-
-/***/ 4697:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-var __webpack_unused_export__;
-
-__webpack_unused_export__ = ({ value: true });
-__webpack_unused_export__ = __webpack_unused_export__ = __webpack_unused_export__ = __webpack_unused_export__ = exports.vt = __webpack_unused_export__ = void 0;
-var builder_1 = __nccwpck_require__(957);
-__webpack_unused_export__ = ({ enumerable: true, get: function () { return builder_1.builder; } });
-Object.defineProperty(exports, "vt", ({ enumerable: true, get: function () { return builder_1.create; } }));
-__webpack_unused_export__ = ({ enumerable: true, get: function () { return builder_1.fragment; } });
-__webpack_unused_export__ = ({ enumerable: true, get: function () { return builder_1.convert; } });
-__webpack_unused_export__ = ({ enumerable: true, get: function () { return builder_1.createCB; } });
-__webpack_unused_export__ = ({ enumerable: true, get: function () { return builder_1.fragmentCB; } });
-//# sourceMappingURL=index.js.map
-
-/***/ }),
-
-/***/ 5385:
-/***/ ((__unused_webpack_module, exports) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.DefaultXMLBuilderCBOptions = exports.XMLBuilderOptionKeys = exports.DefaultBuilderOptions = void 0;
-/**
- * Defines default values for builder options.
- */
-exports.DefaultBuilderOptions = {
- version: "1.0",
- encoding: undefined,
- standalone: undefined,
- keepNullNodes: false,
- keepNullAttributes: false,
- ignoreConverters: false,
- skipWhitespaceOnlyText: true,
- convert: {
- att: "@",
- ins: "?",
- text: "#",
- cdata: "$",
- comment: "!"
- },
- defaultNamespace: {
- ele: undefined,
- att: undefined
- },
- namespaceAlias: {
- html: "http://www.w3.org/1999/xhtml",
- xml: "http://www.w3.org/XML/1998/namespace",
- xmlns: "http://www.w3.org/2000/xmlns/",
- mathml: "http://www.w3.org/1998/Math/MathML",
- svg: "http://www.w3.org/2000/svg",
- xlink: "http://www.w3.org/1999/xlink"
- },
- invalidCharReplacement: undefined,
- parser: undefined
-};
-/**
- * Contains keys of `XMLBuilderOptions`.
- */
-exports.XMLBuilderOptionKeys = new Set(Object.keys(exports.DefaultBuilderOptions));
-/**
- * Defines default values for builder options.
- */
-exports.DefaultXMLBuilderCBOptions = {
- format: "xml",
- wellFormed: false,
- prettyPrint: false,
- indent: " ",
- newline: "\n",
- offset: 0,
- width: 0,
- allowEmptyTags: false,
- spaceBeforeSlash: false,
- keepNullNodes: false,
- keepNullAttributes: false,
- ignoreConverters: false,
- convert: {
- att: "@",
- ins: "?",
- text: "#",
- cdata: "$",
- comment: "!"
- },
- defaultNamespace: {
- ele: undefined,
- att: undefined
- },
- namespaceAlias: {
- html: "http://www.w3.org/1999/xhtml",
- xml: "http://www.w3.org/XML/1998/namespace",
- xmlns: "http://www.w3.org/2000/xmlns/",
- mathml: "http://www.w3.org/1998/Math/MathML",
- svg: "http://www.w3.org/2000/svg",
- xlink: "http://www.w3.org/1999/xlink"
- }
-};
-//# sourceMappingURL=interfaces.js.map
-
-/***/ }),
-
-/***/ 8646:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.BaseReader = void 0;
-const dom_1 = __nccwpck_require__(2869);
-/**
- * Parses XML nodes.
- */
-class BaseReader {
- _builderOptions;
- static _entityTable = {
- "lt": "<",
- "gt": ">",
- "amp": "&",
- "quot": '"',
- "apos": "'",
- };
- /**
- * Initializes a new instance of `BaseReader`.
- *
- * @param builderOptions - XML builder options
- */
- constructor(builderOptions) {
- this._builderOptions = builderOptions;
- if (builderOptions.parser) {
- Object.assign(this, builderOptions.parser);
- }
- }
- _docType(parent, name, publicId, systemId) {
- return parent.dtd({ name: name, pubID: publicId, sysID: systemId });
- }
- _comment(parent, data) {
- return parent.com(data);
- }
- _text(parent, data) {
- return parent.txt(data);
- }
- _instruction(parent, target, data) {
- return parent.ins(target, data);
- }
- _cdata(parent, data) {
- return parent.dat(data);
- }
- _element(parent, namespace, name) {
- return (namespace === undefined ? parent.ele(name) : parent.ele(namespace, name));
- }
- _attribute(parent, namespace, name, value) {
- return (namespace === undefined ? parent.att(name, value) : parent.att(namespace, name, value));
- }
- _sanitize(str) {
- return (0, dom_1.sanitizeInput)(str, this._builderOptions.invalidCharReplacement);
- }
- /**
- * Decodes serialized text.
- *
- * @param text - text value to serialize
- */
- _decodeText(text) {
- if (text == null)
- return text;
- return text.replace(/&(quot|amp|apos|lt|gt);/g, (_match, tag) => BaseReader._entityTable[tag]).replace(/&#(?:x([a-fA-F0-9]+)|([0-9]+));/g, (_match, hexStr, numStr) => String.fromCodePoint(parseInt(hexStr || numStr, hexStr ? 16 : 10)));
- }
- /**
- * Decodes serialized attribute value.
- *
- * @param text - attribute value to serialize
- */
- _decodeAttributeValue(text) {
- return this._decodeText(text);
- }
- /**
- * Main parser function which parses the given object and returns an XMLBuilder.
- *
- * @param node - node to recieve parsed content
- * @param obj - object to parse
- */
- parse(node, obj) {
- return this._parse(node, obj);
- }
- /**
- * Creates a DocType node.
- * The node will be skipped if the function returns `undefined`.
- *
- * @param name - node name
- * @param publicId - public identifier
- * @param systemId - system identifier
- */
- docType(parent, name, publicId, systemId) {
- return this._docType(parent, name, publicId, systemId);
- }
- /**
- * Creates a comment node.
- * The node will be skipped if the function returns `undefined`.
- *
- * @param parent - parent node
- * @param data - node data
- */
- comment(parent, data) {
- return this._comment(parent, data);
- }
- /**
- * Creates a text node.
- * The node will be skipped if the function returns `undefined`.
- *
- * @param parent - parent node
- * @param data - node data
- */
- text(parent, data) {
- return this._text(parent, data);
- }
- /**
- * Creates a processing instruction node.
- * The node will be skipped if the function returns `undefined`.
- *
- * @param parent - parent node
- * @param target - instruction target
- * @param data - node data
- */
- instruction(parent, target, data) {
- return this._instruction(parent, target, data);
- }
- /**
- * Creates a CData section node.
- * The node will be skipped if the function returns `undefined`.
- *
- * @param parent - parent node
- * @param data - node data
- */
- cdata(parent, data) {
- return this._cdata(parent, data);
- }
- /**
- * Creates an element node.
- * The node will be skipped if the function returns `undefined`.
- *
- * @param parent - parent node
- * @param namespace - node namespace
- * @param name - node name
- */
- element(parent, namespace, name) {
- return this._element(parent, namespace, name);
- }
- /**
- * Creates an attribute or namespace declaration.
- * The node will be skipped if the function returns `undefined`.
- *
- * @param parent - parent node
- * @param namespace - node namespace
- * @param name - node name
- * @param value - node value
- */
- attribute(parent, namespace, name, value) {
- return this._attribute(parent, namespace, name, value);
- }
- /**
- * Sanitizes input strings.
- *
- * @param str - input string
- */
- sanitize(str) {
- return this._sanitize(str);
- }
-}
-exports.BaseReader = BaseReader;
-//# sourceMappingURL=BaseReader.js.map
-
-/***/ }),
-
-/***/ 8329:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.JSONReader = void 0;
-const ObjectReader_1 = __nccwpck_require__(908);
-const BaseReader_1 = __nccwpck_require__(8646);
-/**
- * Parses XML nodes from a JSON string.
- */
-class JSONReader extends BaseReader_1.BaseReader {
- /**
- * Parses the given document representation.
- *
- * @param node - node receive parsed XML nodes
- * @param str - JSON string to parse
- */
- _parse(node, str) {
- return new ObjectReader_1.ObjectReader(this._builderOptions).parse(node, JSON.parse(str));
- }
-}
-exports.JSONReader = JSONReader;
-//# sourceMappingURL=JSONReader.js.map
-
-/***/ }),
-
-/***/ 908:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.ObjectReader = void 0;
-const util_1 = __nccwpck_require__(7061);
-const BaseReader_1 = __nccwpck_require__(8646);
-/**
- * Parses XML nodes from objects and arrays.
- * ES6 maps and sets are also supoorted.
- */
-class ObjectReader extends BaseReader_1.BaseReader {
- /**
- * Parses the given document representation.
- *
- * @param node - node receive parsed XML nodes
- * @param obj - object to parse
- */
- _parse(node, obj) {
- const options = this._builderOptions;
- let lastChild = null;
- if ((0, util_1.isFunction)(obj)) {
- // evaluate if function
- lastChild = this.parse(node, obj.call(this));
- }
- else if ((0, util_1.isArray)(obj) || (0, util_1.isSet)(obj)) {
- (0, util_1.forEachArray)(obj, item => lastChild = this.parse(node, item), this);
- }
- else if ((0, util_1.isMap)(obj) || (0, util_1.isObject)(obj)) {
- // expand if object
- (0, util_1.forEachObject)(obj, (key, val) => {
- if ((0, util_1.isFunction)(val)) {
- // evaluate if function
- val = val.call(this);
- }
- if (!options.ignoreConverters && key.indexOf(options.convert.att) === 0) {
- // assign attributes
- if (key === options.convert.att) {
- if ((0, util_1.isArray)(val) || (0, util_1.isSet)(val)) {
- throw new Error("Invalid attribute: " + val.toString() + ". " + node._debugInfo());
- }
- else /* if (isMap(val) || isObject(val)) */ {
- (0, util_1.forEachObject)(val, (attrKey, attrVal) => {
- lastChild = this.attribute(node, undefined, this.sanitize(attrKey), this._decodeAttributeValue(this.sanitize(attrVal))) || lastChild;
- });
- }
- }
- else {
- lastChild = this.attribute(node, undefined, this.sanitize(key.substring(options.convert.att.length)), this._decodeAttributeValue(this.sanitize(val?.toString()))) || lastChild;
- }
- }
- else if (!options.ignoreConverters && key.indexOf(options.convert.text) === 0) {
- // text node
- if ((0, util_1.isMap)(val) || (0, util_1.isObject)(val)) {
- // if the key is #text expand child nodes under this node to support mixed content
- lastChild = this.parse(node, val);
- }
- else {
- lastChild = this.text(node, this._decodeText(this.sanitize(val?.toString()))) || lastChild;
- }
- }
- else if (!options.ignoreConverters && key.indexOf(options.convert.cdata) === 0) {
- // cdata node
- if ((0, util_1.isArray)(val) || (0, util_1.isSet)(val)) {
- (0, util_1.forEachArray)(val, item => lastChild = this.cdata(node, this.sanitize(item)) || lastChild, this);
- }
- else {
- lastChild = this.cdata(node, this.sanitize(val?.toString())) || lastChild;
- }
- }
- else if (!options.ignoreConverters && key.indexOf(options.convert.comment) === 0) {
- // comment node
- if ((0, util_1.isArray)(val) || (0, util_1.isSet)(val)) {
- (0, util_1.forEachArray)(val, item => lastChild = this.comment(node, this.sanitize(item)) || lastChild, this);
- }
- else {
- lastChild = this.comment(node, this.sanitize(val?.toString())) || lastChild;
- }
- }
- else if (!options.ignoreConverters && key.indexOf(options.convert.ins) === 0) {
- // processing instruction
- if ((0, util_1.isString)(val)) {
- const insIndex = val.indexOf(' ');
- const insTarget = (insIndex === -1 ? val : val.substr(0, insIndex));
- const insValue = (insIndex === -1 ? '' : val.substr(insIndex + 1));
- lastChild = this.instruction(node, this.sanitize(insTarget), this.sanitize(insValue)) || lastChild;
- }
- else if ((0, util_1.isArray)(val) || (0, util_1.isSet)(val)) {
- (0, util_1.forEachArray)(val, item => {
- const insIndex = item.indexOf(' ');
- const insTarget = (insIndex === -1 ? item : item.substr(0, insIndex));
- const insValue = (insIndex === -1 ? '' : item.substr(insIndex + 1));
- lastChild = this.instruction(node, this.sanitize(insTarget), this.sanitize(insValue)) || lastChild;
- }, this);
- }
- else /* if (isMap(target) || isObject(target)) */ {
- (0, util_1.forEachObject)(val, (insTarget, insValue) => lastChild = this.instruction(node, this.sanitize(insTarget), this.sanitize(insValue)) || lastChild, this);
- }
- }
- else if (((0, util_1.isArray)(val) || (0, util_1.isSet)(val)) && (0, util_1.isEmpty)(val)) {
- // skip empty arrays
- }
- else if (((0, util_1.isMap)(val) || (0, util_1.isObject)(val)) && (0, util_1.isEmpty)(val)) {
- // empty objects produce one node
- lastChild = this.element(node, undefined, this.sanitize(key)) || lastChild;
- }
- else if (!options.keepNullNodes && (val == null)) {
- // skip null and undefined nodes
- }
- else if ((0, util_1.isArray)(val) || (0, util_1.isSet)(val)) {
- // expand list by creating child nodes
- (0, util_1.forEachArray)(val, item => {
- const childNode = {};
- childNode[key] = item;
- lastChild = this.parse(node, childNode);
- }, this);
- }
- else if ((0, util_1.isMap)(val) || (0, util_1.isObject)(val)) {
- // create a parent node
- const parent = this.element(node, undefined, this.sanitize(key));
- if (parent) {
- lastChild = parent;
- // expand child nodes under parent
- this.parse(parent, val);
- }
- }
- else if (val != null && (!(0, util_1.isString)(val) || val !== '')) {
- // leaf element node with a single text node
- const parent = this.element(node, undefined, this.sanitize(key));
- if (parent) {
- lastChild = parent;
- this.text(parent, this._decodeText(this.sanitize(val?.toString())));
- }
- }
- else {
- // leaf element node
- lastChild = this.element(node, undefined, this.sanitize(key)) || lastChild;
- }
- }, this);
- }
- else if (!options.keepNullNodes && (obj == null)) {
- // skip null and undefined nodes
- }
- else {
- // text node
- lastChild = this.text(node, this._decodeText(this.sanitize(obj?.toString()))) || lastChild;
- }
- return lastChild || node;
- }
-}
-exports.ObjectReader = ObjectReader;
-//# sourceMappingURL=ObjectReader.js.map
-
-/***/ }),
-
-/***/ 5532:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.XMLReader = void 0;
-const XMLStringLexer_1 = __nccwpck_require__(3529);
-const interfaces_1 = __nccwpck_require__(4727);
-const interfaces_2 = __nccwpck_require__(9454);
-const infra_1 = __nccwpck_require__(4737);
-const algorithm_1 = __nccwpck_require__(6573);
-const BaseReader_1 = __nccwpck_require__(8646);
-/**
- * Parses XML nodes from an XML document string.
- */
-class XMLReader extends BaseReader_1.BaseReader {
- /**
- * Parses the given document representation.
- *
- * @param node - node receive parsed XML nodes
- * @param str - XML document string to parse
- */
- _parse(node, str) {
- const lexer = new XMLStringLexer_1.XMLStringLexer(str, { skipWhitespaceOnlyText: this._builderOptions.skipWhitespaceOnlyText });
- let lastChild = node;
- let context = node;
- let token = lexer.nextToken();
- while (token.type !== interfaces_1.TokenType.EOF) {
- switch (token.type) {
- case interfaces_1.TokenType.Declaration:
- const declaration = token;
- const version = this.sanitize(declaration.version);
- if (version !== "1.0") {
- throw new Error("Invalid xml version: " + version);
- }
- const builderOptions = {
- version: version
- };
- if (declaration.encoding) {
- builderOptions.encoding = this.sanitize(declaration.encoding);
- }
- if (declaration.standalone) {
- builderOptions.standalone = (this.sanitize(declaration.standalone) === "yes");
- }
- context.set(builderOptions);
- break;
- case interfaces_1.TokenType.DocType:
- const doctype = token;
- context = this.docType(context, this.sanitize(doctype.name), this.sanitize(doctype.pubId), this.sanitize(doctype.sysId)) || context;
- break;
- case interfaces_1.TokenType.CDATA:
- const cdata = token;
- context = this.cdata(context, this.sanitize(cdata.data)) || context;
- break;
- case interfaces_1.TokenType.Comment:
- const comment = token;
- context = this.comment(context, this.sanitize(comment.data)) || context;
- break;
- case interfaces_1.TokenType.PI:
- const pi = token;
- context = this.instruction(context, this.sanitize(pi.target), this.sanitize(pi.data)) || context;
- break;
- case interfaces_1.TokenType.Text:
- if (context.node.nodeType === interfaces_2.NodeType.Document)
- break;
- const text = token;
- context = this.text(context, this._decodeText(this.sanitize(text.data))) || context;
- break;
- case interfaces_1.TokenType.Element:
- const element = token;
- const elementName = this.sanitize(element.name);
- // inherit namespace from parent
- const [prefix] = (0, algorithm_1.namespace_extractQName)(elementName);
- let namespace = context.node.lookupNamespaceURI(prefix);
- // override namespace if there is a namespace declaration
- // attribute
- // also lookup namespace declaration attributes
- const nsDeclarations = {};
- for (let [attName, attValue] of element.attributes) {
- attName = this.sanitize(attName);
- attValue = this.sanitize(attValue);
- if (attName === "xmlns") {
- namespace = attValue;
- }
- else {
- const [attPrefix, attLocalName] = (0, algorithm_1.namespace_extractQName)(attName);
- if (attPrefix === "xmlns") {
- if (attLocalName === prefix) {
- namespace = attValue;
- }
- nsDeclarations[attLocalName] = attValue;
- }
- }
- }
- // create the DOM element node
- const elementNode = (namespace !== null ?
- this.element(context, namespace, elementName) :
- this.element(context, undefined, elementName));
- if (elementNode === undefined)
- break;
- if (context.node === node.node)
- lastChild = elementNode;
- // assign attributes
- for (let [attName, attValue] of element.attributes) {
- attName = this.sanitize(attName);
- attValue = this.sanitize(attValue);
- const [attPrefix, attLocalName] = (0, algorithm_1.namespace_extractQName)(attName);
- let attNamespace = null;
- if (attPrefix === "xmlns" || (attPrefix === null && attLocalName === "xmlns")) {
- // namespace declaration attribute
- attNamespace = infra_1.namespace.XMLNS;
- }
- else {
- attNamespace = elementNode.node.lookupNamespaceURI(attPrefix);
- if (attNamespace !== null && elementNode.node.isDefaultNamespace(attNamespace)) {
- attNamespace = null;
- }
- else if (attNamespace === null && attPrefix !== null) {
- attNamespace = nsDeclarations[attPrefix] || null;
- }
- }
- if (attNamespace !== null)
- this.attribute(elementNode, attNamespace, attName, this._decodeAttributeValue(attValue));
- else
- this.attribute(elementNode, undefined, attName, this._decodeAttributeValue(attValue));
- }
- if (!element.selfClosing) {
- context = elementNode;
- }
- break;
- case interfaces_1.TokenType.ClosingTag:
- /* istanbul ignore else */
- if (context.node.parentNode) {
- context = context.up();
- }
- break;
- }
- token = lexer.nextToken();
- }
- return lastChild;
- }
-}
-exports.XMLReader = XMLReader;
-//# sourceMappingURL=XMLReader.js.map
-
-/***/ }),
-
-/***/ 7288:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.YAMLReader = void 0;
-const ObjectReader_1 = __nccwpck_require__(908);
-const BaseReader_1 = __nccwpck_require__(8646);
-const js_yaml_1 = __nccwpck_require__(8771);
-/**
- * Parses XML nodes from a YAML string.
- */
-class YAMLReader extends BaseReader_1.BaseReader {
- /**
- * Parses the given document representation.
- *
- * @param node - node receive parsed XML nodes
- * @param str - YAML string to parse
- */
- _parse(node, str) {
- const result = (0, js_yaml_1.load)(str);
- /* istanbul ignore next */
- if (result === undefined) {
- throw new Error("Unable to parse YAML document.");
- }
- return new ObjectReader_1.ObjectReader(this._builderOptions).parse(node, result);
- }
-}
-exports.YAMLReader = YAMLReader;
-//# sourceMappingURL=YAMLReader.js.map
-
-/***/ }),
-
-/***/ 8526:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.YAMLReader = exports.JSONReader = exports.ObjectReader = exports.XMLReader = void 0;
-var XMLReader_1 = __nccwpck_require__(5532);
-Object.defineProperty(exports, "XMLReader", ({ enumerable: true, get: function () { return XMLReader_1.XMLReader; } }));
-var ObjectReader_1 = __nccwpck_require__(908);
-Object.defineProperty(exports, "ObjectReader", ({ enumerable: true, get: function () { return ObjectReader_1.ObjectReader; } }));
-var JSONReader_1 = __nccwpck_require__(8329);
-Object.defineProperty(exports, "JSONReader", ({ enumerable: true, get: function () { return JSONReader_1.JSONReader; } }));
-var YAMLReader_1 = __nccwpck_require__(7288);
-Object.defineProperty(exports, "YAMLReader", ({ enumerable: true, get: function () { return YAMLReader_1.YAMLReader; } }));
-//# sourceMappingURL=index.js.map
-
-/***/ }),
-
-/***/ 9099:
-/***/ ((__unused_webpack_module, exports) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.BaseCBWriter = void 0;
-/**
- * Pre-serializes XML nodes.
- */
-class BaseCBWriter {
- _builderOptions;
- _writerOptions;
- /**
- * Gets the current depth of the XML tree.
- */
- level = 0;
- /**
- * Determines whether any data has been written.
- */
- hasData;
- /**
- * Initializes a new instance of `BaseCBWriter`.
- *
- * @param builderOptions - XML builder options
- */
- constructor(builderOptions) {
- this._builderOptions = builderOptions;
- this._writerOptions = builderOptions;
- }
-}
-exports.BaseCBWriter = BaseCBWriter;
-//# sourceMappingURL=BaseCBWriter.js.map
-
-/***/ }),
-
-/***/ 4726:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.BaseWriter = void 0;
-const interfaces_1 = __nccwpck_require__(9454);
-const LocalNameSet_1 = __nccwpck_require__(7830);
-const NamespacePrefixMap_1 = __nccwpck_require__(8377);
-const infra_1 = __nccwpck_require__(4737);
-const algorithm_1 = __nccwpck_require__(6573);
-const constants_1 = __nccwpck_require__(6032);
-/**
- * Pre-serializes XML nodes.
- */
-class BaseWriter {
- static _VoidElementNames = new Set(['area', 'base', 'basefont',
- 'bgsound', 'br', 'col', 'embed', 'frame', 'hr', 'img', 'input', 'keygen',
- 'link', 'menuitem', 'meta', 'param', 'source', 'track', 'wbr']);
- _builderOptions;
- _writerOptions;
- /**
- * Initializes a new instance of `BaseWriter`.
- *
- * @param builderOptions - XML builder options
- */
- constructor(builderOptions) {
- this._builderOptions = builderOptions;
- }
- /**
- * Used by derived classes to serialize the XML declaration.
- *
- * @param version - a version number string
- * @param encoding - encoding declaration
- * @param standalone - standalone document declaration
- */
- declaration(version, encoding, standalone) { }
- /**
- * Used by derived classes to serialize a DocType node.
- *
- * @param name - node name
- * @param publicId - public identifier
- * @param systemId - system identifier
- */
- docType(name, publicId, systemId) { }
- /**
- * Used by derived classes to serialize a comment node.
- *
- * @param data - node data
- */
- comment(data) { }
- /**
- * Used by derived classes to serialize a text node.
- *
- * @param data - node data
- */
- text(data) { }
- /**
- * Used by derived classes to serialize a processing instruction node.
- *
- * @param target - instruction target
- * @param data - node data
- */
- instruction(target, data) { }
- /**
- * Used by derived classes to serialize a CData section node.
- *
- * @param data - node data
- */
- cdata(data) { }
- /**
- * Used by derived classes to serialize the beginning of the opening tag of an
- * element node.
- *
- * @param name - node name
- */
- openTagBegin(name) { }
- /**
- * Used by derived classes to serialize the ending of the opening tag of an
- * element node.
- *
- * @param name - node name
- * @param selfClosing - whether the element node is self closing
- * @param voidElement - whether the element node is a HTML void element
- */
- openTagEnd(name, selfClosing, voidElement) { }
- /**
- * Used by derived classes to serialize the closing tag of an element node.
- *
- * @param name - node name
- */
- closeTag(name) { }
- /**
- * Used by derived classes to serialize attributes or namespace declarations.
- *
- * @param attributes - attribute array
- */
- attributes(attributes) {
- for (const attr of attributes) {
- this.attribute(attr[1] === null ? attr[2] : attr[1] + ':' + attr[2], attr[3]);
- }
- }
- /**
- * Used by derived classes to serialize an attribute or namespace declaration.
- *
- * @param name - node name
- * @param value - node value
- */
- attribute(name, value) { }
- /**
- * Used by derived classes to perform any pre-processing steps before starting
- * serializing an element node.
- *
- * @param name - node name
- */
- beginElement(name) { }
- /**
- * Used by derived classes to perform any post-processing steps after
- * completing serializing an element node.
- *
- * @param name - node name
- */
- endElement(name) { }
- /**
- * Gets the current depth of the XML tree.
- */
- level = 0;
- /**
- * Gets the current XML node.
- */
- currentNode;
- /**
- * Produces an XML serialization of the given node. The pre-serializer inserts
- * namespace declarations where necessary and produces qualified names for
- * nodes and attributes.
- *
- * @param node - node to serialize
- * @param requireWellFormed - whether to check conformance
- */
- serializeNode(node, requireWellFormed) {
- const hasNamespaces = (node._nodeDocument !== undefined && node._nodeDocument._hasNamespaces);
- this.level = 0;
- this.currentNode = node;
- if (hasNamespaces) {
- /** From: https://w3c.github.io/DOM-Parsing/#xml-serialization
- *
- * 1. Let namespace be a context namespace with value null.
- * The context namespace tracks the XML serialization algorithm's current
- * default namespace. The context namespace is changed when either an Element
- * Node has a default namespace declaration, or the algorithm generates a
- * default namespace declaration for the Element Node to match its own
- * namespace. The algorithm assumes no namespace (null) to start.
- * 2. Let prefix map be a new namespace prefix map.
- * 3. Add the XML namespace with prefix value "xml" to prefix map.
- * 4. Let prefix index be a generated namespace prefix index with value 1.
- * The generated namespace prefix index is used to generate a new unique
- * prefix value when no suitable existing namespace prefix is available to
- * serialize a node's namespaceURI (or the namespaceURI of one of node's
- * attributes). See the generate a prefix algorithm.
- */
- let namespace = null;
- const prefixMap = new NamespacePrefixMap_1.NamespacePrefixMap();
- prefixMap.set("xml", infra_1.namespace.XML);
- const prefixIndex = { value: 1 };
- /**
- * 5. Return the result of running the XML serialization algorithm on node
- * passing the context namespace namespace, namespace prefix map prefix map,
- * generated namespace prefix index reference to prefix index, and the
- * flag require well-formed. If an exception occurs during the execution
- * of the algorithm, then catch that exception and throw an
- * "InvalidStateError" DOMException.
- */
- this._serializeNodeNS(node, namespace, prefixMap, prefixIndex, requireWellFormed);
- }
- else {
- this._serializeNode(node, requireWellFormed);
- }
- }
- /**
- * Produces an XML serialization of a node.
- *
- * @param node - node to serialize
- * @param namespace - context namespace
- * @param prefixMap - namespace prefix map
- * @param prefixIndex - generated namespace prefix index
- * @param requireWellFormed - whether to check conformance
- */
- _serializeNodeNS(node, namespace, prefixMap, prefixIndex, requireWellFormed) {
- this.currentNode = node;
- switch (node.nodeType) {
- case interfaces_1.NodeType.Element:
- this._serializeElementNS(node, namespace, prefixMap, prefixIndex, requireWellFormed);
- break;
- case interfaces_1.NodeType.Document:
- this._serializeDocumentNS(node, namespace, prefixMap, prefixIndex, requireWellFormed);
- break;
- case interfaces_1.NodeType.Comment:
- this._serializeComment(node, requireWellFormed);
- break;
- case interfaces_1.NodeType.Text:
- this._serializeText(node, requireWellFormed);
- break;
- case interfaces_1.NodeType.DocumentFragment:
- this._serializeDocumentFragmentNS(node, namespace, prefixMap, prefixIndex, requireWellFormed);
- break;
- case interfaces_1.NodeType.DocumentType:
- this._serializeDocumentType(node, requireWellFormed);
- break;
- case interfaces_1.NodeType.ProcessingInstruction:
- this._serializeProcessingInstruction(node, requireWellFormed);
- break;
- case interfaces_1.NodeType.CData:
- this._serializeCData(node, requireWellFormed);
- break;
- default:
- throw new Error(`Unknown node type: ${node.nodeType}`);
- }
- }
- /**
- * Produces an XML serialization of a node.
- *
- * @param node - node to serialize
- * @param requireWellFormed - whether to check conformance
- */
- _serializeNode(node, requireWellFormed) {
- this.currentNode = node;
- switch (node.nodeType) {
- case interfaces_1.NodeType.Element:
- this._serializeElement(node, requireWellFormed);
- break;
- case interfaces_1.NodeType.Document:
- this._serializeDocument(node, requireWellFormed);
- break;
- case interfaces_1.NodeType.Comment:
- this._serializeComment(node, requireWellFormed);
- break;
- case interfaces_1.NodeType.Text:
- this._serializeText(node, requireWellFormed);
- break;
- case interfaces_1.NodeType.DocumentFragment:
- this._serializeDocumentFragment(node, requireWellFormed);
- break;
- case interfaces_1.NodeType.DocumentType:
- this._serializeDocumentType(node, requireWellFormed);
- break;
- case interfaces_1.NodeType.ProcessingInstruction:
- this._serializeProcessingInstruction(node, requireWellFormed);
- break;
- case interfaces_1.NodeType.CData:
- this._serializeCData(node, requireWellFormed);
- break;
- default:
- throw new Error(`Unknown node type: ${node.nodeType}`);
- }
- }
- /**
- * Produces an XML serialization of an element node.
- *
- * @param node - node to serialize
- * @param namespace - context namespace
- * @param prefixMap - namespace prefix map
- * @param prefixIndex - generated namespace prefix index
- * @param requireWellFormed - whether to check conformance
- */
- _serializeElementNS(node, namespace, prefixMap, prefixIndex, requireWellFormed) {
- const attributes = [];
- /**
- * From: https://w3c.github.io/DOM-Parsing/#xml-serializing-an-element-node
- *
- * 1. If the require well-formed flag is set (its value is true), and this
- * node's localName attribute contains the character ":" (U+003A COLON) or
- * does not match the XML Name production, then throw an exception; the
- * serialization of this node would not be a well-formed element.
- */
- if (requireWellFormed && (node.localName.indexOf(":") !== -1 ||
- !(0, algorithm_1.xml_isName)(node.localName))) {
- throw new Error("Node local name contains invalid characters (well-formed required).");
- }
- /**
- * 2. Let markup be the string "<" (U+003C LESS-THAN SIGN).
- * 3. Let qualified name be an empty string.
- * 4. Let skip end tag be a boolean flag with value false.
- * 5. Let ignore namespace definition attribute be a boolean flag with value
- * false.
- * 6. Given prefix map, copy a namespace prefix map and let map be the
- * result.
- * 7. Let local prefixes map be an empty map. The map has unique Node prefix
- * strings as its keys, with corresponding namespaceURI Node values as the
- * map's key values (in this map, the null namespace is represented by the
- * empty string).
- *
- * _Note:_ This map is local to each element. It is used to ensure there
- * are no conflicting prefixes should a new namespace prefix attribute need
- * to be generated. It is also used to enable skipping of duplicate prefix
- * definitions when writing an element's attributes: the map allows the
- * algorithm to distinguish between a prefix in the namespace prefix map
- * that might be locally-defined (to the current Element) and one that is
- * not.
- * 8. Let local default namespace be the result of recording the namespace
- * information for node given map and local prefixes map.
- *
- * _Note:_ The above step will update map with any found namespace prefix
- * definitions, add the found prefix definitions to the local prefixes map
- * and return a local default namespace value defined by a default namespace
- * attribute if one exists. Otherwise it returns null.
- * 9. Let inherited ns be a copy of namespace.
- * 10. Let ns be the value of node's namespaceURI attribute.
- */
- let qualifiedName = '';
- let skipEndTag = false;
- let ignoreNamespaceDefinitionAttribute = false;
- let map = prefixMap.copy();
- let localPrefixesMap = {};
- let localDefaultNamespace = this._recordNamespaceInformation(node, map, localPrefixesMap);
- let inheritedNS = namespace;
- let ns = node.namespaceURI;
- /** 11. If inherited ns is equal to ns, then: */
- if (inheritedNS === ns) {
- /**
- * 11.1. If local default namespace is not null, then set ignore
- * namespace definition attribute to true.
- */
- if (localDefaultNamespace !== null) {
- ignoreNamespaceDefinitionAttribute = true;
- }
- /**
- * 11.2. If ns is the XML namespace, then append to qualified name the
- * concatenation of the string "xml:" and the value of node's localName.
- * 11.3. Otherwise, append to qualified name the value of node's
- * localName. The node's prefix if it exists, is dropped.
- */
- if (ns === infra_1.namespace.XML) {
- qualifiedName = 'xml:' + node.localName;
- }
- else {
- qualifiedName = node.localName;
- }
- /** 11.4. Append the value of qualified name to markup. */
- this.beginElement(qualifiedName);
- this.openTagBegin(qualifiedName);
- }
- else {
- /**
- * 12. Otherwise, inherited ns is not equal to ns (the node's own
- * namespace is different from the context namespace of its parent).
- * Run these sub-steps:
- *
- * 12.1. Let prefix be the value of node's prefix attribute.
- * 12.2. Let candidate prefix be the result of retrieving a preferred
- * prefix string prefix from map given namespace ns. The above may return
- * null if no namespace key ns exists in map.
- */
- let prefix = node.prefix;
- /**
- * We don't need to run "retrieving a preferred prefix string" algorithm if
- * the element has no prefix and its namespace matches to the default
- * namespace.
- * See: https://github.com/web-platform-tests/wpt/pull/16703
- */
- let candidatePrefix = null;
- if (prefix !== null || ns !== localDefaultNamespace) {
- candidatePrefix = map.get(prefix, ns);
- }
- /**
- * 12.3. If the value of prefix matches "xmlns", then run the following
- * steps:
- */
- if (prefix === "xmlns") {
- /**
- * 12.3.1. If the require well-formed flag is set, then throw an error.
- * An Element with prefix "xmlns" will not legally round-trip in a
- * conforming XML parser.
- */
- if (requireWellFormed) {
- throw new Error("An element cannot have the 'xmlns' prefix (well-formed required).");
- }
- /**
- * 12.3.2. Let candidate prefix be the value of prefix.
- */
- candidatePrefix = prefix;
- }
- /**
- * 12.4.Found a suitable namespace prefix: if candidate prefix is not
- * null (a namespace prefix is defined which maps to ns), then:
- */
- if (candidatePrefix !== null) {
- /**
- * The following may serialize a different prefix than the Element's
- * existing prefix if it already had one. However, the retrieving a
- * preferred prefix string algorithm already tried to match the
- * existing prefix if possible.
- *
- * 12.4.1. Append to qualified name the concatenation of candidate
- * prefix, ":" (U+003A COLON), and node's localName. There exists on
- * this node or the node's ancestry a namespace prefix definition that
- * defines the node's namespace.
- * 12.4.2. If the local default namespace is not null (there exists a
- * locally-defined default namespace declaration attribute) and its
- * value is not the XML namespace, then let inherited ns get the value
- * of local default namespace unless the local default namespace is the
- * empty string in which case let it get null (the context namespace
- * is changed to the declared default, rather than this node's own
- * namespace).
- *
- * _Note:_ Any default namespace definitions or namespace prefixes that
- * define the XML namespace are omitted when serializing this node's
- * attributes.
- */
- qualifiedName = candidatePrefix + ':' + node.localName;
- if (localDefaultNamespace !== null && localDefaultNamespace !== infra_1.namespace.XML) {
- inheritedNS = localDefaultNamespace || null;
- }
- /**
- * 12.4.3. Append the value of qualified name to markup.
- */
- this.beginElement(qualifiedName);
- this.openTagBegin(qualifiedName);
- /** 12.5. Otherwise, if prefix is not null, then: */
- }
- else if (prefix !== null) {
- /**
- * _Note:_ By this step, there is no namespace or prefix mapping
- * declaration in this node (or any parent node visited by this
- * algorithm) that defines prefix otherwise the step labelled Found
- * a suitable namespace prefix would have been followed. The sub-steps
- * that follow will create a new namespace prefix declaration for prefix
- * and ensure that prefix does not conflict with an existing namespace
- * prefix declaration of the same localName in node's attribute list.
- *
- * 12.5.1. If the local prefixes map contains a key matching prefix,
- * then let prefix be the result of generating a prefix providing as
- * input map, ns, and prefix index.
- */
- if (prefix in localPrefixesMap) {
- prefix = this._generatePrefix(ns, map, prefixIndex);
- }
- /**
- * 12.5.2. Add prefix to map given namespace ns.
- * 12.5.3. Append to qualified name the concatenation of prefix, ":"
- * (U+003A COLON), and node's localName.
- * 12.5.4. Append the value of qualified name to markup.
- */
- map.set(prefix, ns);
- qualifiedName += prefix + ':' + node.localName;
- this.beginElement(qualifiedName);
- this.openTagBegin(qualifiedName);
- /**
- * 12.5.5. Append the following to markup, in the order listed:
- *
- * _Note:_ The following serializes a namespace prefix declaration for
- * prefix which was just added to the map.
- *
- * 12.5.5.1. " " (U+0020 SPACE);
- * 12.5.5.2. The string "xmlns:";
- * 12.5.5.3. The value of prefix;
- * 12.5.5.4. "="" (U+003D EQUALS SIGN, U+0022 QUOTATION MARK);
- * 12.5.5.5. The result of serializing an attribute value given ns and
- * the require well-formed flag as input;
- * 12.5.5.6. """ (U+0022 QUOTATION MARK).
- */
- attributes.push([null, 'xmlns', prefix,
- this._serializeAttributeValue(ns, requireWellFormed)]);
- /**
- * 12.5.5.7. If local default namespace is not null (there exists a
- * locally-defined default namespace declaration attribute), then
- * let inherited ns get the value of local default namespace unless the
- * local default namespace is the empty string in which case let it get
- * null.
- */
- if (localDefaultNamespace !== null) {
- inheritedNS = localDefaultNamespace || null;
- }
- /**
- * 12.6. Otherwise, if local default namespace is null, or local
- * default namespace is not null and its value is not equal to ns, then:
- */
- }
- else if (localDefaultNamespace === null ||
- (localDefaultNamespace !== null && localDefaultNamespace !== ns)) {
- /**
- * _Note:_ At this point, the namespace for this node still needs to be
- * serialized, but there's no prefix (or candidate prefix) available; the
- * following uses the default namespace declaration to define the
- * namespace--optionally replacing an existing default declaration
- * if present.
- *
- * 12.6.1. Set the ignore namespace definition attribute flag to true.
- * 12.6.2. Append to qualified name the value of node's localName.
- * 12.6.3. Let the value of inherited ns be ns.
- *
- * _Note:_ The new default namespace will be used in the serialization
- * to define this node's namespace and act as the context namespace for
- * its children.
- */
- ignoreNamespaceDefinitionAttribute = true;
- qualifiedName += node.localName;
- inheritedNS = ns;
- /**
- * 12.6.4. Append the value of qualified name to markup.
- */
- this.beginElement(qualifiedName);
- this.openTagBegin(qualifiedName);
- /**
- * 12.6.5. Append the following to markup, in the order listed:
- *
- * _Note:_ The following serializes the new (or replacement) default
- * namespace definition.
- *
- * 12.6.5.1. " " (U+0020 SPACE);
- * 12.6.5.2. The string "xmlns";
- * 12.6.5.3. "="" (U+003D EQUALS SIGN, U+0022 QUOTATION MARK);
- * 12.6.5.4. The result of serializing an attribute value given ns
- * and the require well-formed flag as input;
- * 12.6.5.5. """ (U+0022 QUOTATION MARK).
- */
- attributes.push([null, null, 'xmlns',
- this._serializeAttributeValue(ns, requireWellFormed)]);
- /**
- * 12.7. Otherwise, the node has a local default namespace that matches
- * ns. Append to qualified name the value of node's localName, let the
- * value of inherited ns be ns, and append the value of qualified name
- * to markup.
- */
- }
- else {
- qualifiedName += node.localName;
- inheritedNS = ns;
- this.beginElement(qualifiedName);
- this.openTagBegin(qualifiedName);
- }
- }
- /**
- * 13. Append to markup the result of the XML serialization of node's
- * attributes given map, prefix index, local prefixes map, ignore namespace
- * definition attribute flag, and require well-formed flag.
- */
- attributes.push(...this._serializeAttributesNS(node, map, prefixIndex, localPrefixesMap, ignoreNamespaceDefinitionAttribute, requireWellFormed));
- this.attributes(attributes);
- /**
- * 14. If ns is the HTML namespace, and the node's list of children is
- * empty, and the node's localName matches any one of the following void
- * elements: "area", "base", "basefont", "bgsound", "br", "col", "embed",
- * "frame", "hr", "img", "input", "keygen", "link", "menuitem", "meta",
- * "param", "source", "track", "wbr"; then append the following to markup,
- * in the order listed:
- * 14.1. " " (U+0020 SPACE);
- * 14.2. "/" (U+002F SOLIDUS).
- * and set the skip end tag flag to true.
- * 15. If ns is not the HTML namespace, and the node's list of children is
- * empty, then append "/" (U+002F SOLIDUS) to markup and set the skip end
- * tag flag to true.
- * 16. Append ">" (U+003E GREATER-THAN SIGN) to markup.
- */
- const isHTML = (ns === infra_1.namespace.HTML);
- if (isHTML && node.childNodes.length === 0 &&
- BaseWriter._VoidElementNames.has(node.localName)) {
- this.openTagEnd(qualifiedName, true, true);
- this.endElement(qualifiedName);
- skipEndTag = true;
- }
- else if (!isHTML && node.childNodes.length === 0) {
- this.openTagEnd(qualifiedName, true, false);
- this.endElement(qualifiedName);
- skipEndTag = true;
- }
- else {
- this.openTagEnd(qualifiedName, false, false);
- }
- /**
- * 17. If the value of skip end tag is true, then return the value of markup
- * and skip the remaining steps. The node is a leaf-node.
- */
- if (skipEndTag)
- return;
- /**
- * 18. If ns is the HTML namespace, and the node's localName matches the
- * string "template", then this is a template element. Append to markup the
- * result of XML serializing a DocumentFragment node given the template
- * element's template contents (a DocumentFragment), providing inherited
- * ns, map, prefix index, and the require well-formed flag.
- *
- * _Note:_ This allows template content to round-trip, given the rules for
- * parsing XHTML documents.
- *
- * 19. Otherwise, append to markup the result of running the XML
- * serialization algorithm on each of node's children, in tree order,
- * providing inherited ns, map, prefix index, and the require well-formed
- * flag.
- */
- if (isHTML && node.localName === "template") {
- // TODO: serialize template contents
- }
- else {
- for (const childNode of node.childNodes) {
- this.level++;
- this._serializeNodeNS(childNode, inheritedNS, map, prefixIndex, requireWellFormed);
- this.level--;
- }
- }
- /**
- * 20. Append the following to markup, in the order listed:
- * 20.1. "" (U+003E GREATER-THAN SIGN).
- * 21. Return the value of markup.
- */
- this.closeTag(qualifiedName);
- this.endElement(qualifiedName);
- }
- /**
- * Produces an XML serialization of an element node.
- *
- * @param node - node to serialize
- * @param requireWellFormed - whether to check conformance
- */
- _serializeElement(node, requireWellFormed) {
- /**
- * From: https://w3c.github.io/DOM-Parsing/#xml-serializing-an-element-node
- *
- * 1. If the require well-formed flag is set (its value is true), and this
- * node's localName attribute contains the character ":" (U+003A COLON) or
- * does not match the XML Name production, then throw an exception; the
- * serialization of this node would not be a well-formed element.
- */
- if (requireWellFormed && (node.localName.indexOf(":") !== -1 ||
- !(0, algorithm_1.xml_isName)(node.localName))) {
- throw new Error("Node local name contains invalid characters (well-formed required).");
- }
- /**
- * 2. Let markup be the string "<" (U+003C LESS-THAN SIGN).
- * 3. Let qualified name be an empty string.
- * 4. Let skip end tag be a boolean flag with value false.
- * 5. Let ignore namespace definition attribute be a boolean flag with value
- * false.
- * 6. Given prefix map, copy a namespace prefix map and let map be the
- * result.
- * 7. Let local prefixes map be an empty map. The map has unique Node prefix
- * strings as its keys, with corresponding namespaceURI Node values as the
- * map's key values (in this map, the null namespace is represented by the
- * empty string).
- *
- * _Note:_ This map is local to each element. It is used to ensure there
- * are no conflicting prefixes should a new namespace prefix attribute need
- * to be generated. It is also used to enable skipping of duplicate prefix
- * definitions when writing an element's attributes: the map allows the
- * algorithm to distinguish between a prefix in the namespace prefix map
- * that might be locally-defined (to the current Element) and one that is
- * not.
- * 8. Let local default namespace be the result of recording the namespace
- * information for node given map and local prefixes map.
- *
- * _Note:_ The above step will update map with any found namespace prefix
- * definitions, add the found prefix definitions to the local prefixes map
- * and return a local default namespace value defined by a default namespace
- * attribute if one exists. Otherwise it returns null.
- * 9. Let inherited ns be a copy of namespace.
- * 10. Let ns be the value of node's namespaceURI attribute.
- */
- let skipEndTag = false;
- /** 11. If inherited ns is equal to ns, then: */
- /**
- * 11.1. If local default namespace is not null, then set ignore
- * namespace definition attribute to true.
- */
- /**
- * 11.2. If ns is the XML namespace, then append to qualified name the
- * concatenation of the string "xml:" and the value of node's localName.
- * 11.3. Otherwise, append to qualified name the value of node's
- * localName. The node's prefix if it exists, is dropped.
- */
- const qualifiedName = node.localName;
- /** 11.4. Append the value of qualified name to markup. */
- this.beginElement(qualifiedName);
- this.openTagBegin(qualifiedName);
- /**
- * 13. Append to markup the result of the XML serialization of node's
- * attributes given map, prefix index, local prefixes map, ignore namespace
- * definition attribute flag, and require well-formed flag.
- */
- const attributes = this._serializeAttributes(node, requireWellFormed);
- this.attributes(attributes);
- /**
- * 14. If ns is the HTML namespace, and the node's list of children is
- * empty, and the node's localName matches any one of the following void
- * elements: "area", "base", "basefont", "bgsound", "br", "col", "embed",
- * "frame", "hr", "img", "input", "keygen", "link", "menuitem", "meta",
- * "param", "source", "track", "wbr"; then append the following to markup,
- * in the order listed:
- * 14.1. " " (U+0020 SPACE);
- * 14.2. "/" (U+002F SOLIDUS).
- * and set the skip end tag flag to true.
- * 15. If ns is not the HTML namespace, and the node's list of children is
- * empty, then append "/" (U+002F SOLIDUS) to markup and set the skip end
- * tag flag to true.
- * 16. Append ">" (U+003E GREATER-THAN SIGN) to markup.
- */
- if (!node.hasChildNodes()) {
- this.openTagEnd(qualifiedName, true, false);
- this.endElement(qualifiedName);
- skipEndTag = true;
- }
- else {
- this.openTagEnd(qualifiedName, false, false);
- }
- /**
- * 17. If the value of skip end tag is true, then return the value of markup
- * and skip the remaining steps. The node is a leaf-node.
- */
- if (skipEndTag)
- return;
- /**
- * 18. If ns is the HTML namespace, and the node's localName matches the
- * string "template", then this is a template element. Append to markup the
- * result of XML serializing a DocumentFragment node given the template
- * element's template contents (a DocumentFragment), providing inherited
- * ns, map, prefix index, and the require well-formed flag.
- *
- * _Note:_ This allows template content to round-trip, given the rules for
- * parsing XHTML documents.
- *
- * 19. Otherwise, append to markup the result of running the XML
- * serialization algorithm on each of node's children, in tree order,
- * providing inherited ns, map, prefix index, and the require well-formed
- * flag.
- */
- for (const childNode of node._children) {
- this.level++;
- this._serializeNode(childNode, requireWellFormed);
- this.level--;
- }
- /**
- * 20. Append the following to markup, in the order listed:
- * 20.1. "" (U+003E GREATER-THAN SIGN).
- * 21. Return the value of markup.
- */
- this.closeTag(qualifiedName);
- this.endElement(qualifiedName);
- }
- /**
- * Produces an XML serialization of a document node.
- *
- * @param node - node to serialize
- * @param namespace - context namespace
- * @param prefixMap - namespace prefix map
- * @param prefixIndex - generated namespace prefix index
- * @param requireWellFormed - whether to check conformance
- */
- _serializeDocumentNS(node, namespace, prefixMap, prefixIndex, requireWellFormed) {
- /**
- * If the require well-formed flag is set (its value is true), and this node
- * has no documentElement (the documentElement attribute's value is null),
- * then throw an exception; the serialization of this node would not be a
- * well-formed document.
- */
- if (requireWellFormed && node.documentElement === null) {
- throw new Error("Missing document element (well-formed required).");
- }
- /**
- * Otherwise, run the following steps:
- * 1. Let serialized document be an empty string.
- * 2. For each child child of node, in tree order, run the XML
- * serialization algorithm on the child passing along the provided
- * arguments, and append the result to serialized document.
- *
- * _Note:_ This will serialize any number of ProcessingInstruction and
- * Comment nodes both before and after the Document's documentElement node,
- * including at most one DocumentType node. (Text nodes are not allowed as
- * children of the Document.)
- *
- * 3. Return the value of serialized document.
- */
- for (const childNode of node.childNodes) {
- this._serializeNodeNS(childNode, namespace, prefixMap, prefixIndex, requireWellFormed);
- }
- }
- /**
- * Produces an XML serialization of a document node.
- *
- * @param node - node to serialize
- * @param requireWellFormed - whether to check conformance
- */
- _serializeDocument(node, requireWellFormed) {
- /**
- * If the require well-formed flag is set (its value is true), and this node
- * has no documentElement (the documentElement attribute's value is null),
- * then throw an exception; the serialization of this node would not be a
- * well-formed document.
- */
- if (requireWellFormed && node.documentElement === null) {
- throw new Error("Missing document element (well-formed required).");
- }
- /**
- * Otherwise, run the following steps:
- * 1. Let serialized document be an empty string.
- * 2. For each child child of node, in tree order, run the XML
- * serialization algorithm on the child passing along the provided
- * arguments, and append the result to serialized document.
- *
- * _Note:_ This will serialize any number of ProcessingInstruction and
- * Comment nodes both before and after the Document's documentElement node,
- * including at most one DocumentType node. (Text nodes are not allowed as
- * children of the Document.)
- *
- * 3. Return the value of serialized document.
- */
- for (const childNode of node._children) {
- this._serializeNode(childNode, requireWellFormed);
- }
- }
- /**
- * Produces an XML serialization of a comment node.
- *
- * @param node - node to serialize
- * @param requireWellFormed - whether to check conformance
- */
- _serializeComment(node, requireWellFormed) {
- /**
- * If the require well-formed flag is set (its value is true), and node's
- * data contains characters that are not matched by the XML Char production
- * or contains "--" (two adjacent U+002D HYPHEN-MINUS characters) or that
- * ends with a "-" (U+002D HYPHEN-MINUS) character, then throw an exception;
- * the serialization of this node's data would not be well-formed.
- */
- if (requireWellFormed && (!(0, algorithm_1.xml_isLegalChar)(node.data) ||
- node.data.indexOf("--") !== -1 || node.data.endsWith("-"))) {
- throw new Error("Comment data contains invalid characters (well-formed required).");
- }
- /**
- * Otherwise, return the concatenation of "".
- */
- this.comment(node.data);
- }
- /**
- * Produces an XML serialization of a text node.
- *
- * @param node - node to serialize
- * @param requireWellFormed - whether to check conformance
- * @param level - current depth of the XML tree
- */
- _serializeText(node, requireWellFormed) {
- /**
- * 1. If the require well-formed flag is set (its value is true), and
- * node's data contains characters that are not matched by the XML Char
- * production, then throw an exception; the serialization of this node's
- * data would not be well-formed.
- */
- if (requireWellFormed && !(0, algorithm_1.xml_isLegalChar)(node.data)) {
- throw new Error("Text data contains invalid characters (well-formed required).");
- }
- /**
- * 2. Let markup be the value of node's data.
- * 3. Replace any occurrences of "&" in markup by "&".
- * 4. Replace any occurrences of "<" in markup by "<".
- * 5. Replace any occurrences of ">" in markup by ">".
- * 6. Return the value of markup.
- */
- const markup = node.data.replace(constants_1.nonEntityAmpersandRegex, '&')
- .replace(//g, '>');
- this.text(markup);
- }
- /**
- * Produces an XML serialization of a document fragment node.
- *
- * @param node - node to serialize
- * @param namespace - context namespace
- * @param prefixMap - namespace prefix map
- * @param prefixIndex - generated namespace prefix index
- * @param requireWellFormed - whether to check conformance
- */
- _serializeDocumentFragmentNS(node, namespace, prefixMap, prefixIndex, requireWellFormed) {
- /**
- * 1. Let markup the empty string.
- * 2. For each child child of node, in tree order, run the XML serialization
- * algorithm on the child given namespace, prefix map, a reference to prefix
- * index, and flag require well-formed. Concatenate the result to markup.
- * 3. Return the value of markup.
- */
- for (const childNode of node.childNodes) {
- this._serializeNodeNS(childNode, namespace, prefixMap, prefixIndex, requireWellFormed);
- }
- }
- /**
- * Produces an XML serialization of a document fragment node.
- *
- * @param node - node to serialize
- * @param requireWellFormed - whether to check conformance
- */
- _serializeDocumentFragment(node, requireWellFormed) {
- /**
- * 1. Let markup the empty string.
- * 2. For each child child of node, in tree order, run the XML serialization
- * algorithm on the child given namespace, prefix map, a reference to prefix
- * index, and flag require well-formed. Concatenate the result to markup.
- * 3. Return the value of markup.
- */
- for (const childNode of node._children) {
- this._serializeNode(childNode, requireWellFormed);
- }
- }
- /**
- * Produces an XML serialization of a document type node.
- *
- * @param node - node to serialize
- * @param requireWellFormed - whether to check conformance
- */
- _serializeDocumentType(node, requireWellFormed) {
- /**
- * 1. If the require well-formed flag is true and the node's publicId
- * attribute contains characters that are not matched by the XML PubidChar
- * production, then throw an exception; the serialization of this node
- * would not be a well-formed document type declaration.
- */
- if (requireWellFormed && !(0, algorithm_1.xml_isPubidChar)(node.publicId)) {
- throw new Error("DocType public identifier does not match PubidChar construct (well-formed required).");
- }
- /**
- * 2. If the require well-formed flag is true and the node's systemId
- * attribute contains characters that are not matched by the XML Char
- * production or that contains both a """ (U+0022 QUOTATION MARK) and a
- * "'" (U+0027 APOSTROPHE), then throw an exception; the serialization
- * of this node would not be a well-formed document type declaration.
- */
- if (requireWellFormed &&
- (!(0, algorithm_1.xml_isLegalChar)(node.systemId) ||
- (node.systemId.indexOf('"') !== -1 && node.systemId.indexOf("'") !== -1))) {
- throw new Error("DocType system identifier contains invalid characters (well-formed required).");
- }
- /**
- * 3. Let markup be an empty string.
- * 4. Append the string "" (U+003E GREATER-THAN SIGN) to markup.
- * 11. Return the value of markup.
- */
- this.docType(node.name, node.publicId, node.systemId);
- }
- /**
- * Produces an XML serialization of a processing instruction node.
- *
- * @param node - node to serialize
- * @param requireWellFormed - whether to check conformance
- */
- _serializeProcessingInstruction(node, requireWellFormed) {
- /**
- * 1. If the require well-formed flag is set (its value is true), and node's
- * target contains a ":" (U+003A COLON) character or is an ASCII
- * case-insensitive match for the string "xml", then throw an exception;
- * the serialization of this node's target would not be well-formed.
- */
- if (requireWellFormed && (node.target.indexOf(":") !== -1 || (/^xml$/i).test(node.target))) {
- throw new Error("Processing instruction target contains invalid characters (well-formed required).");
- }
- /**
- * 2. If the require well-formed flag is set (its value is true), and node's
- * data contains characters that are not matched by the XML Char production
- * or contains the string "?>" (U+003F QUESTION MARK,
- * U+003E GREATER-THAN SIGN), then throw an exception; the serialization of
- * this node's data would not be well-formed.
- */
- if (requireWellFormed && (!(0, algorithm_1.xml_isLegalChar)(node.data) ||
- node.data.indexOf("?>") !== -1)) {
- throw new Error("Processing instruction data contains invalid characters (well-formed required).");
- }
- /**
- * 3. Let markup be the concatenation of the following, in the order listed:
- * 3.1. "" (U+003F QUESTION MARK, U+003E GREATER-THAN SIGN).
- * 4. Return the value of markup.
- */
- this.instruction(node.target, node.data);
- }
- /**
- * Produces an XML serialization of a CDATA node.
- *
- * @param node - node to serialize
- * @param requireWellFormed - whether to check conformance
- */
- _serializeCData(node, requireWellFormed) {
- if (requireWellFormed && (node.data.indexOf("]]>") !== -1)) {
- throw new Error("CDATA contains invalid characters (well-formed required).");
- }
- this.cdata(node.data);
- }
- /**
- * Produces an XML serialization of the attributes of an element node.
- *
- * @param node - node to serialize
- * @param map - namespace prefix map
- * @param prefixIndex - generated namespace prefix index
- * @param localPrefixesMap - local prefixes map
- * @param ignoreNamespaceDefinitionAttribute - whether to ignore namespace
- * attributes
- * @param requireWellFormed - whether to check conformance
- */
- _serializeAttributesNS(node, map, prefixIndex, localPrefixesMap, ignoreNamespaceDefinitionAttribute, requireWellFormed) {
- /**
- * 1. Let result be the empty string.
- * 2. Let localname set be a new empty namespace localname set. This
- * localname set will contain tuples of unique attribute namespaceURI and
- * localName pairs, and is populated as each attr is processed. This set is
- * used to [optionally] enforce the well-formed constraint that an element
- * cannot have two attributes with the same namespaceURI and localName.
- * This can occur when two otherwise identical attributes on the same
- * element differ only by their prefix values.
- */
- const result = [];
- const localNameSet = requireWellFormed ? new LocalNameSet_1.LocalNameSet() : undefined;
- /**
- * 3. Loop: For each attribute attr in element's attributes, in the order
- * they are specified in the element's attribute list:
- */
- for (const attr of node.attributes) {
- // Optimize common case
- if (!requireWellFormed && !ignoreNamespaceDefinitionAttribute && attr.namespaceURI === null) {
- result.push([null, null, attr.localName,
- this._serializeAttributeValue(attr.value, requireWellFormed)]);
- continue;
- }
- /**
- * 3.1. If the require well-formed flag is set (its value is true), and the
- * localname set contains a tuple whose values match those of a new tuple
- * consisting of attr's namespaceURI attribute and localName attribute,
- * then throw an exception; the serialization of this attr would fail to
- * produce a well-formed element serialization.
- */
- if (requireWellFormed && localNameSet && localNameSet.has(attr.namespaceURI, attr.localName)) {
- throw new Error("Element contains duplicate attributes (well-formed required).");
- }
- /**
- * 3.2. Create a new tuple consisting of attr's namespaceURI attribute and
- * localName attribute, and add it to the localname set.
- * 3.3. Let attribute namespace be the value of attr's namespaceURI value.
- * 3.4. Let candidate prefix be null.
- */
- if (requireWellFormed && localNameSet)
- localNameSet.set(attr.namespaceURI, attr.localName);
- let attributeNamespace = attr.namespaceURI;
- let candidatePrefix = null;
- /** 3.5. If attribute namespace is not null, then run these sub-steps: */
- if (attributeNamespace !== null) {
- /**
- * 3.5.1. Let candidate prefix be the result of retrieving a preferred
- * prefix string from map given namespace attribute namespace with
- * preferred prefix being attr's prefix value.
- */
- candidatePrefix = map.get(attr.prefix, attributeNamespace);
- /**
- * 3.5.2. If the value of attribute namespace is the XMLNS namespace,
- * then run these steps:
- */
- if (attributeNamespace === infra_1.namespace.XMLNS) {
- /**
- * 3.5.2.1. If any of the following are true, then stop running these
- * steps and goto Loop to visit the next attribute:
- * - the attr's value is the XML namespace;
- * _Note:_ The XML namespace cannot be redeclared and survive
- * round-tripping (unless it defines the prefix "xml"). To avoid this
- * problem, this algorithm always prefixes elements in the XML
- * namespace with "xml" and drops any related definitions as seen
- * in the above condition.
- * - the attr's prefix is null and the ignore namespace definition
- * attribute flag is true (the Element's default namespace attribute
- * should be skipped);
- * - the attr's prefix is not null and either
- * * the attr's localName is not a key contained in the local
- * prefixes map, or
- * * the attr's localName is present in the local prefixes map but
- * the value of the key does not match attr's value
- * and furthermore that the attr's localName (as the prefix to find)
- * is found in the namespace prefix map given the namespace consisting
- * of the attr's value (the current namespace prefix definition was
- * exactly defined previously--on an ancestor element not the current
- * element whose attributes are being processed).
- */
- if (attr.value === infra_1.namespace.XML ||
- (attr.prefix === null && ignoreNamespaceDefinitionAttribute) ||
- (attr.prefix !== null && (!(attr.localName in localPrefixesMap) ||
- localPrefixesMap[attr.localName] !== attr.value) &&
- map.has(attr.localName, attr.value)))
- continue;
- /**
- * 3.5.2.2. If the require well-formed flag is set (its value is true),
- * and the value of attr's value attribute matches the XMLNS
- * namespace, then throw an exception; the serialization of this
- * attribute would produce invalid XML because the XMLNS namespace
- * is reserved and cannot be applied as an element's namespace via
- * XML parsing.
- *
- * _Note:_ DOM APIs do allow creation of elements in the XMLNS
- * namespace but with strict qualifications.
- */
- if (requireWellFormed && attr.value === infra_1.namespace.XMLNS) {
- throw new Error("XMLNS namespace is reserved (well-formed required).");
- }
- /**
- * 3.5.2.3. If the require well-formed flag is set (its value is true),
- * and the value of attr's value attribute is the empty string, then
- * throw an exception; namespace prefix declarations cannot be used
- * to undeclare a namespace (use a default namespace declaration
- * instead).
- */
- if (requireWellFormed && attr.value === '') {
- throw new Error("Namespace prefix declarations cannot be used to undeclare a namespace (well-formed required).");
- }
- /**
- * 3.5.2.4. the attr's prefix matches the string "xmlns", then let
- * candidate prefix be the string "xmlns".
- */
- if (attr.prefix === 'xmlns')
- candidatePrefix = 'xmlns';
- /**
- * 3.5.3. Otherwise, the attribute namespace is not the XMLNS namespace.
- * Run these steps:
- *
- * _Note:_ The (candidatePrefix === null) check is not in the spec.
- * We deviate from the spec here. Otherwise a prefix is generated for
- * all attributes with namespaces.
- */
- }
- else if (candidatePrefix === null) {
- if (attr.prefix !== null &&
- (!map.hasPrefix(attr.prefix) ||
- map.has(attr.prefix, attributeNamespace))) {
- /**
- * Check if we can use the attribute's own prefix.
- * We deviate from the spec here.
- * TODO: This is not an efficient way of searching for prefixes.
- * Follow developments to the spec.
- */
- candidatePrefix = attr.prefix;
- }
- else {
- /**
- * 3.5.3.1. Let candidate prefix be the result of generating a prefix
- * providing map, attribute namespace, and prefix index as input.
- */
- candidatePrefix = this._generatePrefix(attributeNamespace, map, prefixIndex);
- }
- /**
- * 3.5.3.2. Append the following to result, in the order listed:
- * 3.5.3.2.1. " " (U+0020 SPACE);
- * 3.5.3.2.2. The string "xmlns:";
- * 3.5.3.2.3. The value of candidate prefix;
- * 3.5.3.2.4. "="" (U+003D EQUALS SIGN, U+0022 QUOTATION MARK);
- * 3.5.3.2.5. The result of serializing an attribute value given
- * attribute namespace and the require well-formed flag as input;
- * 3.5.3.2.6. """ (U+0022 QUOTATION MARK).
- */
- result.push([null, "xmlns", candidatePrefix,
- this._serializeAttributeValue(attributeNamespace, requireWellFormed)]);
- }
- }
- /**
- * 3.6. Append a " " (U+0020 SPACE) to result.
- * 3.7. If candidate prefix is not null, then append to result the
- * concatenation of candidate prefix with ":" (U+003A COLON).
- */
- let attrName = '';
- if (candidatePrefix !== null) {
- attrName = candidatePrefix;
- }
- /**
- * 3.8. If the require well-formed flag is set (its value is true), and
- * this attr's localName attribute contains the character
- * ":" (U+003A COLON) or does not match the XML Name production or
- * equals "xmlns" and attribute namespace is null, then throw an
- * exception; the serialization of this attr would not be a
- * well-formed attribute.
- */
- if (requireWellFormed && (attr.localName.indexOf(":") !== -1 ||
- !(0, algorithm_1.xml_isName)(attr.localName) ||
- (attr.localName === "xmlns" && attributeNamespace === null))) {
- throw new Error("Attribute local name contains invalid characters (well-formed required).");
- }
- /**
- * 3.9. Append the following strings to result, in the order listed:
- * 3.9.1. The value of attr's localName;
- * 3.9.2. "="" (U+003D EQUALS SIGN, U+0022 QUOTATION MARK);
- * 3.9.3. The result of serializing an attribute value given attr's value
- * attribute and the require well-formed flag as input;
- * 3.9.4. """ (U+0022 QUOTATION MARK).
- */
- result.push([attributeNamespace, candidatePrefix, attr.localName,
- this._serializeAttributeValue(attr.value, requireWellFormed)]);
- }
- /**
- * 4. Return the value of result.
- */
- return result;
- }
- /**
- * Produces an XML serialization of the attributes of an element node.
- *
- * @param node - node to serialize
- * @param requireWellFormed - whether to check conformance
- */
- _serializeAttributes(node, requireWellFormed) {
- /**
- * 1. Let result be the empty string.
- * 2. Let localname set be a new empty namespace localname set. This
- * localname set will contain tuples of unique attribute namespaceURI and
- * localName pairs, and is populated as each attr is processed. This set is
- * used to [optionally] enforce the well-formed constraint that an element
- * cannot have two attributes with the same namespaceURI and localName.
- * This can occur when two otherwise identical attributes on the same
- * element differ only by their prefix values.
- */
- const result = [];
- const localNameSet = requireWellFormed ? {} : undefined;
- /**
- * 3. Loop: For each attribute attr in element's attributes, in the order
- * they are specified in the element's attribute list:
- */
- for (const attr of node.attributes) {
- // Optimize common case
- if (!requireWellFormed) {
- result.push([null, null, attr.localName,
- this._serializeAttributeValue(attr.value, requireWellFormed)]);
- continue;
- }
- /**
- * 3.1. If the require well-formed flag is set (its value is true), and the
- * localname set contains a tuple whose values match those of a new tuple
- * consisting of attr's namespaceURI attribute and localName attribute,
- * then throw an exception; the serialization of this attr would fail to
- * produce a well-formed element serialization.
- */
- if (requireWellFormed && localNameSet && (attr.localName in localNameSet)) {
- throw new Error("Element contains duplicate attributes (well-formed required).");
- }
- /**
- * 3.2. Create a new tuple consisting of attr's namespaceURI attribute and
- * localName attribute, and add it to the localname set.
- * 3.3. Let attribute namespace be the value of attr's namespaceURI value.
- * 3.4. Let candidate prefix be null.
- */
- /* istanbul ignore else */
- if (requireWellFormed && localNameSet)
- localNameSet[attr.localName] = true;
- /** 3.5. If attribute namespace is not null, then run these sub-steps: */
- /**
- * 3.6. Append a " " (U+0020 SPACE) to result.
- * 3.7. If candidate prefix is not null, then append to result the
- * concatenation of candidate prefix with ":" (U+003A COLON).
- */
- /**
- * 3.8. If the require well-formed flag is set (its value is true), and
- * this attr's localName attribute contains the character
- * ":" (U+003A COLON) or does not match the XML Name production or
- * equals "xmlns" and attribute namespace is null, then throw an
- * exception; the serialization of this attr would not be a
- * well-formed attribute.
- */
- if (requireWellFormed && (attr.localName.indexOf(":") !== -1 ||
- !(0, algorithm_1.xml_isName)(attr.localName))) {
- throw new Error("Attribute local name contains invalid characters (well-formed required).");
- }
- /**
- * 3.9. Append the following strings to result, in the order listed:
- * 3.9.1. The value of attr's localName;
- * 3.9.2. "="" (U+003D EQUALS SIGN, U+0022 QUOTATION MARK);
- * 3.9.3. The result of serializing an attribute value given attr's value
- * attribute and the require well-formed flag as input;
- * 3.9.4. """ (U+0022 QUOTATION MARK).
- */
- result.push([null, null, attr.localName,
- this._serializeAttributeValue(attr.value, requireWellFormed)]);
- }
- /**
- * 4. Return the value of result.
- */
- return result;
- }
- /**
- * Records namespace information for the given element and returns the
- * default namespace attribute value.
- *
- * @param node - element node to process
- * @param map - namespace prefix map
- * @param localPrefixesMap - local prefixes map
- */
- _recordNamespaceInformation(node, map, localPrefixesMap) {
- /**
- * 1. Let default namespace attr value be null.
- */
- let defaultNamespaceAttrValue = null;
- /**
- * 2. Main: For each attribute attr in element's attributes, in the order
- * they are specified in the element's attribute list:
- */
- for (const attr of node.attributes) {
- /**
- * _Note:_ The following conditional steps find namespace prefixes. Only
- * attributes in the XMLNS namespace are considered (e.g., attributes made
- * to look like namespace declarations via
- * setAttribute("xmlns:pretend-prefix", "pretend-namespace") are not
- * included).
- */
- /** 2.1. Let attribute namespace be the value of attr's namespaceURI value. */
- let attributeNamespace = attr.namespaceURI;
- /** 2.2. Let attribute prefix be the value of attr's prefix. */
- let attributePrefix = attr.prefix;
- /** 2.3. If the attribute namespace is the XMLNS namespace, then: */
- if (attributeNamespace === infra_1.namespace.XMLNS) {
- /**
- * 2.3.1. If attribute prefix is null, then attr is a default namespace
- * declaration. Set the default namespace attr value to attr's value and
- * stop running these steps, returning to Main to visit the next
- * attribute.
- */
- if (attributePrefix === null) {
- defaultNamespaceAttrValue = attr.value;
- continue;
- /**
- * 2.3.2. Otherwise, the attribute prefix is not null and attr is a
- * namespace prefix definition. Run the following steps:
- */
- }
- else {
- /** 2.3.2.1. Let prefix definition be the value of attr's localName. */
- let prefixDefinition = attr.localName;
- /** 2.3.2.2. Let namespace definition be the value of attr's value. */
- let namespaceDefinition = attr.value;
- /**
- * 2.3.2.3. If namespace definition is the XML namespace, then stop
- * running these steps, and return to Main to visit the next
- * attribute.
- *
- * _Note:_ XML namespace definitions in prefixes are completely
- * ignored (in order to avoid unnecessary work when there might be
- * prefix conflicts). XML namespaced elements are always handled
- * uniformly by prefixing (and overriding if necessary) the element's
- * localname with the reserved "xml" prefix.
- */
- if (namespaceDefinition === infra_1.namespace.XML) {
- continue;
- }
- /**
- * 2.3.2.4. If namespace definition is the empty string (the
- * declarative form of having no namespace), then let namespace
- * definition be null instead.
- */
- if (namespaceDefinition === '') {
- namespaceDefinition = null;
- }
- /**
- * 2.3.2.5. If prefix definition is found in map given the namespace
- * namespace definition, then stop running these steps, and return to
- * Main to visit the next attribute.
- *
- * _Note:_ This step avoids adding duplicate prefix definitions for
- * the same namespace in the map. This has the side-effect of avoiding
- * later serialization of duplicate namespace prefix declarations in
- * any descendant nodes.
- */
- if (map.has(prefixDefinition, namespaceDefinition)) {
- continue;
- }
- /**
- * 2.3.2.6. Add the prefix prefix definition to map given namespace
- * namespace definition.
- */
- map.set(prefixDefinition, namespaceDefinition);
- /**
- * 2.3.2.7. Add the value of prefix definition as a new key to the
- * local prefixes map, with the namespace definition as the key's
- * value replacing the value of null with the empty string if
- * applicable.
- */
- localPrefixesMap[prefixDefinition] = namespaceDefinition || '';
- }
- }
- }
- /**
- * 3. Return the value of default namespace attr value.
- *
- * _Note:_ The empty string is a legitimate return value and is not
- * converted to null.
- */
- return defaultNamespaceAttrValue;
- }
- /**
- * Generates a new prefix for the given namespace.
- *
- * @param newNamespace - a namespace to generate prefix for
- * @param prefixMap - namespace prefix map
- * @param prefixIndex - generated namespace prefix index
- */
- _generatePrefix(newNamespace, prefixMap, prefixIndex) {
- /**
- * 1. Let generated prefix be the concatenation of the string "ns" and the
- * current numerical value of prefix index.
- * 2. Let the value of prefix index be incremented by one.
- * 3. Add to map the generated prefix given the new namespace namespace.
- * 4. Return the value of generated prefix.
- */
- const generatedPrefix = "ns" + prefixIndex.value.toString();
- prefixIndex.value++;
- prefixMap.set(generatedPrefix, newNamespace);
- return generatedPrefix;
- }
- /**
- * Produces an XML serialization of an attribute value.
- *
- * @param value - attribute value
- * @param requireWellFormed - whether to check conformance
- */
- _serializeAttributeValue(value, requireWellFormed) {
- /**
- * From: https://w3c.github.io/DOM-Parsing/#dfn-serializing-an-attribute-value
- *
- * 1. If the require well-formed flag is set (its value is true), and
- * attribute value contains characters that are not matched by the XML Char
- * production, then throw an exception; the serialization of this attribute
- * value would fail to produce a well-formed element serialization.
- */
- if (requireWellFormed && value !== null && !(0, algorithm_1.xml_isLegalChar)(value)) {
- throw new Error("Invalid characters in attribute value.");
- }
- /**
- * 2. If attribute value is null, then return the empty string.
- */
- if (value === null)
- return "";
- /**
- * 3. Otherwise, attribute value is a string. Return the value of attribute
- * value, first replacing any occurrences of the following:
- * - "&" with "&"
- * - """ with """
- * - "<" with "<"
- * - ">" with ">"
- * NOTE
- * This matches behavior present in browsers, and goes above and beyond the
- * grammar requirement in the XML specification's AttValue production by
- * also replacing ">" characters.
- */
- return value.replace(constants_1.nonEntityAmpersandRegex, '&')
- .replace(//g, '>')
- .replace(/"/g, '"');
- }
-}
-exports.BaseWriter = BaseWriter;
-//# sourceMappingURL=BaseWriter.js.map
-
-/***/ }),
-
-/***/ 6108:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.JSONCBWriter = void 0;
-const BaseCBWriter_1 = __nccwpck_require__(9099);
-/**
- * Serializes XML nodes.
- */
-class JSONCBWriter extends BaseCBWriter_1.BaseCBWriter {
- _hasChildren = [];
- _additionalLevel = 0;
- /**
- * Initializes a new instance of `JSONCBWriter`.
- *
- * @param builderOptions - XML builder options
- */
- constructor(builderOptions) {
- super(builderOptions);
- }
- /** @inheritdoc */
- frontMatter() {
- return "";
- }
- /** @inheritdoc */
- declaration(version, encoding, standalone) {
- return "";
- }
- /** @inheritdoc */
- docType(name, publicId, systemId) {
- return "";
- }
- /** @inheritdoc */
- comment(data) {
- // { "!": "hello" }
- return this._comma() + this._beginLine() + "{" + this._sep() +
- this._key(this._builderOptions.convert.comment) + this._sep() +
- this._val(data) + this._sep() + "}";
- }
- /** @inheritdoc */
- text(data) {
- // { "#": "hello" }
- return this._comma() + this._beginLine() + "{" + this._sep() +
- this._key(this._builderOptions.convert.text) + this._sep() +
- this._val(data) + this._sep() + "}";
- }
- /** @inheritdoc */
- instruction(target, data) {
- // { "?": "target hello" }
- return this._comma() + this._beginLine() + "{" + this._sep() +
- this._key(this._builderOptions.convert.ins) + this._sep() +
- this._val(data ? target + " " + data : target) + this._sep() + "}";
- }
- /** @inheritdoc */
- cdata(data) {
- // { "$": "hello" }
- return this._comma() + this._beginLine() + "{" + this._sep() +
- this._key(this._builderOptions.convert.cdata) + this._sep() +
- this._val(data) + this._sep() + "}";
- }
- /** @inheritdoc */
- attribute(name, value) {
- // { "@name": "val" }
- return this._comma() + this._beginLine(1) + "{" + this._sep() +
- this._key(this._builderOptions.convert.att + name) + this._sep() +
- this._val(value) + this._sep() + "}";
- }
- /** @inheritdoc */
- openTagBegin(name) {
- // { "node": { "#": [
- let str = this._comma() + this._beginLine() + "{" + this._sep() + this._key(name) + this._sep() + "{";
- this._additionalLevel++;
- this.hasData = true;
- str += this._beginLine() + this._key(this._builderOptions.convert.text) + this._sep() + "[";
- this._hasChildren.push(false);
- return str;
- }
- /** @inheritdoc */
- openTagEnd(name, selfClosing, voidElement) {
- if (selfClosing) {
- let str = this._sep() + "]";
- this._additionalLevel--;
- str += this._beginLine() + "}" + this._sep() + "}";
- return str;
- }
- else {
- return "";
- }
- }
- /** @inheritdoc */
- closeTag(name) {
- // ] } }
- let str = this._beginLine() + "]";
- this._additionalLevel--;
- str += this._beginLine() + "}" + this._sep() + "}";
- return str;
- }
- /** @inheritdoc */
- beginElement(name) { }
- /** @inheritdoc */
- endElement(name) { this._hasChildren.pop(); }
- /**
- * Produces characters to be prepended to a line of string in pretty-print
- * mode.
- */
- _beginLine(additionalOffset = 0) {
- if (this._writerOptions.prettyPrint) {
- return (this.hasData ? this._writerOptions.newline : "") +
- this._indent(this._writerOptions.offset + this.level + additionalOffset);
- }
- else {
- return "";
- }
- }
- /**
- * Produces an indentation string.
- *
- * @param level - depth of the tree
- */
- _indent(level) {
- if (level + this._additionalLevel <= 0) {
- return "";
- }
- else {
- return this._writerOptions.indent.repeat(level + this._additionalLevel);
- }
- }
- /**
- * Produces a comma before a child node if it has previous siblings.
- */
- _comma() {
- const str = (this._hasChildren[this._hasChildren.length - 1] ? "," : "");
- if (this._hasChildren.length > 0) {
- this._hasChildren[this._hasChildren.length - 1] = true;
- }
- return str;
- }
- /**
- * Produces a separator string.
- */
- _sep() {
- return (this._writerOptions.prettyPrint ? " " : "");
- }
- /**
- * Produces a JSON key string delimited with double quotes.
- */
- _key(key) {
- return "\"" + key + "\":";
- }
- /**
- * Produces a JSON value string delimited with double quotes.
- */
- _val(val) {
- return JSON.stringify(val);
- }
-}
-exports.JSONCBWriter = JSONCBWriter;
-//# sourceMappingURL=JSONCBWriter.js.map
-
-/***/ }),
-
-/***/ 2661:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.JSONWriter = void 0;
-const ObjectWriter_1 = __nccwpck_require__(1288);
-const util_1 = __nccwpck_require__(7061);
-const BaseWriter_1 = __nccwpck_require__(4726);
-/**
- * Serializes XML nodes into a JSON string.
- */
-class JSONWriter extends BaseWriter_1.BaseWriter {
- /**
- * Initializes a new instance of `JSONWriter`.
- *
- * @param builderOptions - XML builder options
- * @param writerOptions - serialization options
- */
- constructor(builderOptions, writerOptions) {
- super(builderOptions);
- // provide default options
- this._writerOptions = (0, util_1.applyDefaults)(writerOptions, {
- wellFormed: false,
- prettyPrint: false,
- indent: ' ',
- newline: '\n',
- offset: 0,
- group: false,
- verbose: false
- });
- }
- /**
- * Produces an XML serialization of the given node.
- *
- * @param node - node to serialize
- * @param writerOptions - serialization options
- */
- serialize(node) {
- // convert to object
- const objectWriterOptions = (0, util_1.applyDefaults)(this._writerOptions, {
- format: "object",
- wellFormed: false
- });
- const objectWriter = new ObjectWriter_1.ObjectWriter(this._builderOptions, objectWriterOptions);
- const val = objectWriter.serialize(node);
- // recursively convert object into JSON string
- return this._beginLine(this._writerOptions, 0) + this._convertObject(val, this._writerOptions);
- }
- /**
- * Produces an XML serialization of the given object.
- *
- * @param obj - object to serialize
- * @param options - serialization options
- * @param level - depth of the XML tree
- */
- _convertObject(obj, options, level = 0) {
- let markup = '';
- const isLeaf = this._isLeafNode(obj);
- if ((0, util_1.isArray)(obj)) {
- markup += '[';
- const len = obj.length;
- let i = 0;
- for (const val of obj) {
- markup += this._endLine(options, level + 1) +
- this._beginLine(options, level + 1) +
- this._convertObject(val, options, level + 1);
- if (i < len - 1) {
- markup += ',';
- }
- i++;
- }
- markup += this._endLine(options, level) + this._beginLine(options, level);
- markup += ']';
- }
- else if ((0, util_1.isObject)(obj)) {
- markup += '{';
- const len = (0, util_1.objectLength)(obj);
- let i = 0;
- (0, util_1.forEachObject)(obj, (key, val) => {
- if (isLeaf && options.prettyPrint) {
- markup += ' ';
- }
- else {
- markup += this._endLine(options, level + 1) + this._beginLine(options, level + 1);
- }
- markup += this._key(key);
- if (options.prettyPrint) {
- markup += ' ';
- }
- markup += this._convertObject(val, options, level + 1);
- if (i < len - 1) {
- markup += ',';
- }
- i++;
- }, this);
- if (isLeaf && options.prettyPrint) {
- markup += ' ';
- }
- else {
- markup += this._endLine(options, level) + this._beginLine(options, level);
- }
- markup += '}';
- }
- else {
- markup += this._val(obj);
- }
- return markup;
- }
- /**
- * Produces characters to be prepended to a line of string in pretty-print
- * mode.
- *
- * @param options - serialization options
- * @param level - current depth of the XML tree
- */
- _beginLine(options, level) {
- if (!options.prettyPrint) {
- return '';
- }
- else {
- const indentLevel = options.offset + level + 1;
- if (indentLevel > 0) {
- return new Array(indentLevel).join(options.indent);
- }
- }
- return '';
- }
- /**
- * Produces characters to be appended to a line of string in pretty-print
- * mode.
- *
- * @param options - serialization options
- * @param level - current depth of the XML tree
- */
- _endLine(options, level) {
- if (!options.prettyPrint) {
- return '';
- }
- else {
- return options.newline;
- }
- }
- /**
- * Produces a JSON key string delimited with double quotes.
- */
- _key(key) {
- return "\"" + key + "\":";
- }
- /**
- * Produces a JSON value string delimited with double quotes.
- */
- _val(val) {
- return JSON.stringify(val);
- }
- /**
- * Determines if an object is a leaf node.
- *
- * @param obj
- */
- _isLeafNode(obj) {
- return this._descendantCount(obj) <= 1;
- }
- /**
- * Counts the number of descendants of the given object.
- *
- * @param obj
- * @param count
- */
- _descendantCount(obj, count = 0) {
- if ((0, util_1.isArray)(obj)) {
- (0, util_1.forEachArray)(obj, val => count += this._descendantCount(val, count), this);
- }
- else if ((0, util_1.isObject)(obj)) {
- (0, util_1.forEachObject)(obj, (key, val) => count += this._descendantCount(val, count), this);
- }
- else {
- count++;
- }
- return count;
- }
-}
-exports.JSONWriter = JSONWriter;
-//# sourceMappingURL=JSONWriter.js.map
-
-/***/ }),
-
-/***/ 4703:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.MapWriter = void 0;
-const util_1 = __nccwpck_require__(7061);
-const ObjectWriter_1 = __nccwpck_require__(1288);
-const BaseWriter_1 = __nccwpck_require__(4726);
-/**
- * Serializes XML nodes into ES6 maps and arrays.
- */
-class MapWriter extends BaseWriter_1.BaseWriter {
- /**
- * Initializes a new instance of `MapWriter`.
- *
- * @param builderOptions - XML builder options
- * @param writerOptions - serialization options
- */
- constructor(builderOptions, writerOptions) {
- super(builderOptions);
- // provide default options
- this._writerOptions = (0, util_1.applyDefaults)(writerOptions, {
- format: "map",
- wellFormed: false,
- group: false,
- verbose: false
- });
- }
- /**
- * Produces an XML serialization of the given node.
- *
- * @param node - node to serialize
- */
- serialize(node) {
- // convert to object
- const objectWriterOptions = (0, util_1.applyDefaults)(this._writerOptions, {
- format: "object",
- wellFormed: false,
- verbose: false
- });
- const objectWriter = new ObjectWriter_1.ObjectWriter(this._builderOptions, objectWriterOptions);
- const val = objectWriter.serialize(node);
- // recursively convert object into Map
- return this._convertObject(val);
- }
- /**
- * Recursively converts a JS object into an ES5 map.
- *
- * @param obj - a JS object
- */
- _convertObject(obj) {
- if ((0, util_1.isArray)(obj)) {
- for (let i = 0; i < obj.length; i++) {
- obj[i] = this._convertObject(obj[i]);
- }
- return obj;
- }
- else if ((0, util_1.isObject)(obj)) {
- const map = new Map();
- for (const key in obj) {
- map.set(key, this._convertObject(obj[key]));
- }
- return map;
- }
- else {
- return obj;
- }
- }
-}
-exports.MapWriter = MapWriter;
-//# sourceMappingURL=MapWriter.js.map
-
-/***/ }),
-
-/***/ 1288:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.ObjectWriter = void 0;
-const util_1 = __nccwpck_require__(7061);
-const interfaces_1 = __nccwpck_require__(9454);
-const BaseWriter_1 = __nccwpck_require__(4726);
-/**
- * Serializes XML nodes into objects and arrays.
- */
-class ObjectWriter extends BaseWriter_1.BaseWriter {
- _currentList;
- _currentIndex;
- _listRegister;
- /**
- * Initializes a new instance of `ObjectWriter`.
- *
- * @param builderOptions - XML builder options
- * @param writerOptions - serialization options
- */
- constructor(builderOptions, writerOptions) {
- super(builderOptions);
- this._writerOptions = (0, util_1.applyDefaults)(writerOptions, {
- format: "object",
- wellFormed: false,
- group: false,
- verbose: false
- });
- }
- /**
- * Produces an XML serialization of the given node.
- *
- * @param node - node to serialize
- */
- serialize(node) {
- this._currentList = [];
- this._currentIndex = 0;
- this._listRegister = [this._currentList];
- /**
- * First pass, serialize nodes
- * This creates a list of nodes grouped under node types while preserving
- * insertion order. For example:
- * [
- * root: [
- * node: [
- * { "@" : { "att1": "val1", "att2": "val2" }
- * { "#": "node text" }
- * { childNode: [] }
- * { "#": "more text" }
- * ],
- * node: [
- * { "@" : { "att": "val" }
- * { "#": [ "text line1", "text line2" ] }
- * ]
- * ]
- * ]
- */
- this.serializeNode(node, this._writerOptions.wellFormed);
- /**
- * Second pass, process node lists. Above example becomes:
- * {
- * root: {
- * node: [
- * {
- * "@att1": "val1",
- * "@att2": "val2",
- * "#1": "node text",
- * childNode: {},
- * "#2": "more text"
- * },
- * {
- * "@att": "val",
- * "#": [ "text line1", "text line2" ]
- * }
- * ]
- * }
- * }
- */
- return this._process(this._currentList, this._writerOptions);
- }
- _process(items, options) {
- if (items.length === 0)
- return {};
- // determine if there are non-unique element names
- const namesSeen = {};
- let hasNonUniqueNames = false;
- let textCount = 0;
- let commentCount = 0;
- let instructionCount = 0;
- let cdataCount = 0;
- for (let i = 0; i < items.length; i++) {
- const item = items[i];
- const key = Object.keys(item)[0];
- switch (key) {
- case "@":
- continue;
- case "#":
- textCount++;
- break;
- case "!":
- commentCount++;
- break;
- case "?":
- instructionCount++;
- break;
- case "$":
- cdataCount++;
- break;
- default:
- if (namesSeen[key]) {
- hasNonUniqueNames = true;
- }
- else {
- namesSeen[key] = true;
- }
- break;
- }
- }
- const defAttrKey = this._getAttrKey();
- const defTextKey = this._getNodeKey(interfaces_1.NodeType.Text);
- const defCommentKey = this._getNodeKey(interfaces_1.NodeType.Comment);
- const defInstructionKey = this._getNodeKey(interfaces_1.NodeType.ProcessingInstruction);
- const defCdataKey = this._getNodeKey(interfaces_1.NodeType.CData);
- if (textCount === 1 && items.length === 1 && (0, util_1.isString)(items[0]["#"])) {
- // special case of an element node with a single text node
- return items[0]["#"];
- }
- else if (hasNonUniqueNames) {
- const obj = {};
- // process attributes first
- for (let i = 0; i < items.length; i++) {
- const item = items[i];
- const key = Object.keys(item)[0];
- if (key === "@") {
- const attrs = item["@"];
- const attrKeys = Object.keys(attrs);
- if (!options.group || attrKeys.length === 1) {
- for (const attrName in attrs) {
- obj[defAttrKey + attrName] = attrs[attrName];
- }
- }
- else {
- obj[defAttrKey] = attrs;
- }
- }
- }
- // list contains element nodes with non-unique names
- // return an array with mixed content notation
- const result = [];
- for (let i = 0; i < items.length; i++) {
- const item = items[i];
- const key = Object.keys(item)[0];
- switch (key) {
- case "@":
- // attributes were processed above
- break;
- case "#":
- result.push({ [defTextKey]: item["#"] });
- break;
- case "!":
- result.push({ [defCommentKey]: item["!"] });
- break;
- case "?":
- result.push({ [defInstructionKey]: item["?"] });
- break;
- case "$":
- result.push({ [defCdataKey]: item["$"] });
- break;
- default:
- // element node
- const ele = item;
- if (ele[key].length !== 0 && (0, util_1.isArray)(ele[key][0])) {
- // group of element nodes
- const eleGroup = [];
- const listOfLists = ele[key];
- for (let i = 0; i < listOfLists.length; i++) {
- eleGroup.push(this._process(listOfLists[i], options));
- }
- result.push({ [key]: eleGroup });
- }
- else {
- // single element node
- if (options.verbose) {
- result.push({ [key]: [this._process(ele[key], options)] });
- }
- else {
- result.push({ [key]: this._process(ele[key], options) });
- }
- }
- break;
- }
- }
- obj[defTextKey] = result;
- return obj;
- }
- else {
- // all element nodes have unique names
- // return an object while prefixing data node keys
- let textId = 1;
- let commentId = 1;
- let instructionId = 1;
- let cdataId = 1;
- const obj = {};
- for (let i = 0; i < items.length; i++) {
- const item = items[i];
- const key = Object.keys(item)[0];
- switch (key) {
- case "@":
- const attrs = item["@"];
- const attrKeys = Object.keys(attrs);
- if (!options.group || attrKeys.length === 1) {
- for (const attrName in attrs) {
- obj[defAttrKey + attrName] = attrs[attrName];
- }
- }
- else {
- obj[defAttrKey] = attrs;
- }
- break;
- case "#":
- textId = this._processSpecItem(item["#"], obj, options.group, defTextKey, textCount, textId);
- break;
- case "!":
- commentId = this._processSpecItem(item["!"], obj, options.group, defCommentKey, commentCount, commentId);
- break;
- case "?":
- instructionId = this._processSpecItem(item["?"], obj, options.group, defInstructionKey, instructionCount, instructionId);
- break;
- case "$":
- cdataId = this._processSpecItem(item["$"], obj, options.group, defCdataKey, cdataCount, cdataId);
- break;
- default:
- // element node
- const ele = item;
- if (ele[key].length !== 0 && (0, util_1.isArray)(ele[key][0])) {
- // group of element nodes
- const eleGroup = [];
- const listOfLists = ele[key];
- for (let i = 0; i < listOfLists.length; i++) {
- eleGroup.push(this._process(listOfLists[i], options));
- }
- obj[key] = eleGroup;
- }
- else {
- // single element node
- if (options.verbose) {
- obj[key] = [this._process(ele[key], options)];
- }
- else {
- obj[key] = this._process(ele[key], options);
- }
- }
- break;
- }
- }
- return obj;
- }
- }
- _processSpecItem(item, obj, group, defKey, count, id) {
- if (!group && (0, util_1.isArray)(item) && count + item.length > 2) {
- for (const subItem of item) {
- const key = defKey + (id++).toString();
- obj[key] = subItem;
- }
- }
- else {
- const key = count > 1 ? defKey + (id++).toString() : defKey;
- obj[key] = item;
- }
- return id;
- }
- /** @inheritdoc */
- beginElement(name) {
- const childItems = [];
- if (this._currentList.length === 0) {
- this._currentList.push({ [name]: childItems });
- }
- else {
- const lastItem = this._currentList[this._currentList.length - 1];
- if (this._isElementNode(lastItem, name)) {
- if (lastItem[name].length !== 0 && (0, util_1.isArray)(lastItem[name][0])) {
- const listOfLists = lastItem[name];
- listOfLists.push(childItems);
- }
- else {
- lastItem[name] = [lastItem[name], childItems];
- }
- }
- else {
- this._currentList.push({ [name]: childItems });
- }
- }
- this._currentIndex++;
- if (this._listRegister.length > this._currentIndex) {
- this._listRegister[this._currentIndex] = childItems;
- }
- else {
- this._listRegister.push(childItems);
- }
- this._currentList = childItems;
- }
- /** @inheritdoc */
- endElement() {
- this._currentList = this._listRegister[--this._currentIndex];
- }
- /** @inheritdoc */
- attribute(name, value) {
- if (this._currentList.length === 0) {
- this._currentList.push({ "@": { [name]: value } });
- }
- else {
- const lastItem = this._currentList[this._currentList.length - 1];
- /* istanbul ignore else */
- if (this._isAttrNode(lastItem)) {
- lastItem["@"][name] = value;
- }
- else {
- this._currentList.push({ "@": { [name]: value } });
- }
- }
- }
- /** @inheritdoc */
- comment(data) {
- if (this._currentList.length === 0) {
- this._currentList.push({ "!": data });
- }
- else {
- const lastItem = this._currentList[this._currentList.length - 1];
- if (this._isCommentNode(lastItem)) {
- if ((0, util_1.isArray)(lastItem["!"])) {
- lastItem["!"].push(data);
- }
- else {
- lastItem["!"] = [lastItem["!"], data];
- }
- }
- else {
- this._currentList.push({ "!": data });
- }
- }
- }
- /** @inheritdoc */
- text(data) {
- if (this._currentList.length === 0) {
- this._currentList.push({ "#": data });
- }
- else {
- const lastItem = this._currentList[this._currentList.length - 1];
- if (this._isTextNode(lastItem)) {
- if ((0, util_1.isArray)(lastItem["#"])) {
- lastItem["#"].push(data);
- }
- else {
- lastItem["#"] = [lastItem["#"], data];
- }
- }
- else {
- this._currentList.push({ "#": data });
- }
- }
- }
- /** @inheritdoc */
- instruction(target, data) {
- const value = (data === "" ? target : target + " " + data);
- if (this._currentList.length === 0) {
- this._currentList.push({ "?": value });
- }
- else {
- const lastItem = this._currentList[this._currentList.length - 1];
- if (this._isInstructionNode(lastItem)) {
- if ((0, util_1.isArray)(lastItem["?"])) {
- lastItem["?"].push(value);
- }
- else {
- lastItem["?"] = [lastItem["?"], value];
- }
- }
- else {
- this._currentList.push({ "?": value });
- }
- }
- }
- /** @inheritdoc */
- cdata(data) {
- if (this._currentList.length === 0) {
- this._currentList.push({ "$": data });
- }
- else {
- const lastItem = this._currentList[this._currentList.length - 1];
- if (this._isCDATANode(lastItem)) {
- if ((0, util_1.isArray)(lastItem["$"])) {
- lastItem["$"].push(data);
- }
- else {
- lastItem["$"] = [lastItem["$"], data];
- }
- }
- else {
- this._currentList.push({ "$": data });
- }
- }
- }
- _isAttrNode(x) {
- return "@" in x;
- }
- _isTextNode(x) {
- return "#" in x;
- }
- _isCommentNode(x) {
- return "!" in x;
- }
- _isInstructionNode(x) {
- return "?" in x;
- }
- _isCDATANode(x) {
- return "$" in x;
- }
- _isElementNode(x, name) {
- return name in x;
- }
- /**
- * Returns an object key for an attribute or namespace declaration.
- */
- _getAttrKey() {
- return this._builderOptions.convert.att;
- }
- /**
- * Returns an object key for the given node type.
- *
- * @param nodeType - node type to get a key for
- */
- _getNodeKey(nodeType) {
- switch (nodeType) {
- case interfaces_1.NodeType.Comment:
- return this._builderOptions.convert.comment;
- case interfaces_1.NodeType.Text:
- return this._builderOptions.convert.text;
- case interfaces_1.NodeType.ProcessingInstruction:
- return this._builderOptions.convert.ins;
- case interfaces_1.NodeType.CData:
- return this._builderOptions.convert.cdata;
- /* istanbul ignore next */
- default:
- throw new Error("Invalid node type.");
- }
- }
-}
-exports.ObjectWriter = ObjectWriter;
-//# sourceMappingURL=ObjectWriter.js.map
-
-/***/ }),
-
-/***/ 9341:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.XMLCBWriter = void 0;
-const BaseCBWriter_1 = __nccwpck_require__(9099);
-/**
- * Serializes XML nodes.
- */
-class XMLCBWriter extends BaseCBWriter_1.BaseCBWriter {
- _lineLength = 0;
- /**
- * Initializes a new instance of `XMLCBWriter`.
- *
- * @param builderOptions - XML builder options
- */
- constructor(builderOptions) {
- super(builderOptions);
- }
- /** @inheritdoc */
- frontMatter() {
- return "";
- }
- /** @inheritdoc */
- declaration(version, encoding, standalone) {
- let markup = this._beginLine() + "";
- return markup;
- }
- /** @inheritdoc */
- docType(name, publicId, systemId) {
- let markup = this._beginLine();
- if (publicId && systemId) {
- markup += "";
- }
- else if (publicId) {
- markup += "";
- }
- else if (systemId) {
- markup += "";
- }
- else {
- markup += "";
- }
- return markup;
- }
- /** @inheritdoc */
- comment(data) {
- return this._beginLine() + "";
- }
- /** @inheritdoc */
- text(data) {
- return data;
- }
- /** @inheritdoc */
- instruction(target, data) {
- if (data) {
- return this._beginLine() + "";
- }
- else {
- return this._beginLine() + "";
- }
- }
- /** @inheritdoc */
- cdata(data) {
- return this._beginLine() + "";
- }
- /** @inheritdoc */
- openTagBegin(name) {
- this._lineLength += 1 + name.length;
- return this._beginLine() + "<" + name;
- }
- /** @inheritdoc */
- openTagEnd(name, selfClosing, voidElement) {
- if (voidElement) {
- return " />";
- }
- else if (selfClosing) {
- if (this._writerOptions.allowEmptyTags) {
- return ">";
- }
- else if (this._writerOptions.spaceBeforeSlash) {
- return " />";
- }
- else {
- return "/>";
- }
- }
- else {
- return ">";
- }
- }
- /** @inheritdoc */
- closeTag(name, hasTextPayload) {
- const ending = hasTextPayload ? '' : this._beginLine();
- return ending + "";
- }
- /** @inheritdoc */
- attribute(name, value) {
- let str = name + "=\"" + value + "\"";
- if (this._writerOptions.prettyPrint && this._writerOptions.width > 0 &&
- this._lineLength + 1 + str.length > this._writerOptions.width) {
- str = this._beginLine() + this._indent(1) + str;
- this._lineLength = str.length;
- return str;
- }
- else {
- this._lineLength += 1 + str.length;
- return " " + str;
- }
- }
- /** @inheritdoc */
- beginElement(name) { }
- /** @inheritdoc */
- endElement(name) { }
- /**
- * Produces characters to be prepended to a line of string in pretty-print
- * mode.
- */
- _beginLine() {
- if (this._writerOptions.prettyPrint) {
- const str = (this.hasData ? this._writerOptions.newline : "") +
- this._indent(this._writerOptions.offset + this.level);
- this._lineLength = str.length;
- return str;
- }
- else {
- return "";
- }
- }
- /**
- * Produces an indentation string.
- *
- * @param level - depth of the tree
- */
- _indent(level) {
- if (level <= 0) {
- return "";
- }
- else {
- return this._writerOptions.indent.repeat(level);
- }
- }
-}
-exports.XMLCBWriter = XMLCBWriter;
-//# sourceMappingURL=XMLCBWriter.js.map
-
-/***/ }),
-
-/***/ 5272:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.XMLWriter = void 0;
-const util_1 = __nccwpck_require__(7061);
-const interfaces_1 = __nccwpck_require__(9454);
-const BaseWriter_1 = __nccwpck_require__(4726);
-const util_2 = __nccwpck_require__(8247);
-/**
- * Serializes XML nodes into strings.
- */
-class XMLWriter extends BaseWriter_1.BaseWriter {
- _refs;
- _indentation = {};
- _lengthToLastNewline = 0;
- /**
- * Initializes a new instance of `XMLWriter`.
- *
- * @param builderOptions - XML builder options
- * @param writerOptions - serialization options
- */
- constructor(builderOptions, writerOptions) {
- super(builderOptions);
- // provide default options
- this._writerOptions = (0, util_1.applyDefaults)(writerOptions, {
- wellFormed: false,
- headless: false,
- prettyPrint: false,
- indent: " ",
- newline: "\n",
- offset: 0,
- width: 0,
- allowEmptyTags: false,
- indentTextOnlyNodes: false,
- spaceBeforeSlash: false
- });
- }
- /**
- * Produces an XML serialization of the given node.
- *
- * @param node - node to serialize
- */
- serialize(node) {
- this._refs = { suppressPretty: false, emptyNode: false, markup: "" };
- // Serialize XML declaration
- if (node.nodeType === interfaces_1.NodeType.Document && !this._writerOptions.headless) {
- this.declaration(this._builderOptions.version, this._builderOptions.encoding, this._builderOptions.standalone);
- }
- // recursively serialize node
- this.serializeNode(node, this._writerOptions.wellFormed);
- // remove trailing newline
- if (this._writerOptions.prettyPrint &&
- this._refs.markup.slice(-this._writerOptions.newline.length) === this._writerOptions.newline) {
- this._refs.markup = this._refs.markup.slice(0, -this._writerOptions.newline.length);
- }
- return this._refs.markup;
- }
- /** @inheritdoc */
- declaration(version, encoding, standalone) {
- this._beginLine();
- this._refs.markup += "";
- this._endLine();
- }
- /** @inheritdoc */
- docType(name, publicId, systemId) {
- this._beginLine();
- if (publicId && systemId) {
- this._refs.markup += "";
- }
- else if (publicId) {
- this._refs.markup += "";
- }
- else if (systemId) {
- this._refs.markup += "";
- }
- else {
- this._refs.markup += "";
- }
- this._endLine();
- }
- /** @inheritdoc */
- openTagBegin(name) {
- this._beginLine();
- this._refs.markup += "<" + name;
- }
- /** @inheritdoc */
- openTagEnd(name, selfClosing, voidElement) {
- // do not indent text only elements or elements with empty text nodes
- this._refs.suppressPretty = false;
- this._refs.emptyNode = false;
- if (this._writerOptions.prettyPrint && !selfClosing && !voidElement) {
- let textOnlyNode = true;
- let emptyNode = true;
- let childNode = this.currentNode.firstChild;
- let cdataCount = 0;
- let textCount = 0;
- while (childNode) {
- if (util_2.Guard.isExclusiveTextNode(childNode)) {
- textCount++;
- }
- else if (util_2.Guard.isCDATASectionNode(childNode)) {
- cdataCount++;
- }
- else {
- textOnlyNode = false;
- emptyNode = false;
- break;
- }
- if (childNode.data !== '') {
- emptyNode = false;
- }
- childNode = childNode.nextSibling;
- }
- this._refs.suppressPretty = !this._writerOptions.indentTextOnlyNodes && textOnlyNode && ((cdataCount <= 1 && textCount === 0) || cdataCount === 0);
- this._refs.emptyNode = emptyNode;
- }
- if ((voidElement || selfClosing || this._refs.emptyNode) && this._writerOptions.allowEmptyTags) {
- this._refs.markup += ">";
- }
- else {
- this._refs.markup += voidElement ? " />" :
- (selfClosing || this._refs.emptyNode) ? (this._writerOptions.spaceBeforeSlash ? " />" : "/>") : ">";
- }
- this._endLine();
- }
- /** @inheritdoc */
- closeTag(name) {
- if (!this._refs.emptyNode) {
- this._beginLine();
- this._refs.markup += "";
- }
- this._refs.suppressPretty = false;
- this._refs.emptyNode = false;
- this._endLine();
- }
- /** @inheritdoc */
- attribute(name, value) {
- const str = name + "=\"" + value + "\"";
- if (this._writerOptions.prettyPrint && this._writerOptions.width > 0 &&
- this._refs.markup.length - this._lengthToLastNewline + 1 + str.length > this._writerOptions.width) {
- this._endLine();
- this._beginLine();
- this._refs.markup += this._indent(1) + str;
- }
- else {
- this._refs.markup += " " + str;
- }
- }
- /** @inheritdoc */
- text(data) {
- if (data !== '') {
- this._beginLine();
- this._refs.markup += data;
- this._endLine();
- }
- }
- /** @inheritdoc */
- cdata(data) {
- if (data !== '') {
- this._beginLine();
- this._refs.markup += "";
- this._endLine();
- }
- }
- /** @inheritdoc */
- comment(data) {
- this._beginLine();
- this._refs.markup += "";
- this._endLine();
- }
- /** @inheritdoc */
- instruction(target, data) {
- this._beginLine();
- this._refs.markup += "";
- this._endLine();
- }
- /**
- * Produces characters to be prepended to a line of string in pretty-print
- * mode.
- */
- _beginLine() {
- if (this._writerOptions.prettyPrint && !this._refs.suppressPretty) {
- this._refs.markup += this._indent(this._writerOptions.offset + this.level);
- }
- }
- /**
- * Produces characters to be appended to a line of string in pretty-print
- * mode.
- */
- _endLine() {
- if (this._writerOptions.prettyPrint && !this._refs.suppressPretty) {
- this._refs.markup += this._writerOptions.newline;
- this._lengthToLastNewline = this._refs.markup.length;
- }
- }
- /**
- * Produces an indentation string.
- *
- * @param level - depth of the tree
- */
- _indent(level) {
- if (level <= 0) {
- return "";
- }
- else if (this._indentation[level] !== undefined) {
- return this._indentation[level];
- }
- else {
- const str = this._writerOptions.indent.repeat(level);
- this._indentation[level] = str;
- return str;
- }
- }
-}
-exports.XMLWriter = XMLWriter;
-//# sourceMappingURL=XMLWriter.js.map
-
-/***/ }),
-
-/***/ 2233:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.YAMLCBWriter = void 0;
-const BaseCBWriter_1 = __nccwpck_require__(9099);
-/**
- * Serializes XML nodes.
- */
-class YAMLCBWriter extends BaseCBWriter_1.BaseCBWriter {
- _rootWritten = false;
- _additionalLevel = 0;
- /**
- * Initializes a new instance of `BaseCBWriter`.
- *
- * @param builderOptions - XML builder options
- */
- constructor(builderOptions) {
- super(builderOptions);
- if (builderOptions.indent.length < 2) {
- throw new Error("YAML indententation string must be at least two characters long.");
- }
- if (builderOptions.offset < 0) {
- throw new Error("YAML offset should be zero or a positive number.");
- }
- }
- /** @inheritdoc */
- frontMatter() {
- return this._beginLine() + "---";
- }
- /** @inheritdoc */
- declaration(version, encoding, standalone) {
- return "";
- }
- /** @inheritdoc */
- docType(name, publicId, systemId) {
- return "";
- }
- /** @inheritdoc */
- comment(data) {
- // "!": "hello"
- return this._beginLine() +
- this._key(this._builderOptions.convert.comment) + " " +
- this._val(data);
- }
- /** @inheritdoc */
- text(data) {
- // "#": "hello"
- return this._beginLine() +
- this._key(this._builderOptions.convert.text) + " " +
- this._val(data);
- }
- /** @inheritdoc */
- instruction(target, data) {
- // "?": "target hello"
- return this._beginLine() +
- this._key(this._builderOptions.convert.ins) + " " +
- this._val(data ? target + " " + data : target);
- }
- /** @inheritdoc */
- cdata(data) {
- // "$": "hello"
- return this._beginLine() +
- this._key(this._builderOptions.convert.cdata) + " " +
- this._val(data);
- }
- /** @inheritdoc */
- attribute(name, value) {
- // "@name": "val"
- this._additionalLevel++;
- const str = this._beginLine() +
- this._key(this._builderOptions.convert.att + name) + " " +
- this._val(value);
- this._additionalLevel--;
- return str;
- }
- /** @inheritdoc */
- openTagBegin(name) {
- // "node":
- // "#":
- // -
- let str = this._beginLine() + this._key(name);
- if (!this._rootWritten) {
- this._rootWritten = true;
- }
- this.hasData = true;
- this._additionalLevel++;
- str += this._beginLine(true) + this._key(this._builderOptions.convert.text);
- return str;
- }
- /** @inheritdoc */
- openTagEnd(name, selfClosing, voidElement) {
- if (selfClosing) {
- return " " + this._val("");
- }
- return "";
- }
- /** @inheritdoc */
- closeTag(name) {
- this._additionalLevel--;
- return "";
- }
- /** @inheritdoc */
- beginElement(name) { }
- /** @inheritdoc */
- endElement(name) { }
- /**
- * Produces characters to be prepended to a line of string in pretty-print
- * mode.
- */
- _beginLine(suppressArray = false) {
- return (this.hasData ? this._writerOptions.newline : "") +
- this._indent(this._writerOptions.offset + this.level, suppressArray);
- }
- /**
- * Produces an indentation string.
- *
- * @param level - depth of the tree
- * @param suppressArray - whether the suppress array marker
- */
- _indent(level, suppressArray) {
- if (level + this._additionalLevel <= 0) {
- return "";
- }
- else {
- const chars = this._writerOptions.indent.repeat(level + this._additionalLevel);
- if (!suppressArray && this._rootWritten) {
- return chars.substr(0, chars.length - 2) + '-' + chars.substr(-1, 1);
- }
- return chars;
- }
- }
- /**
- * Produces a YAML key string delimited with double quotes.
- */
- _key(key) {
- return "\"" + key + "\":";
- }
- /**
- * Produces a YAML value string delimited with double quotes.
- */
- _val(val) {
- return JSON.stringify(val);
- }
-}
-exports.YAMLCBWriter = YAMLCBWriter;
-//# sourceMappingURL=YAMLCBWriter.js.map
-
-/***/ }),
-
-/***/ 6612:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.YAMLWriter = void 0;
-const ObjectWriter_1 = __nccwpck_require__(1288);
-const util_1 = __nccwpck_require__(7061);
-const BaseWriter_1 = __nccwpck_require__(4726);
-/**
- * Serializes XML nodes into a YAML string.
- */
-class YAMLWriter extends BaseWriter_1.BaseWriter {
- /**
- * Initializes a new instance of `YAMLWriter`.
- *
- * @param builderOptions - XML builder options
- * @param writerOptions - serialization options
- */
- constructor(builderOptions, writerOptions) {
- super(builderOptions);
- // provide default options
- this._writerOptions = (0, util_1.applyDefaults)(writerOptions, {
- wellFormed: false,
- indent: ' ',
- newline: '\n',
- offset: 0,
- group: false,
- verbose: false
- });
- if (this._writerOptions.indent.length < 2) {
- throw new Error("YAML indententation string must be at least two characters long.");
- }
- if (this._writerOptions.offset < 0) {
- throw new Error("YAML offset should be zero or a positive number.");
- }
- }
- /**
- * Produces an XML serialization of the given node.
- *
- * @param node - node to serialize
- * @param writerOptions - serialization options
- */
- serialize(node) {
- // convert to object
- const objectWriterOptions = (0, util_1.applyDefaults)(this._writerOptions, {
- format: "object",
- wellFormed: false
- });
- const objectWriter = new ObjectWriter_1.ObjectWriter(this._builderOptions, objectWriterOptions);
- const val = objectWriter.serialize(node);
- let markup = this._beginLine(this._writerOptions, 0) + '---' + this._endLine(this._writerOptions) +
- this._convertObject(val, this._writerOptions, 0);
- // remove trailing newline
- /* istanbul ignore else */
- if (markup.slice(-this._writerOptions.newline.length) === this._writerOptions.newline) {
- markup = markup.slice(0, -this._writerOptions.newline.length);
- }
- return markup;
- }
- /**
- * Produces an XML serialization of the given object.
- *
- * @param obj - object to serialize
- * @param options - serialization options
- * @param level - depth of the XML tree
- * @param indentLeaf - indents leaf nodes
- */
- _convertObject(obj, options, level, suppressIndent = false) {
- let markup = '';
- if ((0, util_1.isArray)(obj)) {
- for (const val of obj) {
- markup += this._beginLine(options, level, true);
- if (!(0, util_1.isObject)(val)) {
- markup += this._val(val) + this._endLine(options);
- }
- else if ((0, util_1.isEmpty)(val)) {
- markup += '""' + this._endLine(options);
- }
- else {
- markup += this._convertObject(val, options, level, true);
- }
- }
- }
- else /* if (isObject(obj)) */ {
- (0, util_1.forEachObject)(obj, (key, val) => {
- if (suppressIndent) {
- markup += this._key(key);
- suppressIndent = false;
- }
- else {
- markup += this._beginLine(options, level) + this._key(key);
- }
- if (!(0, util_1.isObject)(val) && !(0, util_1.isArray)(val)) {
- markup += ' ' + this._val(val) + this._endLine(options);
- }
- else if ((0, util_1.isEmpty)(val)) {
- markup += ' ""' + this._endLine(options);
- }
- else {
- markup += this._endLine(options) +
- this._convertObject(val, options, level + 1);
- }
- }, this);
- }
- return markup;
- }
- /**
- * Produces characters to be prepended to a line of string in pretty-print
- * mode.
- *
- * @param options - serialization options
- * @param level - current depth of the XML tree
- * @param isArray - whether this line is an array item
- */
- _beginLine(options, level, isArray = false) {
- const indentLevel = options.offset + level + 1;
- const chars = new Array(indentLevel).join(options.indent);
- if (isArray) {
- return chars.substr(0, chars.length - 2) + '-' + chars.substr(-1, 1);
- }
- else {
- return chars;
- }
- }
- /**
- * Produces characters to be appended to a line of string in pretty-print
- * mode.
- *
- * @param options - serialization options
- */
- _endLine(options) {
- return options.newline;
- }
- /**
- * Produces a YAML key string delimited with double quotes.
- */
- _key(key) {
- return "\"" + key + "\":";
- }
- /**
- * Produces a YAML value string delimited with double quotes.
- */
- _val(val) {
- return JSON.stringify(val);
- }
-}
-exports.YAMLWriter = YAMLWriter;
-//# sourceMappingURL=YAMLWriter.js.map
-
-/***/ }),
-
-/***/ 2062:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.YAMLWriter = exports.JSONWriter = exports.ObjectWriter = exports.XMLWriter = exports.MapWriter = void 0;
-var MapWriter_1 = __nccwpck_require__(4703);
-Object.defineProperty(exports, "MapWriter", ({ enumerable: true, get: function () { return MapWriter_1.MapWriter; } }));
-var XMLWriter_1 = __nccwpck_require__(5272);
-Object.defineProperty(exports, "XMLWriter", ({ enumerable: true, get: function () { return XMLWriter_1.XMLWriter; } }));
-var ObjectWriter_1 = __nccwpck_require__(1288);
-Object.defineProperty(exports, "ObjectWriter", ({ enumerable: true, get: function () { return ObjectWriter_1.ObjectWriter; } }));
-var JSONWriter_1 = __nccwpck_require__(2661);
-Object.defineProperty(exports, "JSONWriter", ({ enumerable: true, get: function () { return JSONWriter_1.JSONWriter; } }));
-var YAMLWriter_1 = __nccwpck_require__(6612);
-Object.defineProperty(exports, "YAMLWriter", ({ enumerable: true, get: function () { return YAMLWriter_1.YAMLWriter; } }));
-//# sourceMappingURL=index.js.map
-
-/***/ }),
-
/***/ 3838:
/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __nccwpck_require__) => {
@@ -67107,276 +36019,19 @@ var external_fs_ = __nccwpck_require__(9896);
var external_fs_default = /*#__PURE__*/__nccwpck_require__.n(external_fs_);
// EXTERNAL MODULE: ./node_modules/@actions/core/lib/core.js + 7 modules
var setup_java_core = __nccwpck_require__(3838);
-// EXTERNAL MODULE: external "path"
-var external_path_ = __nccwpck_require__(6928);
-// EXTERNAL MODULE: ./node_modules/@actions/io/lib/io.js
-var setup_java_io = __nccwpck_require__(8701);
-// EXTERNAL MODULE: external "os"
-var external_os_ = __nccwpck_require__(857);
-var external_os_default = /*#__PURE__*/__nccwpck_require__.n(external_os_);
-// EXTERNAL MODULE: ./node_modules/xmlbuilder2/lib/index.js
-var lib = __nccwpck_require__(4697);
-// EXTERNAL MODULE: ./src/constants.ts
-var constants = __nccwpck_require__(7242);
-// EXTERNAL MODULE: ./src/gpg.ts
-var gpg = __nccwpck_require__(8343);
// EXTERNAL MODULE: ./src/util.ts
var util = __nccwpck_require__(4527);
-;// CONCATENATED MODULE: ./src/auth.ts
-
-
-
-
-
-
-
-
-
-async function configureAuthentication() {
- const id = setup_java_core/* getInput */.V4(constants/* INPUT_SERVER_ID */.fd);
- const usernameEnvVar = getInputWithDeprecatedAlias(constants/* INPUT_SERVER_USERNAME_ENV_VAR */.sc, constants/* INPUT_SERVER_USERNAME_DEPRECATED */.sp, constants/* INPUT_DEFAULT_SERVER_USERNAME */.Wj);
- const passwordEnvVar = getInputWithDeprecatedAlias(constants/* INPUT_SERVER_PASSWORD_ENV_VAR */.r4, constants/* INPUT_SERVER_PASSWORD_DEPRECATED */.Vt, constants/* INPUT_DEFAULT_SERVER_PASSWORD */.xp);
- const settingsDirectory = setup_java_core/* getInput */.V4(constants/* INPUT_SETTINGS_PATH */.Xh) ||
- external_path_.join(external_os_.homedir(), constants/* M2_DIR */.iT);
- const overwriteSettings = (0,util/* getBooleanInput */.Vt)(constants/* INPUT_OVERWRITE_SETTINGS */.TS, true);
- const gpgPrivateKey = setup_java_core/* getInput */.V4(constants/* INPUT_GPG_PRIVATE_KEY */.wz) ||
- constants/* INPUT_DEFAULT_GPG_PRIVATE_KEY */.OD;
- const gpgPassphraseEnvVar = getInputWithDeprecatedAlias(constants/* INPUT_GPG_PASSPHRASE_ENV_VAR */.db, constants/* INPUT_GPG_PASSPHRASE_DEPRECATED */.TY, gpgPrivateKey ? constants/* INPUT_DEFAULT_GPG_PASSPHRASE */.RX : undefined);
- if (gpgPrivateKey) {
- setup_java_core/* setSecret */.Pq(gpgPrivateKey);
- }
- await createAuthenticationSettings(id, usernameEnvVar, passwordEnvVar, settingsDirectory, overwriteSettings, gpgPassphraseEnvVar);
- if (gpgPrivateKey) {
- setup_java_core/* info */.pq('Importing private gpg key');
- const keyFingerprint = (await gpg/* importKey */.Fh(gpgPrivateKey)) || '';
- setup_java_core/* saveState */.LZ(constants/* STATE_GPG_PRIVATE_KEY_FINGERPRINT */.wm, keyFingerprint);
- }
-}
-function getInputWithDeprecatedAlias(inputName, deprecatedInputName, defaultValue) {
- const value = setup_java_core/* getInput */.V4(inputName);
- const deprecatedValue = setup_java_core/* getInput */.V4(deprecatedInputName);
- if (deprecatedValue) {
- setup_java_core/* warning */.$e(`The '${deprecatedInputName}' input is deprecated and may be removed in a future release. Please use '${inputName}' instead.`);
- }
- return value || deprecatedValue || defaultValue || '';
-}
-async function createAuthenticationSettings(id, usernameEnvVar, passwordEnvVar, settingsDirectory, overwriteSettings, gpgPassphraseEnvVar = undefined) {
- setup_java_core/* info */.pq(`Creating ${constants/* MVN_SETTINGS_FILE */.vO} with server-id: ${id}`);
- // when an alternate m2 location is specified use only that location (no .m2 directory)
- // otherwise use the home/.m2/ path
- await setup_java_io/* mkdirP */.U$(settingsDirectory);
- await write(settingsDirectory, generate(id, usernameEnvVar, passwordEnvVar, gpgPassphraseEnvVar), overwriteSettings);
-}
-// only exported for testing purposes
-function generate(id, usernameEnvVar, passwordEnvVar, gpgPassphraseEnvVar) {
- const xmlObj = {
- settings: {
- '@xmlns': 'http://maven.apache.org/SETTINGS/1.0.0',
- '@xmlns:xsi': 'http://www.w3.org/2001/XMLSchema-instance',
- '@xsi:schemaLocation': 'http://maven.apache.org/SETTINGS/1.0.0 https://maven.apache.org/xsd/settings-1.0.0.xsd',
- interactiveMode: false,
- servers: {
- server: [
- {
- id: id,
- username: `\${env.${usernameEnvVar}}`,
- password: `\${env.${passwordEnvVar}}`
- }
- ]
- }
- }
- };
- // The maven-gpg-plugin reads the passphrase from the environment variable
- // named by the `gpg.passphraseEnvName` property (default MAVEN_GPG_PASSPHRASE).
- // Only configure it when the requested env var name differs from that default;
- // otherwise the plugin already reads the right variable and no extra settings
- // are needed. Writing `gpg.passphrase` to settings.xml is deprecated and fails
- // when the plugin's `bestPractices` mode is enabled.
- if (gpgPassphraseEnvVar &&
- gpgPassphraseEnvVar !== constants/* MAVEN_GPG_PASSPHRASE_DEFAULT_ENV */.ko) {
- xmlObj.settings.profiles = {
- profile: {
- id: constants/* GPG_PASSPHRASE_PROFILE_ID */.K$,
- properties: {
- 'gpg.passphraseEnvName': gpgPassphraseEnvVar
- }
- }
- };
- xmlObj.settings.activeProfiles = {
- activeProfile: constants/* GPG_PASSPHRASE_PROFILE_ID */.K$
- };
- }
- return (0,lib/* create */.vt)(xmlObj).end({
- headless: true,
- prettyPrint: true,
- width: 80
- });
-}
-async function write(directory, settings, overwriteSettings) {
- const location = external_path_.join(directory, constants/* MVN_SETTINGS_FILE */.vO);
- const settingsExists = external_fs_.existsSync(location);
- if (settingsExists && overwriteSettings) {
- setup_java_core/* info */.pq(`Overwriting existing file ${location}`);
- }
- else if (!settingsExists) {
- setup_java_core/* info */.pq(`Writing to ${location}`);
- }
- else {
- setup_java_core/* info */.pq(`Skipping generation ${location} because file already exists and overwriting is not required`);
- return;
- }
- return external_fs_.writeFileSync(location, settings, {
- encoding: 'utf-8',
- flag: 'w'
- });
-}
-
-;// CONCATENATED MODULE: ./src/toolchains.ts
-
-
-
-
-
-
-
-function validateToolchainIds(versions, versionFile, toolchainIds) {
- if (!toolchainIds.length) {
- return;
- }
- const versionCount = versions.length || (versionFile ? 1 : 0);
- if (versionCount !== toolchainIds.length) {
- throw new Error(`The number of Maven toolchain IDs (${toolchainIds.length}) must match the number of Java versions (${versionCount})`);
- }
-}
-async function configureToolchains(version, distributionName, jdkHome, toolchainId) {
- const vendor = setup_java_core/* getInput */.V4(constants/* INPUT_MVN_TOOLCHAIN_VENDOR */.m7) || distributionName;
- const id = toolchainId || `${vendor}_${version}`;
- const settingsDirectory = setup_java_core/* getInput */.V4(constants/* INPUT_SETTINGS_PATH */.Xh) ||
- external_path_.join(external_os_.homedir(), constants/* M2_DIR */.iT);
- await createToolchainsSettings({
- jdkInfo: {
- version,
- vendor,
- id,
- jdkHome
- },
- settingsDirectory
- });
-}
-async function createToolchainsSettings({ jdkInfo, settingsDirectory }) {
- setup_java_core/* info */.pq(`Creating ${constants/* MVN_TOOLCHAINS_FILE */.qs} for JDK version ${jdkInfo.version} from ${jdkInfo.vendor}`);
- // when an alternate m2 location is specified use only that location (no .m2 directory)
- // otherwise use the home/.m2/ path
- await setup_java_io/* mkdirP */.U$(settingsDirectory);
- const originalToolchains = await readExistingToolchainsFile(settingsDirectory);
- const updatedToolchains = generateToolchainDefinition(originalToolchains, jdkInfo.version, jdkInfo.vendor, jdkInfo.id, jdkInfo.jdkHome);
- await writeToolchainsFileToDisk(settingsDirectory, updatedToolchains);
-}
-// only exported for testing purposes
-function generateToolchainDefinition(original, version, vendor, id, jdkHome) {
- let jsToolchains = [
- {
- type: 'jdk',
- provides: {
- version: `${version}`,
- vendor: `${vendor}`,
- id: `${id}`
- },
- configuration: {
- jdkHome: `${jdkHome}`
- }
- }
- ];
- // default root attributes, used when the existing file does not declare its own
- let rootAttributes = {
- '@xmlns': 'http://maven.apache.org/TOOLCHAINS/1.1.0',
- '@xmlns:xsi': 'http://www.w3.org/2001/XMLSchema-instance',
- '@xsi:schemaLocation': 'http://maven.apache.org/TOOLCHAINS/1.1.0 https://maven.apache.org/xsd/toolchains-1.1.0.xsd'
- };
- if (original?.length) {
- // convert existing toolchains into TS native objects for better handling
- // xmlbuilder2 will convert the document into a `{toolchains: { toolchain: [] | {} }}` structure
- // instead of the desired `toolchains: [{}]` one or simply `[{}]`
- const jsObj = (0,lib/* create */.vt)(original)
- .root()
- .toObject();
- if (jsObj.toolchains) {
- // preserve the existing root attributes (xmlns, schemaLocation, …) so we don't
- // silently rewrite user-managed metadata or change the effective XML namespace;
- // xmlbuilder2 exposes attributes as `@`-prefixed keys on the element object
- const existingAttributes = Object.fromEntries(Object.entries(jsObj.toolchains).filter(([key]) => key.startsWith('@')));
- // fall back to the defaults only for attributes the existing file is missing
- rootAttributes = { ...rootAttributes, ...existingAttributes };
- if (jsObj.toolchains.toolchain) {
- // in case only a single child exists xmlbuilder2 will not create an array and using verbose = true equally doesn't work here
- // See https://oozcitak.github.io/xmlbuilder2/serialization.html#js-object-and-map-serializers for details
- if (Array.isArray(jsObj.toolchains.toolchain)) {
- jsToolchains.push(...jsObj.toolchains.toolchain);
- }
- else {
- jsToolchains.push(jsObj.toolchains.toolchain);
- }
- }
- }
- // remove potential duplicates based on type & id (which should be a unique combination);
- // self.findIndex will only return the first occurrence, ensuring duplicates are skipped
- jsToolchains = jsToolchains.filter((value, index, self) =>
- // ensure non-jdk toolchains are kept in the results, we must not touch them because they belong to the user
- value.type !== 'jdk' ||
- // keep toolchains that lack a usable string id (e.g. partially-formed user files);
- // we cannot safely deduplicate them and must not crash while reading them
- typeof value.provides?.id !== 'string' ||
- index ===
- self.findIndex(t => t.type === value.type && t.provides?.id === value.provides?.id));
- }
- return (0,lib/* create */.vt)({
- toolchains: {
- ...rootAttributes,
- toolchain: jsToolchains
- }
- }).end({
- format: 'xml',
- wellFormed: false,
- headless: false,
- prettyPrint: true,
- width: 80
- });
-}
-async function readExistingToolchainsFile(directory) {
- const location = external_path_.join(directory, constants/* MVN_TOOLCHAINS_FILE */.qs);
- if (external_fs_.existsSync(location)) {
- return external_fs_.readFileSync(location, {
- encoding: 'utf-8',
- flag: 'r'
- });
- }
- return '';
-}
-async function writeToolchainsFileToDisk(directory, settings) {
- const location = external_path_.join(directory, constants/* MVN_TOOLCHAINS_FILE */.qs);
- const settingsExists = external_fs_.existsSync(location);
- // The toolchains file is produced by a non-destructive merge (existing JDK,
- // custom, and non-jdk toolchains are preserved – see generateToolchainDefinition),
- // so it is always safe to write it. Unlike settings.xml, it is therefore not
- // gated behind the `overwrite-settings` input; that would prevent subsequent
- // setup-java runs from registering additional JDKs and silently drop the
- // toolchain entries created by earlier runs.
- if (settingsExists) {
- setup_java_core/* info */.pq(`Updating existing file ${location}`);
- }
- else {
- setup_java_core/* info */.pq(`Writing to ${location}`);
- }
- return external_fs_.writeFileSync(location, settings, {
- encoding: 'utf-8',
- flag: 'w'
- });
-}
-
+// EXTERNAL MODULE: ./src/constants.ts
+var constants = __nccwpck_require__(7242);
+// EXTERNAL MODULE: external "path"
+var external_path_ = __nccwpck_require__(6928);
// EXTERNAL MODULE: external "url"
var external_url_ = __nccwpck_require__(7016);
// EXTERNAL MODULE: ./src/distributions/package-types.ts
var package_types = __nccwpck_require__(7835);
+// EXTERNAL MODULE: external "os"
+var external_os_ = __nccwpck_require__(857);
+var external_os_default = /*#__PURE__*/__nccwpck_require__.n(external_os_);
// EXTERNAL MODULE: ./src/distributions/platform-types.ts
var platform_types = __nccwpck_require__(7444);
;// CONCATENATED MODULE: ./src/distributions/distribution-factory.ts
@@ -67469,53 +36124,6 @@ async function getJavaDistribution(distributionName, installerOptions, jdkFile)
}
}
-;// CONCATENATED MODULE: ./src/maven-args.ts
-
-
-
-/**
- * Configures the MAVEN_ARGS environment variable so that Maven suppresses
- * artifact transfer/download progress output by default, producing cleaner
- * CI logs.
- *
- * Behavior:
- * - When `show-download-progress` is `false` (the default), `-ntp`
- * (`--no-transfer-progress`) is appended to any existing MAVEN_ARGS value.
- * - When `show-download-progress` is `true`, MAVEN_ARGS is left untouched so
- * the user's own configuration (and Maven's default progress output) is
- * preserved.
- *
- * The change is idempotent: if MAVEN_ARGS already disables transfer progress
- * (via `-ntp` or `--no-transfer-progress`) nothing is added. Any pre-existing
- * MAVEN_ARGS value is preserved.
- *
- * MAVEN_ARGS is honored by Maven 3.9.0+ and the Maven Wrapper; older Maven
- * versions ignore it, so this is a no-op there. It has no effect on non-Maven
- * builds such as Gradle or sbt.
- */
-function configureMavenArgs() {
- const showDownloadProgress = (0,util/* getBooleanInput */.Vt)(constants/* INPUT_SHOW_DOWNLOAD_PROGRESS */.wX, false);
- if (showDownloadProgress) {
- setup_java_core/* debug */.Yz(`${constants/* INPUT_SHOW_DOWNLOAD_PROGRESS */.wX} is true; leaving ${constants/* MAVEN_ARGS_ENV */.qm} unchanged`);
- return;
- }
- const existingArgs = (process.env[constants/* MAVEN_ARGS_ENV */.qm] ?? '').trim();
- const alreadyDisabled = existingArgs
- .split(/\s+/)
- .some(arg => arg === constants/* MAVEN_NO_TRANSFER_PROGRESS_FLAG */.ti ||
- arg === constants/* MAVEN_NO_TRANSFER_PROGRESS_LONG_FLAG */.kN);
- if (alreadyDisabled) {
- setup_java_core/* debug */.Yz(`${constants/* MAVEN_ARGS_ENV */.qm} already disables transfer progress; leaving it unchanged`);
- return;
- }
- const updatedArgs = existingArgs
- ? `${existingArgs} ${constants/* MAVEN_NO_TRANSFER_PROGRESS_FLAG */.ti}`
- : constants/* MAVEN_NO_TRANSFER_PROGRESS_FLAG */.ti;
- setup_java_core/* exportVariable */.dN(constants/* MAVEN_ARGS_ENV */.qm, updatedArgs);
- setup_java_core/* info */.pq(`Configured ${constants/* MAVEN_ARGS_ENV */.qm} to include ${constants/* MAVEN_NO_TRANSFER_PROGRESS_FLAG */.ti} to suppress Maven transfer progress logs. ` +
- `Set '${constants/* INPUT_SHOW_DOWNLOAD_PROGRESS */.wX}: true' to keep the download progress output.`);
-}
-
;// CONCATENATED MODULE: ./src/problem-matcher.ts
@@ -67529,6 +36137,8 @@ function configureProblemMatcher(matcherPath) {
setup_java_core/* info */.pq(`##[add-matcher]${matcherPath}`);
}
+// EXTERNAL MODULE: ./src/toolchain-ids.ts
+var toolchain_ids = __nccwpck_require__(7083);
;// CONCATENATED MODULE: ./src/setup-java.ts
@@ -67539,8 +36149,6 @@ function configureProblemMatcher(matcherPath) {
-
-
async function run() {
const versions = setup_java_core/* getMultilineInput */.q3(constants/* INPUT_JAVA_VERSION */.QM);
let distributionName = setup_java_core/* getInput */.V4(constants/* INPUT_DISTRIBUTION */.g_);
@@ -67559,12 +36167,13 @@ async function run() {
const toolchainIds = setup_java_core/* getMultilineInput */.q3(constants/* INPUT_MVN_TOOLCHAIN_ID */.nr);
let actionError;
let cacheRestore;
+ const toolchainConfigurations = [];
try {
setup_java_core/* startGroup */.Oh('Installed distributions');
if (!versions.length && !versionFile) {
throw new Error('java-version or java-version-file input expected');
}
- validateToolchainIds(versions, versionFile, toolchainIds);
+ (0,toolchain_ids/* validateToolchainIds */.O)(versions, versionFile, toolchainIds);
if (!versions.length) {
setup_java_core/* debug */.Yz('java-version input is empty, looking for java-version-file input');
const content = external_fs_default().readFileSync(versionFile).toString().trim();
@@ -67596,7 +36205,7 @@ async function run() {
cacheRestore = cache
? startCacheRestore(cache, cacheDependencyPath, cachePath)
: undefined;
- await installVersion(versionInfo.version, installerInputsOptions);
+ toolchainConfigurations.push(await installVersion(versionInfo.version, installerInputsOptions));
}
else {
// When using java-version input, distribution is still required
@@ -67619,14 +36228,13 @@ async function run() {
? startCacheRestore(cache, cacheDependencyPath, cachePath)
: undefined;
for (const [index, version] of versions.entries()) {
- await installVersion(version, installerInputsOptions, index);
+ toolchainConfigurations.push(await installVersion(version, installerInputsOptions, index));
}
}
setup_java_core/* endGroup */.N4();
const matchersPath = external_path_.join(external_path_.dirname((0,external_url_.fileURLToPath)(import.meta.url)), '..', '..', '.github');
configureProblemMatcher(external_path_.join(matchersPath, 'java.json'));
- await configureAuthentication();
- configureMavenArgs();
+ await configureMaven(toolchainConfigurations);
}
catch (error) {
actionError = error;
@@ -67681,20 +36289,42 @@ async function installVersion(version, options, toolchainId = 0) {
// pass the resolved version to the toolchains configuration instead.
const isLatest = version.trim().toLowerCase() === 'latest';
const toolchainVersion = isLatest ? result.version : version;
- await configureToolchains(toolchainVersion, distributionName, result.path, toolchainIds[toolchainId]);
setup_java_core/* info */.pq('');
setup_java_core/* info */.pq('Java configuration:');
setup_java_core/* info */.pq(` Distribution: ${distributionName}`);
setup_java_core/* info */.pq(` Version: ${result.version}`);
setup_java_core/* info */.pq(` Path: ${result.path}`);
setup_java_core/* info */.pq('');
+ return {
+ version: toolchainVersion,
+ distributionName,
+ path: result.path,
+ toolchainId: toolchainIds[toolchainId]
+ };
+}
+async function configureMaven(toolchainConfigurations) {
+ const authentication = __nccwpck_require__.e(/* import() */ 81).then(__nccwpck_require__.bind(__nccwpck_require__, 9081)).then(auth => auth.configureAuthentication());
+ const toolchains = configureInstalledToolchains(toolchainConfigurations);
+ const results = await Promise.allSettled([authentication, toolchains]);
+ const failure = results.find((result) => result.status === 'rejected');
+ if (failure) {
+ throw failure.reason;
+ }
+ const { configureMavenArgs } = await __nccwpck_require__.e(/* import() */ 172).then(__nccwpck_require__.bind(__nccwpck_require__, 8172));
+ configureMavenArgs();
+}
+async function configureInstalledToolchains(toolchainConfigurations) {
+ const toolchains = await __nccwpck_require__.e(/* import() */ 451).then(__nccwpck_require__.bind(__nccwpck_require__, 9451));
+ for (const configuration of toolchainConfigurations) {
+ await toolchains.configureToolchains(configuration.version, configuration.distributionName, configuration.path, configuration.toolchainId);
+ }
}
async function startCacheRestore(cache, cacheDependencyPath, cachePath) {
- const { isCacheFeatureAvailable } = await Promise.all(/* import() */[__nccwpck_require__.e(767), __nccwpck_require__.e(394)]).then(__nccwpck_require__.bind(__nccwpck_require__, 1394));
+ const { isCacheFeatureAvailable } = await Promise.all(/* import() */[__nccwpck_require__.e(824), __nccwpck_require__.e(971), __nccwpck_require__.e(394)]).then(__nccwpck_require__.bind(__nccwpck_require__, 1394));
if (!isCacheFeatureAvailable()) {
return;
}
- const { restore } = await Promise.all(/* import() */[__nccwpck_require__.e(767), __nccwpck_require__.e(377)]).then(__nccwpck_require__.bind(__nccwpck_require__, 7377));
+ const { restore } = await Promise.all(/* import() */[__nccwpck_require__.e(824), __nccwpck_require__.e(971), __nccwpck_require__.e(377)]).then(__nccwpck_require__.bind(__nccwpck_require__, 7377));
await restore(cache, cacheDependencyPath, cachePath);
}
diff --git a/package-lock.json b/package-lock.json
index 6b238243..e4776783 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -16,8 +16,8 @@
"@actions/http-client": "^4.0.1",
"@actions/io": "^3.0.2",
"@actions/tool-cache": "^4.0.0",
- "semver": "^7.8.5",
- "xmlbuilder2": "^4.0.3"
+ "fast-xml-parser": "^5.10.1",
+ "semver": "^7.8.5"
},
"devDependencies": {
"@eslint/js": "^10.0.1",
@@ -1566,54 +1566,6 @@
],
"license": "MIT"
},
- "node_modules/@oozcitak/dom": {
- "version": "2.0.2",
- "resolved": "https://registry.npmjs.org/@oozcitak/dom/-/dom-2.0.2.tgz",
- "integrity": "sha512-GjpKhkSYC3Mj4+lfwEyI1dqnsKTgwGy48ytZEhm4A/xnH/8z9M3ZVXKr/YGQi3uCLs1AEBS+x5T2JPiueEDW8w==",
- "license": "MIT",
- "dependencies": {
- "@oozcitak/infra": "^2.0.2",
- "@oozcitak/url": "^3.0.0",
- "@oozcitak/util": "^10.0.0"
- },
- "engines": {
- "node": ">=20.0"
- }
- },
- "node_modules/@oozcitak/infra": {
- "version": "2.0.2",
- "resolved": "https://registry.npmjs.org/@oozcitak/infra/-/infra-2.0.2.tgz",
- "integrity": "sha512-2g+E7hoE2dgCz/APPOEK5s3rMhJvNxSMBrP+U+j1OWsIbtSpWxxlUjq1lU8RIsFJNYv7NMlnVsCuHcUzJW+8vA==",
- "license": "MIT",
- "dependencies": {
- "@oozcitak/util": "^10.0.0"
- },
- "engines": {
- "node": ">=20.0"
- }
- },
- "node_modules/@oozcitak/url": {
- "version": "3.0.0",
- "resolved": "https://registry.npmjs.org/@oozcitak/url/-/url-3.0.0.tgz",
- "integrity": "sha512-ZKfET8Ak1wsLAiLWNfFkZc/BraDccuTJKR6svTYc7sVjbR+Iu0vtXdiDMY4o6jaFl5TW2TlS7jbLl4VovtAJWQ==",
- "license": "MIT",
- "dependencies": {
- "@oozcitak/infra": "^2.0.2",
- "@oozcitak/util": "^10.0.0"
- },
- "engines": {
- "node": ">=20.0"
- }
- },
- "node_modules/@oozcitak/util": {
- "version": "10.0.0",
- "resolved": "https://registry.npmjs.org/@oozcitak/util/-/util-10.0.0.tgz",
- "integrity": "sha512-hAX0pT/73190NLqBPPWSdBVGtbY6VOhWYK3qqHqtXQ1gK7kS2yz4+ivsN07hpJ6I3aeMtKP6J6npsEKOAzuTLA==",
- "license": "MIT",
- "engines": {
- "node": ">=20.0"
- }
- },
"node_modules/@pkgr/core": {
"version": "0.3.6",
"resolved": "https://registry.npmjs.org/@pkgr/core/-/core-0.3.6.tgz",
@@ -6042,49 +5994,6 @@
"node": ">=16.0.0"
}
},
- "node_modules/xmlbuilder2": {
- "version": "4.0.3",
- "resolved": "https://registry.npmjs.org/xmlbuilder2/-/xmlbuilder2-4.0.3.tgz",
- "integrity": "sha512-bx8Q1STctnNaaDymWnkfQLKofs0mGNN7rLLapJlGuV3VlvegD7Ls4ggMjE3aUSWItCCzU0PEv45lI87iSigiCA==",
- "license": "MIT",
- "dependencies": {
- "@oozcitak/dom": "^2.0.2",
- "@oozcitak/infra": "^2.0.2",
- "@oozcitak/util": "^10.0.0",
- "js-yaml": "^4.1.1"
- },
- "engines": {
- "node": ">=20.0"
- }
- },
- "node_modules/xmlbuilder2/node_modules/argparse": {
- "version": "2.0.1",
- "resolved": "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz",
- "integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==",
- "license": "Python-2.0"
- },
- "node_modules/xmlbuilder2/node_modules/js-yaml": {
- "version": "4.3.0",
- "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.3.0.tgz",
- "integrity": "sha512-1td788aAnnZ5qs7V2QIRl1owjtYpbKt749Y3xauqQgwIIGF/xXWz1wMTEBx5O3LK3lXLVuqXPdPxj2BoFHaW9Q==",
- "funding": [
- {
- "type": "github",
- "url": "https://github.com/sponsors/puzrin"
- },
- {
- "type": "github",
- "url": "https://github.com/sponsors/nodeca"
- }
- ],
- "license": "MIT",
- "dependencies": {
- "argparse": "^2.0.1"
- },
- "bin": {
- "js-yaml": "bin/js-yaml.js"
- }
- },
"node_modules/y18n": {
"version": "5.0.8",
"resolved": "https://registry.npmjs.org/y18n/-/y18n-5.0.8.tgz",
diff --git a/package.json b/package.json
index ab5d15b5..e1474c23 100644
--- a/package.json
+++ b/package.json
@@ -49,8 +49,8 @@
"@actions/http-client": "^4.0.1",
"@actions/io": "^3.0.2",
"@actions/tool-cache": "^4.0.0",
- "semver": "^7.8.5",
- "xmlbuilder2": "^4.0.3"
+ "fast-xml-parser": "^5.10.1",
+ "semver": "^7.8.5"
},
"devDependencies": {
"@eslint/js": "^10.0.1",
diff --git a/src/auth.ts b/src/auth.ts
index a22f7e4f..277342c5 100644
--- a/src/auth.ts
+++ b/src/auth.ts
@@ -4,11 +4,10 @@ import * as io from '@actions/io';
import * as fs from 'fs';
import * as os from 'os';
-
-import {create as xmlCreate} from 'xmlbuilder2';
import * as constants from './constants.js';
import * as gpg from './gpg.js';
import {getBooleanInput} from './util.js';
+import {escapeXmlText} from './xml.js';
export async function configureAuthentication() {
const id = core.getInput(constants.INPUT_SERVER_ID);
@@ -101,53 +100,48 @@ export function generate(
passwordEnvVar: string,
gpgPassphraseEnvVar?: string | undefined
) {
- const xmlObj: {[key: string]: any} = {
- settings: {
- '@xmlns': 'http://maven.apache.org/SETTINGS/1.0.0',
- '@xmlns:xsi': 'http://www.w3.org/2001/XMLSchema-instance',
- '@xsi:schemaLocation':
- 'http://maven.apache.org/SETTINGS/1.0.0 https://maven.apache.org/xsd/settings-1.0.0.xsd',
- interactiveMode: false,
- servers: {
- server: [
- {
- id: id,
- username: `\${env.${usernameEnvVar}}`,
- password: `\${env.${passwordEnvVar}}`
- }
- ]
- }
- }
- };
-
// The maven-gpg-plugin reads the passphrase from the environment variable
// named by the `gpg.passphraseEnvName` property (default MAVEN_GPG_PASSPHRASE).
// Only configure it when the requested env var name differs from that default;
// otherwise the plugin already reads the right variable and no extra settings
// are needed. Writing `gpg.passphrase` to settings.xml is deprecated and fails
// when the plugin's `bestPractices` mode is enabled.
- if (
+ const includeGpgPassphraseProfile =
gpgPassphraseEnvVar &&
- gpgPassphraseEnvVar !== constants.MAVEN_GPG_PASSPHRASE_DEFAULT_ENV
- ) {
- xmlObj.settings.profiles = {
- profile: {
- id: constants.GPG_PASSPHRASE_PROFILE_ID,
- properties: {
- 'gpg.passphraseEnvName': gpgPassphraseEnvVar
- }
- }
- };
- xmlObj.settings.activeProfiles = {
- activeProfile: constants.GPG_PASSPHRASE_PROFILE_ID
- };
+ gpgPassphraseEnvVar !== constants.MAVEN_GPG_PASSPHRASE_DEFAULT_ENV;
+
+ const lines = [
+ '',
+ ' false',
+ ' ',
+ ' ',
+ ` ${escapeXmlText(id)}`,
+ ` ${escapeXmlText(`\${env.${usernameEnvVar}}`)}`,
+ ` ${escapeXmlText(`\${env.${passwordEnvVar}}`)}`,
+ ' ',
+ ' '
+ ];
+
+ if (includeGpgPassphraseProfile) {
+ lines.push(
+ ' ',
+ ' ',
+ ` ${constants.GPG_PASSPHRASE_PROFILE_ID}`,
+ ' ',
+ ` ${escapeXmlText(gpgPassphraseEnvVar)}`,
+ ' ',
+ ' ',
+ ' ',
+ ' ',
+ ` ${constants.GPG_PASSPHRASE_PROFILE_ID}`,
+ ' '
+ );
}
- return xmlCreate(xmlObj).end({
- headless: true,
- prettyPrint: true,
- width: 80
- });
+ lines.push('');
+ return lines.join('\n');
}
async function write(
diff --git a/src/setup-java.ts b/src/setup-java.ts
index 6035a613..e998f7b6 100644
--- a/src/setup-java.ts
+++ b/src/setup-java.ts
@@ -1,15 +1,13 @@
import fs from 'fs';
import * as core from '@actions/core';
-import * as auth from './auth.js';
import {getBooleanInput, getVersionFromFileContent} from './util.js';
-import * as toolchains from './toolchains.js';
import * as constants from './constants.js';
import * as path from 'path';
import {fileURLToPath} from 'url';
import {getJavaDistribution} from './distributions/distribution-factory.js';
import {JavaInstallerOptions} from './distributions/base-models.js';
-import {configureMavenArgs} from './maven-args.js';
import {configureProblemMatcher} from './problem-matcher.js';
+import {validateToolchainIds} from './toolchain-ids.js';
export async function run() {
const versions = core.getMultilineInput(constants.INPUT_JAVA_VERSION);
@@ -33,9 +31,9 @@ export async function run() {
const verifySignaturePublicKey =
core.getInput(constants.INPUT_VERIFY_SIGNATURE_PUBLIC_KEY) || undefined;
const toolchainIds = core.getMultilineInput(constants.INPUT_MVN_TOOLCHAIN_ID);
-
let actionError: Error | undefined;
let cacheRestore: Promise | undefined;
+ const toolchainConfigurations: ToolchainConfiguration[] = [];
try {
core.startGroup('Installed distributions');
@@ -44,7 +42,7 @@ export async function run() {
throw new Error('java-version or java-version-file input expected');
}
- toolchains.validateToolchainIds(versions, versionFile, toolchainIds);
+ validateToolchainIds(versions, versionFile, toolchainIds);
if (!versions.length) {
core.debug(
@@ -93,7 +91,9 @@ export async function run() {
cacheRestore = cache
? startCacheRestore(cache, cacheDependencyPath, cachePath)
: undefined;
- await installVersion(versionInfo.version, installerInputsOptions);
+ toolchainConfigurations.push(
+ await installVersion(versionInfo.version, installerInputsOptions)
+ );
} else {
// When using java-version input, distribution is still required
if (!distributionName) {
@@ -117,7 +117,9 @@ export async function run() {
? startCacheRestore(cache, cacheDependencyPath, cachePath)
: undefined;
for (const [index, version] of versions.entries()) {
- await installVersion(version, installerInputsOptions, index);
+ toolchainConfigurations.push(
+ await installVersion(version, installerInputsOptions, index)
+ );
}
}
core.endGroup();
@@ -129,8 +131,7 @@ export async function run() {
);
configureProblemMatcher(path.join(matchersPath, 'java.json'));
- await auth.configureAuthentication();
- configureMavenArgs();
+ await configureMaven(toolchainConfigurations);
} catch (error) {
actionError = error as Error;
}
@@ -174,7 +175,7 @@ async function installVersion(
version: string,
options: installerInputsOptions,
toolchainId = 0
-) {
+): Promise {
const {
distributionName,
jdkFile,
@@ -217,19 +218,19 @@ async function installVersion(
const isLatest = version.trim().toLowerCase() === 'latest';
const toolchainVersion = isLatest ? result.version : version;
- await toolchains.configureToolchains(
- toolchainVersion,
- distributionName,
- result.path,
- toolchainIds[toolchainId]
- );
-
core.info('');
core.info('Java configuration:');
core.info(` Distribution: ${distributionName}`);
core.info(` Version: ${result.version}`);
core.info(` Path: ${result.path}`);
core.info('');
+
+ return {
+ version: toolchainVersion,
+ distributionName,
+ path: result.path,
+ toolchainId: toolchainIds[toolchainId]
+ };
}
interface installerInputsOptions {
@@ -245,6 +246,47 @@ interface installerInputsOptions {
toolchainIds: Array;
}
+interface ToolchainConfiguration {
+ version: string;
+ distributionName: string;
+ path: string;
+ toolchainId?: string;
+}
+
+async function configureMaven(
+ toolchainConfigurations: ToolchainConfiguration[]
+): Promise {
+ const authentication = import('./auth.js').then(auth =>
+ auth.configureAuthentication()
+ );
+ const toolchains = configureInstalledToolchains(toolchainConfigurations);
+
+ const results = await Promise.allSettled([authentication, toolchains]);
+ const failure = results.find(
+ (result): result is PromiseRejectedResult => result.status === 'rejected'
+ );
+ if (failure) {
+ throw failure.reason;
+ }
+
+ const {configureMavenArgs} = await import('./maven-args.js');
+ configureMavenArgs();
+}
+
+async function configureInstalledToolchains(
+ toolchainConfigurations: ToolchainConfiguration[]
+): Promise {
+ const toolchains = await import('./toolchains.js');
+ for (const configuration of toolchainConfigurations) {
+ await toolchains.configureToolchains(
+ configuration.version,
+ configuration.distributionName,
+ configuration.path,
+ configuration.toolchainId
+ );
+ }
+}
+
async function startCacheRestore(
cache: string,
cacheDependencyPath: string,
diff --git a/src/toolchain-ids.ts b/src/toolchain-ids.ts
new file mode 100644
index 00000000..b9884d61
--- /dev/null
+++ b/src/toolchain-ids.ts
@@ -0,0 +1,16 @@
+export function validateToolchainIds(
+ versions: string[],
+ versionFile: string,
+ toolchainIds: string[]
+) {
+ if (!toolchainIds.length) {
+ return;
+ }
+
+ const versionCount = versions.length || (versionFile ? 1 : 0);
+ if (versionCount !== toolchainIds.length) {
+ throw new Error(
+ `The number of Maven toolchain IDs (${toolchainIds.length}) must match the number of Java versions (${versionCount})`
+ );
+ }
+}
diff --git a/src/toolchains.ts b/src/toolchains.ts
index fe21a64c..3995b9c2 100644
--- a/src/toolchains.ts
+++ b/src/toolchains.ts
@@ -4,8 +4,8 @@ import * as path from 'path';
import * as core from '@actions/core';
import * as io from '@actions/io';
import * as constants from './constants.js';
-
-import {create as xmlCreate} from 'xmlbuilder2';
+export {validateToolchainIds} from './toolchain-ids.js';
+import {escapeXmlAttribute, escapeXmlText} from './xml.js';
interface JdkInfo {
version: string;
@@ -14,23 +14,6 @@ interface JdkInfo {
jdkHome: string;
}
-export function validateToolchainIds(
- versions: string[],
- versionFile: string,
- toolchainIds: string[]
-) {
- if (!toolchainIds.length) {
- return;
- }
-
- const versionCount = versions.length || (versionFile ? 1 : 0);
- if (versionCount !== toolchainIds.length) {
- throw new Error(
- `The number of Maven toolchain IDs (${toolchainIds.length}) must match the number of Java versions (${versionCount})`
- );
- }
-}
-
export async function configureToolchains(
version: string,
distributionName: string,
@@ -70,7 +53,7 @@ export async function createToolchainsSettings({
await io.mkdirP(settingsDirectory);
const originalToolchains =
await readExistingToolchainsFile(settingsDirectory);
- const updatedToolchains = generateToolchainDefinition(
+ const updatedToolchains = await generateToolchainDefinition(
originalToolchains,
jdkInfo.version,
jdkInfo.vendor,
@@ -81,7 +64,27 @@ export async function createToolchainsSettings({
}
// only exported for testing purposes
-export function generateToolchainDefinition(
+export async function generateToolchainDefinition(
+ original: string,
+ version: string,
+ vendor: string,
+ id: string,
+ jdkHome: string
+) {
+ if (!original?.length) {
+ return generateNewToolchainDefinition(version, vendor, id, jdkHome);
+ }
+
+ return generateMergedToolchainDefinition(
+ original,
+ version,
+ vendor,
+ id,
+ jdkHome
+ );
+}
+
+async function generateMergedToolchainDefinition(
original: string,
version: string,
vendor: string,
@@ -108,62 +111,75 @@ export function generateToolchainDefinition(
'@xsi:schemaLocation':
'http://maven.apache.org/TOOLCHAINS/1.1.0 https://maven.apache.org/xsd/toolchains-1.1.0.xsd'
};
- if (original?.length) {
- // convert existing toolchains into TS native objects for better handling
- // xmlbuilder2 will convert the document into a `{toolchains: { toolchain: [] | {} }}` structure
- // instead of the desired `toolchains: [{}]` one or simply `[{}]`
- const jsObj = xmlCreate(original)
- .root()
- .toObject() as unknown as ExtractedToolchains;
- if (jsObj.toolchains) {
- // preserve the existing root attributes (xmlns, schemaLocation, …) so we don't
- // silently rewrite user-managed metadata or change the effective XML namespace;
- // xmlbuilder2 exposes attributes as `@`-prefixed keys on the element object
- const existingAttributes = Object.fromEntries(
- Object.entries(jsObj.toolchains).filter(([key]) => key.startsWith('@'))
- ) as Record;
- // fall back to the defaults only for attributes the existing file is missing
- rootAttributes = {...rootAttributes, ...existingAttributes};
+ const {XMLParser} = await import('fast-xml-parser');
+ const parser = new XMLParser({
+ ignoreAttributes: false,
+ attributeNamePrefix: '@',
+ parseAttributeValue: false,
+ parseTagValue: false,
+ trimValues: true,
+ isArray: tagName => tagName === 'toolchain'
+ });
+ const jsObj = parser.parse(original) as ExtractedToolchains;
+ if (isToolchainsRoot(jsObj.toolchains)) {
+ // preserve the existing root attributes (xmlns, schemaLocation, …) so we don't
+ // silently rewrite user-managed metadata or change the effective XML namespace;
+ // fast-xml-parser exposes attributes as `@`-prefixed keys on the element object
+ const existingAttributes = Object.fromEntries(
+ Object.entries(jsObj.toolchains).filter(
+ ([key, value]) => key.startsWith('@') && typeof value === 'string'
+ )
+ ) as Record;
+ // fall back to the defaults only for attributes the existing file is missing
+ rootAttributes = {...rootAttributes, ...existingAttributes};
- if (jsObj.toolchains.toolchain) {
- // in case only a single child exists xmlbuilder2 will not create an array and using verbose = true equally doesn't work here
- // See https://oozcitak.github.io/xmlbuilder2/serialization.html#js-object-and-map-serializers for details
- if (Array.isArray(jsObj.toolchains.toolchain)) {
- jsToolchains.push(...jsObj.toolchains.toolchain);
- } else {
- jsToolchains.push(jsObj.toolchains.toolchain);
- }
- }
+ if (jsObj.toolchains.toolchain) {
+ jsToolchains.push(...jsObj.toolchains.toolchain);
}
-
- // remove potential duplicates based on type & id (which should be a unique combination);
- // self.findIndex will only return the first occurrence, ensuring duplicates are skipped
- jsToolchains = jsToolchains.filter(
- (value, index, self) =>
- // ensure non-jdk toolchains are kept in the results, we must not touch them because they belong to the user
- value.type !== 'jdk' ||
- // keep toolchains that lack a usable string id (e.g. partially-formed user files);
- // we cannot safely deduplicate them and must not crash while reading them
- typeof value.provides?.id !== 'string' ||
- index ===
- self.findIndex(
- t => t.type === value.type && t.provides?.id === value.provides?.id
- )
- );
}
- return xmlCreate({
- toolchains: {
- ...rootAttributes,
- toolchain: jsToolchains
- }
- }).end({
- format: 'xml',
- wellFormed: false,
- headless: false,
- prettyPrint: true,
- width: 80
- });
+ // remove potential duplicates based on type & id (which should be a unique combination);
+ // self.findIndex will only return the first occurrence, ensuring duplicates are skipped
+ jsToolchains = jsToolchains.filter(
+ (value, index, self) =>
+ // ensure non-jdk toolchains are kept in the results, we must not touch them because they belong to the user
+ value.type !== 'jdk' ||
+ // keep toolchains that lack a usable string id (e.g. partially-formed user files);
+ // we cannot safely deduplicate them and must not crash while reading them
+ typeof value.provides?.id !== 'string' ||
+ index ===
+ self.findIndex(
+ t => t.type === value.type && t.provides?.id === value.provides?.id
+ )
+ );
+
+ return serializeToolchains(rootAttributes, jsToolchains);
+}
+
+export function generateNewToolchainDefinition(
+ version: string,
+ vendor: string,
+ id: string,
+ jdkHome: string
+) {
+ return [
+ '',
+ '',
+ ' ',
+ ' jdk',
+ ' ',
+ ` ${escapeXmlText(version)}`,
+ ` ${escapeXmlText(vendor)}`,
+ ` ${escapeXmlText(id)}`,
+ ' ',
+ ' ',
+ ` ${escapeXmlText(jdkHome)}`,
+ ' ',
+ ' ',
+ ''
+ ].join('\n');
}
async function readExistingToolchainsFile(directory: string) {
@@ -198,23 +214,134 @@ async function writeToolchainsFileToDisk(directory: string, settings: string) {
});
}
+function serializeToolchains(
+ rootAttributes: Record,
+ toolchains: Toolchain[]
+) {
+ return [
+ '',
+ serializeOpeningTag('toolchains', rootAttributes, 0),
+ ...toolchains.flatMap(toolchain =>
+ serializeXmlElement('toolchain', toolchain, 1)
+ ),
+ ''
+ ].join('\n');
+}
+
+function serializeOpeningTag(
+ name: string,
+ attributes: Record,
+ depth: number
+) {
+ const indent = ' '.repeat(depth);
+ const attributeEntries = Object.entries(attributes);
+ if (!attributeEntries.length) {
+ return `${indent}<${name}>`;
+ }
+
+ const [firstAttribute, ...restAttributes] = attributeEntries;
+ const lines = [
+ `${indent}<${name} ${formatXmlAttribute(firstAttribute)}`,
+ ...restAttributes.map(([attributeName, value]) => {
+ return `${indent} ${formatXmlAttribute([attributeName, value])}`;
+ })
+ ];
+ lines[lines.length - 1] += '>';
+ return lines.join('\n');
+}
+
+function serializeXmlElement(
+ name: string,
+ value: XmlElementValue,
+ depth: number
+): string[] {
+ const indent = ' '.repeat(depth);
+ if (Array.isArray(value)) {
+ return value.flatMap(item => serializeXmlElement(name, item, depth));
+ }
+
+ if (!isXmlElementObject(value)) {
+ return [
+ `${indent}<${name}>${escapeXmlText(String(value ?? ''))}`
+ ];
+ }
+
+ const attributes = Object.fromEntries(
+ Object.entries(value)
+ .filter(([key, attributeValue]) => {
+ return key.startsWith('@') && typeof attributeValue === 'string';
+ })
+ .map(([key, attributeValue]) => [key, attributeValue as string])
+ );
+ const childEntries = Object.entries(value).filter(
+ ([key]) => !key.startsWith('@') && key !== '#text'
+ );
+ const textValue = value['#text'];
+
+ if (!childEntries.length) {
+ if (textValue !== undefined) {
+ return [
+ `${serializeOpeningTag(name, attributes, depth)}${escapeXmlText(
+ String(textValue ?? '')
+ )}`
+ ];
+ }
+ return [`${serializeOpeningTag(name, attributes, depth)}`];
+ }
+
+ return [
+ serializeOpeningTag(name, attributes, depth),
+ ...(textValue === undefined
+ ? []
+ : [`${' '.repeat(depth + 1)}${escapeXmlText(String(textValue ?? ''))}`]),
+ ...childEntries.flatMap(([childName, childValue]) =>
+ serializeXmlElement(childName, childValue, depth + 1)
+ ),
+ `${indent}`
+ ];
+}
+
+function formatXmlAttribute([name, value]: [string, string]) {
+ return `${name.slice(1)}="${escapeXmlAttribute(value)}"`;
+}
+
+function isToolchainsRoot(value: ExtractedToolchains['toolchains']) {
+ return isXmlElementObject(value);
+}
+
+function isXmlElementObject(
+ value: unknown
+): value is Record {
+ return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
interface ExtractedToolchains {
- toolchains: {
- // root attributes such as xmlns / schemaLocation are exposed as `@`-prefixed keys
- [attribute: `@${string}`]: string;
- toolchain?: Toolchain[] | Toolchain;
- };
+ toolchains: ToolchainsRoot | string;
+}
+
+interface ToolchainsRoot extends XmlElementObject {
+ // root attributes such as xmlns / schemaLocation are exposed as `@`-prefixed keys
+ [attribute: `@${string}`]: string;
+ toolchain?: Toolchain[];
}
// Toolchain type definition according to Maven Toolchains XSD 1.1.0
interface Toolchain {
type: string;
- provides:
- | {
- version: string;
- vendor: string;
- id: string;
- }
- | any;
- configuration: any;
+ provides?: XmlElementObject;
+ configuration?: XmlElementObject;
+ [customElement: string]: XmlElementValue;
}
+
+interface XmlElementObject {
+ [name: string]: XmlElementValue;
+}
+
+type XmlElementValue =
+ | string
+ | number
+ | boolean
+ | null
+ | undefined
+ | XmlElementObject
+ | XmlElementValue[];
diff --git a/src/xml.ts b/src/xml.ts
new file mode 100644
index 00000000..a61d55cf
--- /dev/null
+++ b/src/xml.ts
@@ -0,0 +1,12 @@
+export function escapeXmlText(value: string): string {
+ return value
+ .replace(/&/g, '&')
+ .replace(//g, '>');
+}
+
+// Use for user-controlled values written into XML attributes. Text nodes should
+// use escapeXmlText so quotes remain byte-compatible with previous output.
+export function escapeXmlAttribute(value: string): string {
+ return escapeXmlText(value).replace(/"/g, '"').replace(/'/g, ''');
+}