Some text.
Hello, world.
'); + * + * $('h1').html(); + * //=> 'Hello, world.'
+ * ```
+ *
+ * @example To render the markup of an entire document, invoke the
+ * `html` function exported by the Cheerio module with a "root"
+ * selection.
+ *
+ * ```js
+ * cheerio.html($.root());
+ * //=> 'Hello, world.
'
+ * ```
+ */
+ describe('.html - deprecated API', () => {
+ it('() : of empty cheerio object should return null', () => {
+ /*
+ * Note: the direct invocation of the Cheerio constructor function is
+ * also deprecated.
+ */
+ const $ = cheerio();
+ expect($.html()).toBe(null);
+ });
+
+ it('(selector) : should return the outerHTML of the selected element', () => {
+ const $ = cheerio.load(fruits);
+ expect($.html('.pear')).toBe('
Hello, world.
'); + * $('h1').text(); + * //=> 'Hello, world.' + * ``` + * + * @examplea child with another child and not a comment followed by one last child and some final
text.',
+ );
+ expect($.text($('a'))).toBe(
+ 'This is a child with another child and not a comment followed by one last child and some final text.',
+ );
+ });
+
+ it('() : should return the rendered text content of the root', () => {
+ const $ = cheerio.load(
+ 'This is a child with another child and not a comment followed by one last child and some final
text.',
+ );
+ expect($.text()).toBe(
+ 'This is a child with another child and not a comment followed by one last child and some final text.',
+ );
+ });
+
+ it('(cheerio object) : should not omit script tags', () => {
+ const $ = cheerio.load('');
+ expect($.text()).toBe('console.log("test")');
+ });
+
+ it('(cheerio object) : should omit style tags', () => {
+ const $ = cheerio.load(
+ '',
+ );
+ expect($.text()).toBe('.cf-hidden { display: none; }');
+ });
+ });
+ });
+});
diff --git a/frontend/node_modules/cheerio/src/__tests__/xml.spec.ts b/frontend/node_modules/cheerio/src/__tests__/xml.spec.ts
new file mode 100644
index 0000000..22d32fe
--- /dev/null
+++ b/frontend/node_modules/cheerio/src/__tests__/xml.spec.ts
@@ -0,0 +1,66 @@
+import { describe, it, expect } from 'vitest';
+import { load } from '../index.js';
+import type { CheerioOptions } from '../options.js';
+
+function xml(str: string, options?: CheerioOptions) {
+ options = { xml: true, ...options };
+ const $ = load(str, options);
+ return $.xml();
+}
+
+function dom(str: string, options?: CheerioOptions) {
+ const $ = load('', options);
+ return $(str).html();
+}
+
+describe('render', () => {
+ describe('(xml)', () => {
+ it('should render 
+
+
+ Hello, testing text function,
End of message',
+ );
+ expect($('body').prop('textContent')).toBe(
+ 'Welcome Hello, testing text function,console.log("hello").cf-hidden { display: none; }End of message',
+ );
+ expect($('style').prop('textContent')).toBe(
+ '.cf-hidden { display: none; }',
+ );
+ expect($('script').prop('textContent')).toBe('console.log("hello")');
+ });
+
+ it('("innerText") : should render properly', () => {
+ expect($('select').children().prop('innerText')).toBe(
+ 'Option not selected',
+ );
+
+ expect($(script).prop('innerText')).toBe('AB');
+
+ expect($(undefined).prop('innerText')).toBeUndefined();
+ });
+
+ it('("innerText") : should omit style and script tags', () => {
+ const $ = load(
+ 'Welcome Hello, testing text function,
End of message',
+ );
+ expect($('body').prop('innerText')).toBe(
+ 'Welcome Hello, testing text function,End of message',
+ );
+ expect($('style').prop('innerText')).toBe('');
+ expect($('script').prop('innerText')).toBe('');
+ });
+
+ it('(inherited properties) : prop should support inherited properties', () => {
+ expect($('select').prop('childNodes')).toBe($('select')[0].childNodes);
+ });
+
+ it('(key) : should skip text nodes', () => {
+ const $text = load(mixedText);
+ const $body = $text($text('body')[0].children);
+
+ expect($text($body[1]).prop('tagName')).toBeUndefined();
+
+ $body.prop('test-name', () => 'tester');
+ expect($text('body').html()).toBe(
+ '1TEXT2',
+ );
+ });
+
+ it("(bool) shouldn't treat boolean attributes differently in XML mode", () => {
+ const $xml = $.load(``, {
+ xml: true,
+ })('input');
+
+ expect($xml.prop('checked')).toBe('checked');
+ expect($xml.prop('disabled')).toBe('yes');
+ });
+ });
+
+ describe('.data', () => {
+ let $: CheerioAPI;
+
+ beforeEach(() => {
+ $ = load(chocolates);
+ });
+
+ it('() : should get all data attributes initially declared in the markup', () => {
+ const data = $('.linth').data();
+ expect(data).toStrictEqual({
+ highlight: 'Lindor',
+ origin: 'swiss',
+ });
+ });
+
+ it('() : should get all data set via `data`', () => {
+ const $el = cheerio('');
+ $el.data('a', 1);
+ $el.data('b', 2);
+
+ expect($el.data()).toStrictEqual({
+ a: 1,
+ b: 2,
+ });
+ });
+
+ it('() : should get all data attributes initially declared in the markup merged with all data additionally set via `data`', () => {
+ const $el = cheerio('
');
+ $el.data('b', 'b-modified');
+ $el.data('c', 'c');
+
+ expect($el.data()).toStrictEqual({
+ a: 'a',
+ b: 'b-modified',
+ c: 'c',
+ });
+ });
+
+ it('() : no data attribute should return an empty object', () => {
+ const data = $('.cailler').data();
+ expect(Object.keys(data)).toHaveLength(0);
+ expect($('.free').data()).toBeUndefined();
+ });
+
+ it('(invalid key) : invalid data attribute should return `undefined`', () => {
+ const data = $('.frey').data('lol');
+ expect(data).toBeUndefined();
+ });
+
+ it('(valid key) : valid data attribute should get value', () => {
+ const highlight = $('.linth').data('highlight');
+ const origin = $('.linth').data('origin');
+
+ expect(highlight).toBe('Lindor');
+ expect(origin).toBe('swiss');
+ });
+
+ it('(key) : should translate camel-cased key values to hyphen-separated versions', () => {
+ const $el = cheerio(
+ '
',
+ );
+
+ expect($el.data('ThreeWordAttribute')).toBe('a');
+ expect($el.data('fooBar_baz-')).toBe('b');
+ });
+
+ it('(key) : should retrieve object values', () => {
+ const data = {};
+ const $el = cheerio('
');
+
+ $el.data('test', data);
+
+ expect($el.data('test')).toBe(data);
+ });
+
+ it('(key) : should parse JSON data derived from the markup', () => {
+ const $el = cheerio('
');
+
+ expect($el.data('json')).toStrictEqual([1, 2, 3]);
+ });
+
+ it('(key) : should not parse JSON data set via the `data` API', () => {
+ const $el = cheerio('
');
+ $el.data('json', '[1, 2, 3]');
+
+ expect($el.data('json')).toBe('[1, 2, 3]');
+ });
+
+ // See https://api.jquery.com/data/ and https://bugs.jquery.com/ticket/14523
+ it('(key) : should ignore the markup value after the first access', () => {
+ const $el = cheerio('
');
+
+ expect($el.data('test')).toBe('a');
+
+ $el.attr('data-test', 'b');
+
+ expect($el.data('test')).toBe('a');
+ });
+
+ it('(key) : should recover from malformed JSON', () => {
+ const $el = cheerio('
');
+
+ expect($el.data('custom')).toBe('{{templatevar}}');
+ });
+
+ it('("") : should accept the empty string as a name', () => {
+ const $el = cheerio('
');
+
+ expect($el.data('')).toBe('a');
+ });
+
+ it('(hyphen key) : data addribute with hyphen should be camelized ;-)', () => {
+ const data = $('.frey').data();
+ expect(data).toStrictEqual({
+ taste: 'sweet',
+ bestCollection: 'Mahony',
+ });
+ });
+
+ it('(key, value) : should set data attribute', () => {
+ // Adding as object.
+ const a = $('.frey').data({
+ balls: 'giandor',
+ });
+ // Adding as string.
+ const b = $('.linth').data('snack', 'chocoletti');
+
+ expect(() => {
+ a.data(4 as never, 'throw');
+ }).not.toThrow();
+ expect(a.data('balls')).toStrictEqual('giandor');
+ expect(b.data('snack')).toStrictEqual('chocoletti');
+ });
+
+ it('(key, value) : should set data for all elements in the selection', () => {
+ $('li').data('foo', 'bar');
+
+ expect($('li').eq(0).data('foo')).toStrictEqual('bar');
+ expect($('li').eq(1).data('foo')).toStrictEqual('bar');
+ expect($('li').eq(2).data('foo')).toStrictEqual('bar');
+ });
+
+ it('(map) : object map should set multiple data attributes', () => {
+ const { data } = $('.linth').data({
+ id: 'Cailler',
+ flop: 'Pippilotti Rist',
+ top: 'Frigor',
+ url: 'http://www.cailler.ch/',
+ })[0] as never;
+
+ expect(data).toHaveProperty('id', 'Cailler');
+ expect(data).toHaveProperty('flop', 'Pippilotti Rist');
+ expect(data).toHaveProperty('top', 'Frigor');
+ expect(data).toHaveProperty('url', 'http://www.cailler.ch/');
+ });
+
+ describe('(attr) : data-* attribute type coercion :', () => {
+ it('boolean', () => {
+ const $el = cheerio('
');
+ expect($el.data('bool')).toBe(true);
+ });
+
+ it('number', () => {
+ const $el = cheerio('
');
+ expect($el.data('number')).toBe(23);
+ });
+
+ it('number (scientific notation is not coerced)', () => {
+ const $el = cheerio('
');
+ expect($el.data('sci')).toBe('1E10');
+ });
+
+ it('null', () => {
+ const $el = cheerio('
');
+ expect($el.data('null')).toBe(null);
+ });
+
+ it('object', () => {
+ const $el = cheerio('
');
+ expect($el.data('obj')).toStrictEqual({ a: 45 });
+ });
+
+ it('array', () => {
+ const $el = cheerio('
');
+ expect($el.data('array')).toStrictEqual([1, 2, 3]);
+ });
+ });
+
+ it('(key, value) : should skip text nodes', () => {
+ const $text = load(mixedText);
+ const $body = $text($text('body')[0].children);
+
+ $body.data('snack', 'chocoletti');
+
+ expect($text('b').data('snack')).toBe('chocoletti');
+ });
+ });
+
+ describe('.val', () => {
+ let $: CheerioAPI;
+
+ beforeEach(() => {
+ $ = load(inputs);
+ });
+
+ it('(): on div should get undefined', () => {
+ expect($('
').val()).toBeUndefined();
+ });
+
+ it('(): on select should get value', () => {
+ const val = $('select#one').val();
+ expect(val).toBe('option_selected');
+ });
+ it('(): on select with no value should get text', () => {
+ const val = $('select#one-valueless').val();
+ expect(val).toBe('Option selected');
+ });
+ it('(): on select with no value should get converted HTML', () => {
+ const val = $('select#one-html-entity').val();
+ expect(val).toBe('Option ');
+ });
+ it('(): on select with no value should get text content', () => {
+ const val = $('select#one-nested').val();
+ expect(val).toBe('Option selected');
+ });
+ it('(): on option should get value', () => {
+ const val = $('select#one option').eq(0).val();
+ expect(val).toBe('option_not_selected');
+ });
+ it('(): on text input should get value', () => {
+ const val = $('input[type="text"]').val();
+ expect(val).toBe('input_text');
+ });
+ it('(): on checked checkbox should get value', () => {
+ const val = $('input[name="checkbox_on"]').val();
+ expect(val).toBe('on');
+ });
+ it('(): on unchecked checkbox should get value', () => {
+ const val = $('input[name="checkbox_off"]').val();
+ expect(val).toBe('off');
+ });
+ it('(): on valueless checkbox should get value', () => {
+ const val = $('input[name="checkbox_valueless"]').val();
+ expect(val).toBe('on');
+ });
+ it('(): on radio should get value', () => {
+ const val = $('input[type="radio"]').val();
+ expect(val).toBe('off');
+ });
+ it('(): on valueless radio should get value', () => {
+ const val = $('input[name="radio_valueless"]').val();
+ expect(val).toBe('on');
+ });
+ it('(): on multiple select should get an array of values', () => {
+ const val = $('select#multi').val();
+ expect(val).toStrictEqual(['2', '3']);
+ });
+ it('(): on multiple select with no value attribute should get an array of text content', () => {
+ const val = $('select#multi-valueless').val();
+ expect(val).toStrictEqual(['2', '3']);
+ });
+ it('(): with no selector matches should return nothing', () => {
+ const val = $('.nasty').val();
+ expect(val).toBeUndefined();
+ });
+ it('(invalid value): should only handle arrays when it has the attribute multiple', () => {
+ const val = $('select#one').val([]);
+ expect(val).not.toBeUndefined();
+ });
+ it('(value): on empty set should get `this`', () => {
+ const $empty = $([]);
+ expect($empty.val('test')).toBe($empty);
+ });
+ it('(value): on input text should set value', () => {
+ const element = $('input[type="text"]').val('test');
+ expect(element.val()).toBe('test');
+ });
+ it('(value): on select should set value', () => {
+ const element = $('select#one').val('option_not_selected');
+ expect(element.val()).toBe('option_not_selected');
+ });
+ it('(value): on option should set value', () => {
+ const element = $('select#one option').eq(0).val('option_changed');
+ expect(element.val()).toBe('option_changed');
+ });
+ it('(value): on radio should set value', () => {
+ const element = $('input[name="radio"]').val('off');
+ expect(element.val()).toBe('off');
+ });
+ it('(value): on radio with special characters should set value', () => {
+ const element = $('input[name="radio[brackets]"]').val('off');
+ expect(element.val()).toBe('off');
+ });
+ it('(values): on multiple select should set multiple values', () => {
+ const element = $('select#multi').val(['1', '3', '4']);
+ expect(element.val()).toHaveLength(3);
+ });
+ });
+
+ describe('.removeAttr', () => {
+ let $: CheerioAPI;
+
+ beforeEach(() => {
+ $ = load(fruits);
+ });
+
+ it('(key) : should remove a single attr', () => {
+ const $fruits = $('#fruits');
+ expect($fruits.attr('id')).not.toBeUndefined();
+ $fruits.removeAttr('id');
+ expect($fruits.attr('id')).toBeUndefined();
+ });
+
+ it('(key key) : should remove multiple attrs', () => {
+ const $apple = $('.apple');
+ $apple.attr('id', 'favorite');
+ $apple.attr('size', 'small');
+
+ expect($apple.attr('id')).toBe('favorite');
+ expect($apple.attr('class')).toBe('apple');
+ expect($apple.attr('size')).toBe('small');
+ $apple.removeAttr('id class');
+ expect($apple.attr('id')).toBeUndefined();
+ expect($apple.attr('class')).toBeUndefined();
+ expect($apple.attr('size')).toBe('small');
+ });
+
+ it('(key) : should return cheerio object', () => {
+ const obj = $('ul').removeAttr('id');
+ expect(obj).toBeInstanceOf($);
+ });
+
+ it('(key) : should skip text nodes', () => {
+ const $text = load(mixedText);
+ const $body = $text($text('body')[0].children);
+
+ $body.addClass(() => 'test');
+
+ expect($text('body').html()).toBe(
+ '1TEXT2',
+ );
+
+ $body.removeAttr('class');
+
+ expect($text('body').html()).toBe(mixedText);
+ });
+ });
+
+ describe('.hasClass', () => {
+ let $: CheerioAPI;
+
+ beforeEach(() => {
+ $ = load(fruits);
+ });
+
+ it('(valid class) : should return true', () => {
+ const cls = $('.apple').hasClass('apple');
+ expect(cls).toBe(true);
+
+ expect(withClass('foo').hasClass('foo')).toBe(true);
+ expect(withClass('foo bar').hasClass('foo')).toBe(true);
+ expect(withClass('bar foo').hasClass('foo')).toBe(true);
+ expect(withClass('bar foo bar').hasClass('foo')).toBe(true);
+ });
+
+ it('(invalid class) : should return false', () => {
+ const cls = $('#fruits').hasClass('fruits');
+ expect(cls).toBe(false);
+ expect(withClass('foo-bar').hasClass('foo')).toBe(false);
+ expect(withClass('foo-bar').hasClass('foo')).toBe(false);
+ expect(withClass('foo-bar').hasClass('foo-ba')).toBe(false);
+ });
+
+ it('should check multiple classes', () => {
+ // Add a class
+ $('.apple').addClass('red');
+ expect($('.apple').hasClass('apple')).toBe(true);
+ expect($('.apple').hasClass('red')).toBe(true);
+
+ // Remove one and test again
+ $('.apple').removeClass('apple');
+ expect($('li').eq(0).hasClass('apple')).toBe(false);
+ });
+
+ it('(empty string argument) : should return false', () => {
+ expect(withClass('foo').hasClass('')).toBe(false);
+ expect(withClass('foo bar').hasClass('')).toBe(false);
+ expect(withClass('foo bar').removeClass('foo').hasClass('')).toBe(false);
+ });
+ });
+
+ describe('.addClass', () => {
+ let $: CheerioAPI;
+
+ beforeEach(() => {
+ $ = load(fruits);
+ });
+
+ it('(first class) : should add the class to the element', () => {
+ const $fruits = $('#fruits');
+ $fruits.addClass('fruits');
+ const cls = $fruits.hasClass('fruits');
+ expect(cls).toBe(true);
+ });
+
+ it('(single class) : should add the class to the element', () => {
+ $('.apple').addClass('fruit');
+ const cls = $('.apple').hasClass('fruit');
+ expect(cls).toBe(true);
+ });
+
+ it('(class): adds classes to many selected items', () => {
+ $('li').addClass('fruit');
+ expect($('.apple').hasClass('fruit')).toBe(true);
+ expect($('.orange').hasClass('fruit')).toBe(true);
+ expect($('.pear').hasClass('fruit')).toBe(true);
+
+ // Mixed with text nodes
+ const $red = $('\n | undefined;
+function getAttr(
+ elem: AnyNode,
+ name: string,
+ xmlMode?: boolean,
+): string | undefined;
+function getAttr(
+ elem: AnyNode,
+ name: string | undefined,
+ xmlMode?: boolean,
+): Record | string | undefined {
+ if (!elem || !isTag(elem)) return undefined;
+
+ elem.attribs ??= {};
+
+ // Return the entire attribs object if no attribute specified
+ if (!name) {
+ return elem.attribs;
+ }
+
+ if (hasOwn.call(elem.attribs, name)) {
+ // Get the (decoded) attribute
+ return !xmlMode && rboolean.test(name) ? name : elem.attribs[name];
+ }
+
+ // Mimic the DOM and return text content as value for `option's`
+ if (elem.name === 'option' && name === 'value') {
+ return text(elem.children);
+ }
+
+ // Mimic DOM with default value for radios/checkboxes
+ if (
+ elem.name === 'input' &&
+ (elem.attribs['type'] === 'radio' || elem.attribs['type'] === 'checkbox') &&
+ name === 'value'
+ ) {
+ return 'on';
+ }
+
+ return undefined;
+}
+
+/**
+ * Sets the value of an attribute. The attribute will be deleted if the value is
+ * `null`.
+ *
+ * @private
+ * @param el - The element to set the attribute on.
+ * @param name - The attribute's name.
+ * @param value - The attribute's value.
+ */
+function setAttr(el: Element, name: string, value: string | null) {
+ if (value === null) {
+ removeAttribute(el, name);
+ } else {
+ el.attribs[name] = `${value}`;
+ }
+}
+
+/**
+ * Method for getting attributes. Gets the attribute value for only the first
+ * element in the matched set.
+ *
+ * @category Attributes
+ * @example
+ *
+ * ```js
+ * $('ul').attr('id');
+ * //=> fruits
+ * ```
+ *
+ * @param name - Name of the attribute.
+ * @returns The attribute's value.
+ * @see {@link https://api.jquery.com/attr/}
+ */
+export function attr(
+ this: Cheerio,
+ name: string,
+): string | undefined;
+/**
+ * Method for getting all attributes and their values of the first element in
+ * the matched set.
+ *
+ * @category Attributes
+ * @example
+ *
+ * ```js
+ * $('ul').attr();
+ * //=> { id: 'fruits' }
+ * ```
+ *
+ * @returns The attribute's values.
+ * @see {@link https://api.jquery.com/attr/}
+ */
+export function attr(
+ this: Cheerio,
+): Record | undefined;
+/**
+ * Method for setting attributes. Sets the attribute value for only the first
+ * element in the matched set. If you set an attribute's value to `null`, you
+ * remove that attribute. You may also pass a `map` and `function`.
+ *
+ * @category Attributes
+ * @example
+ *
+ * ```js
+ * $('.apple').attr('id', 'favorite').html();
+ * //=> Apple
+ * ```
+ *
+ * @param name - Name of the attribute.
+ * @param value - The new value of the attribute.
+ * @returns The instance itself.
+ * @see {@link https://api.jquery.com/attr/}
+ */
+export function attr(
+ this: Cheerio,
+ name: string,
+ value?:
+ | string
+ | null
+ | ((this: Element, i: number, attrib: string) => string | null),
+): Cheerio;
+/**
+ * Method for setting multiple attributes at once. Sets the attribute value for
+ * only the first element in the matched set. If you set an attribute's value to
+ * `null`, you remove that attribute.
+ *
+ * @category Attributes
+ * @example
+ *
+ * ```js
+ * $('.apple').attr({ id: 'favorite' }).html();
+ * //=> Apple
+ * ```
+ *
+ * @param values - Map of attribute names and values.
+ * @returns The instance itself.
+ * @see {@link https://api.jquery.com/attr/}
+ */
+export function attr(
+ this: Cheerio,
+ values: Record,
+): Cheerio;
+export function attr(
+ this: Cheerio,
+ name?: string | Record,
+ value?:
+ | string
+ | null
+ | ((this: Element, i: number, attrib: string) => string | null),
+): string | Cheerio | undefined | Record {
+ // Set the value (with attr map support)
+ if (typeof name === 'object' || value !== undefined) {
+ if (typeof value === 'function') {
+ if (typeof name !== 'string') {
+ {
+ throw new Error('Bad combination of arguments.');
+ }
+ }
+ return domEach(this, (el, i) => {
+ if (isTag(el)) setAttr(el, name, value.call(el, i, el.attribs[name]));
+ });
+ }
+ return domEach(this, (el) => {
+ if (!isTag(el)) return;
+
+ if (typeof name === 'object') {
+ for (const objName of Object.keys(name)) {
+ const objValue = name[objName];
+ setAttr(el, objName, objValue);
+ }
+ } else {
+ setAttr(el, name as string, value as string);
+ }
+ });
+ }
+
+ return arguments.length > 1
+ ? this
+ : getAttr(this[0], name as string, this.options.xmlMode);
+}
+
+/**
+ * Gets a node's prop.
+ *
+ * @private
+ * @category Attributes
+ * @param el - Element to get the prop of.
+ * @param name - Name of the prop.
+ * @param xmlMode - Disable handling of special HTML attributes.
+ * @returns The prop's value.
+ */
+function getProp(
+ el: Element,
+ name: string,
+ xmlMode?: boolean,
+): string | undefined | Element[keyof Element] {
+ return name in el
+ ? // @ts-expect-error TS doesn't like us accessing the value directly here.
+ el[name]
+ : !xmlMode && rboolean.test(name)
+ ? getAttr(el, name, false) !== undefined
+ : getAttr(el, name, xmlMode);
+}
+
+/**
+ * Sets the value of a prop.
+ *
+ * @private
+ * @param el - The element to set the prop on.
+ * @param name - The prop's name.
+ * @param value - The prop's value.
+ * @param xmlMode - Disable handling of special HTML attributes.
+ */
+function setProp(el: Element, name: string, value: unknown, xmlMode?: boolean) {
+ if (name in el) {
+ // @ts-expect-error Overriding value
+ el[name] = value;
+ } else {
+ setAttr(
+ el,
+ name,
+ !xmlMode && rboolean.test(name) ? (value ? '' : null) : `${value}`,
+ );
+ }
+}
+
+interface StyleProp {
+ length: number;
+ [key: string]: string | number;
+ [index: number]: string;
+}
+
+/**
+ * Method for getting and setting properties. Gets the property value for only
+ * the first element in the matched set.
+ *
+ * @category Attributes
+ * @example
+ *
+ * ```js
+ * $('input[type="checkbox"]').prop('checked');
+ * //=> false
+ *
+ * $('input[type="checkbox"]').prop('checked', true).val();
+ * //=> ok
+ * ```
+ *
+ * @param name - Name of the property.
+ * @returns If `value` is specified the instance itself, otherwise the prop's
+ * value.
+ * @see {@link https://api.jquery.com/prop/}
+ */
+export function prop(
+ this: Cheerio,
+ name: 'tagName' | 'nodeName',
+): string | undefined;
+export function prop(
+ this: Cheerio,
+ name: 'innerHTML' | 'outerHTML' | 'innerText' | 'textContent',
+): string | null;
+/**
+ * Get a parsed CSS style object.
+ *
+ * @param name - Name of the property.
+ * @returns The style object, or `undefined` if the element has no `style`
+ * attribute.
+ */
+export function prop(
+ this: Cheerio,
+ name: 'style',
+): StyleProp | undefined;
+/**
+ * Resolve `href` or `src` of supported elements. Requires the `baseURI` option
+ * to be set, and a global `URL` object to be part of the environment.
+ *
+ * @example With `baseURI` set to `'https://example.com'`:
+ *
+ * ```js
+ * $('
').prop('src');
+ * //=> 'https://example.com/image.png'
+ * ```
+ *
+ * @param name - Name of the property.
+ * @returns The resolved URL, or `undefined` if the element is not supported.
+ */
+export function prop(
+ this: Cheerio,
+ name: 'href' | 'src',
+): string | undefined;
+/**
+ * Get a property of an element.
+ *
+ * @param name - Name of the property.
+ * @returns The property's value.
+ */
+export function prop(
+ this: Cheerio,
+ name: K,
+): Element[K];
+/**
+ * Set a property of an element.
+ *
+ * @param name - Name of the property.
+ * @param value - Value to set the property to.
+ * @returns The instance itself.
+ */
+export function prop(
+ this: Cheerio,
+ name: K,
+ value:
+ | Element[K]
+ | ((this: Element, i: number, prop: K) => Element[keyof Element]),
+): Cheerio;
+/**
+ * Set multiple properties of an element.
+ *
+ * @example
+ *
+ * ```js
+ * $('input[type="checkbox"]').prop({
+ * checked: true,
+ * disabled: false,
+ * });
+ * ```
+ *
+ * @param map - Object of properties to set.
+ * @returns The instance itself.
+ */
+export function prop(
+ this: Cheerio,
+ map: Record,
+): Cheerio;
+/**
+ * Set a property of an element.
+ *
+ * @param name - Name of the property.
+ * @param value - Value to set the property to.
+ * @returns The instance itself.
+ */
+export function prop(
+ this: Cheerio,
+ name: string,
+ value:
+ | string
+ | boolean
+ | null
+ | ((this: Element, i: number, prop: string) => string | boolean),
+): Cheerio;
+/**
+ * Get a property of an element.
+ *
+ * @param name - The property's name.
+ * @returns The property's value.
+ */
+export function prop(this: Cheerio, name: string): string;
+export function prop(
+ this: Cheerio,
+ name: string | Record,
+ value?:
+ | ((
+ this: Element,
+ i: number,
+ prop: string | undefined,
+ ) => string | Element[keyof Element] | boolean)
+ | unknown,
+): Cheerio | string | undefined | null | Element[keyof Element] | StyleProp {
+ if (typeof name === 'string' && value === undefined) {
+ const el = this[0];
+
+ if (!el || !isTag(el)) return undefined;
+
+ switch (name) {
+ case 'style': {
+ const property = this.css() as StyleProp;
+ const keys = Object.keys(property);
+ for (let i = 0; i < keys.length; i++) {
+ property[i] = keys[i];
+ }
+
+ property.length = keys.length;
+
+ return property;
+ }
+ case 'tagName':
+ case 'nodeName': {
+ return el.name.toUpperCase();
+ }
+
+ case 'href':
+ case 'src': {
+ const prop = el.attribs?.[name];
+
+ if (
+ typeof URL !== 'undefined' &&
+ ((name === 'href' && (el.tagName === 'a' || el.tagName === 'link')) ||
+ (name === 'src' &&
+ (el.tagName === 'img' ||
+ el.tagName === 'iframe' ||
+ el.tagName === 'audio' ||
+ el.tagName === 'video' ||
+ el.tagName === 'source'))) &&
+ prop !== undefined &&
+ this.options.baseURI
+ ) {
+ return new URL(prop, this.options.baseURI).href;
+ }
+
+ return prop;
+ }
+
+ case 'innerText': {
+ return innerText(el);
+ }
+
+ case 'textContent': {
+ return textContent(el);
+ }
+
+ case 'outerHTML': {
+ return this.clone().wrap(';
+}
+
+/**
+ * Sets the value of a data attribute.
+ *
+ * @private
+ * @param elem - The element to set the data attribute on.
+ * @param name - The data attribute's name.
+ * @param value - The data attribute's value.
+ */
+function setData(
+ elem: DataElement,
+ name: string | Record,
+ value?: unknown,
+) {
+ elem.data ??= {};
+
+ if (typeof name === 'object') Object.assign(elem.data, name);
+ else if (typeof name === 'string' && value !== undefined) {
+ elem.data[name] = value;
+ }
+}
+
+/**
+ * Read _all_ HTML5 `data-*` attributes from the equivalent HTML5 `data-*`
+ * attribute, and cache the value in the node's internal data store.
+ *
+ * @private
+ * @category Attributes
+ * @param el - Element to get the data attribute of.
+ * @returns A map with all of the data attributes.
+ */
+function readAllData(el: DataElement): unknown {
+ for (const domName of Object.keys(el.attribs)) {
+ if (!domName.startsWith(dataAttrPrefix)) {
+ continue;
+ }
+
+ const jsName = camelCase(domName.slice(dataAttrPrefix.length));
+
+ if (!hasOwn.call(el.data, jsName)) {
+ el.data![jsName] = parseDataValue(el.attribs[domName]);
+ }
+ }
+
+ return el.data;
+}
+
+/**
+ * Read the specified attribute from the equivalent HTML5 `data-*` attribute,
+ * and (if present) cache the value in the node's internal data store.
+ *
+ * @private
+ * @category Attributes
+ * @param el - Element to get the data attribute of.
+ * @param name - Name of the data attribute.
+ * @returns The data attribute's value.
+ */
+function readData(el: DataElement, name: string): unknown {
+ const domName = dataAttrPrefix + cssCase(name);
+ const data = el.data!;
+
+ if (hasOwn.call(data, name)) {
+ return data[name];
+ }
+
+ if (hasOwn.call(el.attribs, domName)) {
+ return (data[name] = parseDataValue(el.attribs[domName]));
+ }
+
+ return undefined;
+}
+
+/**
+ * Coerce string data-* attributes to their corresponding JavaScript primitives.
+ *
+ * @private
+ * @category Attributes
+ * @param value - The value to parse.
+ * @returns The parsed value.
+ */
+function parseDataValue(value: string): unknown {
+ if (value === 'null') return null;
+ if (value === 'true') return true;
+ if (value === 'false') return false;
+ const num = Number(value);
+ if (value === String(num)) return num;
+ if (rbrace.test(value)) {
+ try {
+ return JSON.parse(value);
+ } catch {
+ /* Ignore */
+ }
+ }
+ return value;
+}
+
+/**
+ * Method for getting data attributes, for only the first element in the matched
+ * set.
+ *
+ * @category Attributes
+ * @example
+ *
+ * ```js
+ * $('').data('apple-color');
+ * //=> 'red'
+ * ```
+ *
+ * @param name - Name of the data attribute.
+ * @returns The data attribute's value, or `undefined` if the attribute does not
+ * exist.
+ * @see {@link https://api.jquery.com/data/}
+ */
+export function data(
+ this: Cheerio,
+ name: string,
+): unknown | undefined;
+/**
+ * Method for getting all of an element's data attributes, for only the first
+ * element in the matched set.
+ *
+ * @category Attributes
+ * @example
+ *
+ * ```js
+ * $('').data();
+ * //=> { appleColor: 'red' }
+ * ```
+ *
+ * @returns A map with all of the data attributes.
+ * @see {@link https://api.jquery.com/data/}
+ */
+export function data(
+ this: Cheerio,
+): Record;
+/**
+ * Method for setting data attributes, for only the first element in the matched
+ * set.
+ *
+ * @category Attributes
+ * @example
+ *
+ * ```js
+ * const apple = $('.apple').data('kind', 'mac');
+ *
+ * apple.data('kind');
+ * //=> 'mac'
+ * ```
+ *
+ * @param name - Name of the data attribute.
+ * @param value - The new value.
+ * @returns The instance itself.
+ * @see {@link https://api.jquery.com/data/}
+ */
+export function data(
+ this: Cheerio,
+ name: string,
+ value: unknown,
+): Cheerio;
+/**
+ * Method for setting multiple data attributes at once, for only the first
+ * element in the matched set.
+ *
+ * @category Attributes
+ * @example
+ *
+ * ```js
+ * const apple = $('.apple').data({ kind: 'mac' });
+ *
+ * apple.data('kind');
+ * //=> 'mac'
+ * ```
+ *
+ * @param values - Map of names to values.
+ * @returns The instance itself.
+ * @see {@link https://api.jquery.com/data/}
+ */
+export function data(
+ this: Cheerio,
+ values: Record,
+): Cheerio;
+export function data(
+ this: Cheerio,
+ name?: string | Record,
+ value?: unknown,
+): unknown | Cheerio | undefined | Record {
+ const elem = this[0];
+
+ if (!elem || !isTag(elem)) return;
+
+ const dataEl: DataElement = elem;
+ dataEl.data ??= {};
+
+ // Return the entire data object if no data specified
+ if (name == null) {
+ return readAllData(dataEl);
+ }
+
+ // Set the value (with attr map support)
+ if (typeof name === 'object' || value !== undefined) {
+ domEach(this, (el) => {
+ if (isTag(el)) {
+ if (typeof name === 'object') setData(el, name);
+ else setData(el, name, value as unknown);
+ }
+ });
+ return this;
+ }
+
+ return readData(dataEl, name);
+}
+
+/**
+ * Method for getting the value of input, select, and textarea. Note: Support
+ * for `map`, and `function` has not been added yet.
+ *
+ * @category Attributes
+ * @example
+ *
+ * ```js
+ * $('input[type="text"]').val();
+ * //=> input_text
+ * ```
+ *
+ * @returns The value.
+ * @see {@link https://api.jquery.com/val/}
+ */
+export function val(
+ this: Cheerio,
+): string | undefined | string[];
+/**
+ * Method for setting the value of input, select, and textarea. Note: Support
+ * for `map`, and `function` has not been added yet.
+ *
+ * @category Attributes
+ * @example
+ *
+ * ```js
+ * $('input[type="text"]').val('test').html();
+ * //=>
+ * ```
+ *
+ * @param value - The new value.
+ * @returns The instance itself.
+ * @see {@link https://api.jquery.com/val/}
+ */
+export function val(
+ this: Cheerio,
+ value: string | string[],
+): Cheerio;
+export function val(
+ this: Cheerio,
+ value?: string | string[],
+): string | string[] | Cheerio | undefined {
+ const querying = arguments.length === 0;
+ const element = this[0];
+
+ if (!element || !isTag(element)) return querying ? undefined : this;
+
+ switch (element.name) {
+ case 'textarea': {
+ return this.text(value as string);
+ }
+ case 'select': {
+ const option = this.find('option:selected');
+ if (!querying) {
+ if (this.attr('multiple') == null && typeof value === 'object') {
+ return this;
+ }
+
+ this.find('option').removeAttr('selected');
+
+ const values = typeof value === 'object' ? value : [value];
+ for (const val of values) {
+ this.find(`option[value="${val}"]`).attr('selected', '');
+ }
+
+ return this;
+ }
+
+ return this.attr('multiple')
+ ? option.toArray().map((el) => text(el.children))
+ : option.attr('value');
+ }
+ case 'input':
+ case 'option': {
+ return querying
+ ? this.attr('value')
+ : this.attr('value', value as string);
+ }
+ }
+
+ return undefined;
+}
+
+/**
+ * Remove an attribute.
+ *
+ * @private
+ * @param elem - Node to remove attribute from.
+ * @param name - Name of the attribute to remove.
+ */
+function removeAttribute(elem: Element, name: string) {
+ if (!elem.attribs || !hasOwn.call(elem.attribs, name)) return;
+
+ delete elem.attribs[name];
+}
+
+/**
+ * Splits a space-separated list of names to individual names.
+ *
+ * @category Attributes
+ * @param names - Names to split.
+ * @returns - Split names.
+ */
+function splitNames(names?: string): string[] {
+ return names ? names.trim().split(rspace) : [];
+}
+
+/**
+ * Method for removing attributes by `name`.
+ *
+ * @category Attributes
+ * @example
+ *
+ * ```js
+ * $('.pear').removeAttr('class').html();
+ * //=> Pear
+ *
+ * $('.apple').attr('id', 'favorite');
+ * $('.apple').removeAttr('id class').html();
+ * //=> Apple
+ * ```
+ *
+ * @param name - Name of the attribute.
+ * @returns The instance itself.
+ * @see {@link https://api.jquery.com/removeAttr/}
+ */
+export function removeAttr(
+ this: Cheerio,
+ name: string,
+): Cheerio {
+ const attrNames = splitNames(name);
+
+ for (const attrName of attrNames) {
+ domEach(this, (elem) => {
+ if (isTag(elem)) removeAttribute(elem, attrName);
+ });
+ }
+
+ return this;
+}
+
+/**
+ * Check to see if _any_ of the matched elements have the given `className`.
+ *
+ * @category Attributes
+ * @example
+ *
+ * ```js
+ * $('.pear').hasClass('pear');
+ * //=> true
+ *
+ * $('apple').hasClass('fruit');
+ * //=> false
+ *
+ * $('li').hasClass('pear');
+ * //=> true
+ * ```
+ *
+ * @param className - Name of the class.
+ * @returns Indicates if an element has the given `className`.
+ * @see {@link https://api.jquery.com/hasClass/}
+ */
+export function hasClass(
+ this: Cheerio,
+ className: string,
+): boolean {
+ return this.toArray().some((elem) => {
+ const clazz = isTag(elem) && elem.attribs['class'];
+ let idx = -1;
+
+ if (clazz && className.length > 0) {
+ while ((idx = clazz.indexOf(className, idx + 1)) > -1) {
+ const end = idx + className.length;
+
+ if (
+ (idx === 0 || rspace.test(clazz[idx - 1])) &&
+ (end === clazz.length || rspace.test(clazz[end]))
+ ) {
+ return true;
+ }
+ }
+ }
+
+ return false;
+ });
+}
+
+/**
+ * Adds class(es) to all of the matched elements. Also accepts a `function`.
+ *
+ * @category Attributes
+ * @example
+ *
+ * ```js
+ * $('.pear').addClass('fruit').html();
+ * //=> Pear
+ *
+ * $('.apple').addClass('fruit red').html();
+ * //=> Apple
+ * ```
+ *
+ * @param value - Name of new class.
+ * @returns The instance itself.
+ * @see {@link https://api.jquery.com/addClass/}
+ */
+export function addClass>(
+ this: R,
+ value?:
+ | string
+ | ((this: Element, i: number, className: string) => string | undefined),
+): R {
+ // Support functions
+ if (typeof value === 'function') {
+ return domEach(this, (el, i) => {
+ if (isTag(el)) {
+ const className = el.attribs['class'] || '';
+ addClass.call([el], value.call(el, i, className));
+ }
+ });
+ }
+
+ // Return if no value or not a string or function
+ if (!value || typeof value !== 'string') return this;
+
+ const classNames = value.split(rspace);
+ const numElements = this.length;
+
+ for (let i = 0; i < numElements; i++) {
+ const el = this[i];
+ // If selected element isn't a tag, move on
+ if (!isTag(el)) continue;
+
+ // If we don't already have classes — always set xmlMode to false here, as it doesn't matter for classes
+ const className = getAttr(el, 'class', false);
+
+ if (className) {
+ let setClass = ` ${className} `;
+
+ // Check if class already exists
+ for (const cn of classNames) {
+ const appendClass = `${cn} `;
+ if (!setClass.includes(` ${appendClass}`)) setClass += appendClass;
+ }
+
+ setAttr(el, 'class', setClass.trim());
+ } else {
+ setAttr(el, 'class', classNames.join(' ').trim());
+ }
+ }
+
+ return this;
+}
+
+/**
+ * Removes one or more space-separated classes from the selected elements. If no
+ * `className` is defined, all classes will be removed. Also accepts a
+ * `function`.
+ *
+ * @category Attributes
+ * @example
+ *
+ * ```js
+ * $('.pear').removeClass('pear').html();
+ * //=> Pear
+ *
+ * $('.apple').addClass('red').removeClass().html();
+ * //=> Apple
+ * ```
+ *
+ * @param name - Name of the class. If not specified, removes all elements.
+ * @returns The instance itself.
+ * @see {@link https://api.jquery.com/removeClass/}
+ */
+export function removeClass>(
+ this: R,
+ name?:
+ | string
+ | ((this: Element, i: number, className: string) => string | undefined),
+): R {
+ // Handle if value is a function
+ if (typeof name === 'function') {
+ return domEach(this, (el, i) => {
+ if (isTag(el)) {
+ removeClass.call([el], name.call(el, i, el.attribs['class'] || ''));
+ }
+ });
+ }
+
+ const classes = splitNames(name);
+ const numClasses = classes.length;
+ const removeAll = arguments.length === 0;
+
+ return domEach(this, (el) => {
+ if (!isTag(el)) return;
+
+ if (removeAll) {
+ // Short circuit the remove all case as this is the nice one
+ el.attribs['class'] = '';
+ } else {
+ const elClasses = splitNames(el.attribs['class']);
+ let changed = false;
+
+ for (let j = 0; j < numClasses; j++) {
+ const index = elClasses.indexOf(classes[j]);
+
+ if (index >= 0) {
+ elClasses.splice(index, 1);
+ changed = true;
+
+ /*
+ * We have to do another pass to ensure that there are not duplicate
+ * classes listed
+ */
+ j--;
+ }
+ }
+ if (changed) {
+ el.attribs['class'] = elClasses.join(' ');
+ }
+ }
+ });
+}
+
+/**
+ * Add or remove class(es) from the matched elements, depending on either the
+ * class's presence or the value of the switch argument. Also accepts a
+ * `function`.
+ *
+ * @category Attributes
+ * @example
+ *
+ * ```js
+ * $('.apple.green').toggleClass('fruit green red').html();
+ * //=> Apple
+ *
+ * $('.apple.green').toggleClass('fruit green red', true).html();
+ * //=> Apple
+ * ```
+ *
+ * @param value - Name of the class. Can also be a function.
+ * @param stateVal - If specified the state of the class.
+ * @returns The instance itself.
+ * @see {@link https://api.jquery.com/toggleClass/}
+ */
+export function toggleClass>(
+ this: R,
+ value?:
+ | string
+ | ((
+ this: Element,
+ i: number,
+ className: string,
+ stateVal?: boolean,
+ ) => string),
+ stateVal?: boolean,
+): R {
+ // Support functions
+ if (typeof value === 'function') {
+ return domEach(this, (el, i) => {
+ if (isTag(el)) {
+ toggleClass.call(
+ [el],
+ value.call(el, i, el.attribs['class'] || '', stateVal),
+ stateVal,
+ );
+ }
+ });
+ }
+
+ // Return if no value or not a string or function
+ if (!value || typeof value !== 'string') return this;
+
+ const classNames = value.split(rspace);
+ const numClasses = classNames.length;
+ const state = typeof stateVal === 'boolean' ? (stateVal ? 1 : -1) : 0;
+ const numElements = this.length;
+
+ for (let i = 0; i < numElements; i++) {
+ const el = this[i];
+ // If selected element isn't a tag, move on
+ if (!isTag(el)) continue;
+
+ const elementClasses = splitNames(el.attribs['class']);
+
+ // Check if class already exists
+ for (let j = 0; j < numClasses; j++) {
+ // Check if the class name is currently defined
+ const index = elementClasses.indexOf(classNames[j]);
+
+ // Add if stateValue === true or we are toggling and there is no value
+ if (state >= 0 && index < 0) {
+ elementClasses.push(classNames[j]);
+ } else if (state <= 0 && index >= 0) {
+ // Otherwise remove but only if the item exists
+ elementClasses.splice(index, 1);
+ }
+ }
+
+ el.attribs['class'] = elementClasses.join(' ');
+ }
+
+ return this;
+}
diff --git a/frontend/node_modules/cheerio/src/api/css.spec.ts b/frontend/node_modules/cheerio/src/api/css.spec.ts
new file mode 100644
index 0000000..f6455c2
--- /dev/null
+++ b/frontend/node_modules/cheerio/src/api/css.spec.ts
@@ -0,0 +1,138 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { load, type Cheerio } from '../index.js';
+import type { Element } from 'domhandler';
+import { cheerio, mixedText } from '../__fixtures__/fixtures.js';
+
+describe('$(...)', () => {
+ describe('.css', () => {
+ it('(prop): should return a css property value', () => {
+ const el = cheerio('');
+ expect(el.css('hai')).toBe('there');
+ });
+
+ it('([prop1, prop2]): should return the specified property values as an object', () => {
+ const el = cheerio(
+ ' ',
+ );
+ expect(el.css(['margin', 'color'])).toStrictEqual({
+ margin: '1px',
+ color: 'blue',
+ });
+ });
+
+ it('(prop, val): should set a css property', () => {
+ const el = cheerio(' ');
+ el.css('color', 'red');
+ expect(el.attr('style')).toBe('margin: 0; color: red;');
+ expect(el.eq(1).attr('style')).toBe('color: red;');
+ });
+
+ it('(prop, val) : should skip text nodes', () => {
+ const $text = load(mixedText);
+ const $body = $text($text('body')[0].children);
+
+ $body.css('test', 'value');
+
+ expect($text('body').html()).toBe(
+ '1TEXT2',
+ );
+ });
+
+ it('(prop, ""): should unset a css property', () => {
+ const el = cheerio('');
+ el.css('padding', '');
+ expect(el.attr('style')).toBe('margin: 0;');
+ });
+
+ it('(any, val): should ignore unsupported prop types', () => {
+ const el = cheerio(' ');
+ el.css(123 as never, 'test');
+ expect(el.attr('style')).toBe('padding: 1px;');
+ });
+
+ it('(prop): should not mangle embedded urls', () => {
+ const el = cheerio(
+ ' ',
+ );
+ expect(el.css('background-image')).toBe(
+ 'url(http://example.com/img.png)',
+ );
+ });
+
+ it('(prop): should ignore blank properties', () => {
+ const el = cheerio(' ');
+ expect(el.css()).toStrictEqual({ color: '#aaa' });
+ });
+
+ it('(prop): should ignore blank values', () => {
+ const el = cheerio(' ');
+ expect(el.css()).toStrictEqual({ position: 'absolute' });
+ });
+
+ it('(prop): should return undefined for unmatched elements', () => {
+ const $ = load(' ');
+ expect($('ul').css('background-image')).toBeUndefined();
+ });
+
+ it('(prop): should return undefined for unmatched styles', () => {
+ const el = cheerio(' ');
+ expect(el.css('margin')).toBeUndefined();
+ });
+
+ describe('(prop, function):', () => {
+ let $el: Cheerio;
+ beforeEach(() => {
+ const $ = load(
+ '
- \n
- \n
- \n
').prop('src');
+ * //=> 'https://example.com/image.png'
+ * ```
+ *
+ * @param name - Name of the property.
+ * @returns The resolved URL, or `undefined` if the element is not supported.
+ */
+export function prop',
+ );
+ $el = $('div');
+ });
+
+ it('should iterate over the selection', () => {
+ let count = 0;
+ $el.css('margin', function (idx, value) {
+ expect(idx).toBe(count);
+ expect(value).toBe(`${count}px`);
+ expect(this).toBe($el[count]);
+ count++;
+ return undefined;
+ });
+ expect(count).toBe(3);
+ });
+
+ it('should set each attribute independently', () => {
+ const values = ['4px', '', undefined];
+ $el.css('margin', (idx) => values[idx]);
+ expect($el.eq(0).attr('style')).toBe('margin: 4px;');
+ expect($el.eq(1).attr('style')).toBe('');
+ expect($el.eq(2).attr('style')).toBe('margin: 2px;');
+ });
+ });
+
+ it('(obj): should set each key and val', () => {
+ const el = cheerio('');
+ el.css({ foo: 0 } as never);
+ expect(el.eq(0).attr('style')).toBe('padding: 0; foo: 0;');
+ expect(el.eq(1).attr('style')).toBe('foo: 0;');
+ });
+
+ describe('parser', () => {
+ it('should allow any whitespace between declarations', () => {
+ const el = cheerio('');
+ expect(el.css(['one', 'two', 'five'])).toStrictEqual({
+ one: '0',
+ two: '1',
+ });
+ });
+
+ it('should add malformed values to previous field (#1134)', () => {
+ const el = cheerio(
+ '',
+ );
+ expect(el.css('background-image')).toStrictEqual(
+ 'url(data:image/png;base64,iVBORw0KGgo)',
+ );
+ });
+ });
+ });
+});
diff --git a/frontend/node_modules/cheerio/src/api/css.ts b/frontend/node_modules/cheerio/src/api/css.ts
new file mode 100644
index 0000000..9a1564a
--- /dev/null
+++ b/frontend/node_modules/cheerio/src/api/css.ts
@@ -0,0 +1,224 @@
+import { domEach } from '../utils.js';
+import { isTag, type Element, type AnyNode } from 'domhandler';
+import type { Cheerio } from '../cheerio.js';
+
+/**
+ * Get the value of a style property for the first element in the set of matched
+ * elements.
+ *
+ * @category CSS
+ * @param names - Optionally the names of the properties of interest.
+ * @returns A map of all of the style properties.
+ * @see {@link https://api.jquery.com/css/}
+ */
+export function css(
+ this: Cheerio,
+ names?: string[],
+): Record | undefined;
+/**
+ * Get the value of a style property for the first element in the set of matched
+ * elements.
+ *
+ * @category CSS
+ * @param name - The name of the property.
+ * @returns The property value for the given name.
+ * @see {@link https://api.jquery.com/css/}
+ */
+export function css(
+ this: Cheerio,
+ name: string,
+): string | undefined;
+/**
+ * Set one CSS property for every matched element.
+ *
+ * @category CSS
+ * @param prop - The name of the property.
+ * @param val - The new value.
+ * @returns The instance itself.
+ * @see {@link https://api.jquery.com/css/}
+ */
+export function css(
+ this: Cheerio,
+ prop: string,
+ val:
+ | string
+ | ((this: Element, i: number, style: string) => string | undefined),
+): Cheerio;
+/**
+ * Set multiple CSS properties for every matched element.
+ *
+ * @category CSS
+ * @param map - A map of property names and values.
+ * @returns The instance itself.
+ * @see {@link https://api.jquery.com/css/}
+ */
+export function css(
+ this: Cheerio,
+ map: Record,
+): Cheerio;
+/**
+ * Set multiple CSS properties for every matched element.
+ *
+ * @category CSS
+ * @param prop - The names of the properties.
+ * @param val - The new values.
+ * @returns The instance itself.
+ * @see {@link https://api.jquery.com/css/}
+ */
+export function css(
+ this: Cheerio,
+ prop?: string | string[] | Record,
+ val?:
+ | string
+ | ((this: Element, i: number, style: string) => string | undefined),
+): Cheerio | Record | string | undefined {
+ if (
+ (prop != null && val != null) ||
+ // When `prop` is a "plain" object
+ (typeof prop === 'object' && !Array.isArray(prop))
+ ) {
+ return domEach(this, (el, i) => {
+ if (isTag(el)) {
+ // `prop` can't be an array here anymore.
+ setCss(el, prop as string, val, i);
+ }
+ });
+ }
+
+ if (this.length === 0) {
+ return undefined;
+ }
+
+ return getCss(this[0], prop as string);
+}
+
+/**
+ * Set styles of all elements.
+ *
+ * @private
+ * @param el - Element to set style of.
+ * @param prop - Name of property.
+ * @param value - Value to set property to.
+ * @param idx - Optional index within the selection.
+ */
+function setCss(
+ el: Element,
+ prop: string | Record,
+ value:
+ | string
+ | ((this: Element, i: number, style: string) => string | undefined)
+ | undefined,
+ idx: number,
+) {
+ if (typeof prop === 'string') {
+ const styles = getCss(el);
+
+ const val =
+ typeof value === 'function' ? value.call(el, idx, styles[prop]) : value;
+
+ if (val === '') {
+ delete styles[prop];
+ } else if (val != null) {
+ styles[prop] = val;
+ }
+
+ el.attribs['style'] = stringify(styles);
+ } else if (typeof prop === 'object') {
+ const keys = Object.keys(prop);
+ for (let i = 0; i < keys.length; i++) {
+ const k = keys[i];
+ setCss(el, k, prop[k], i);
+ }
+ }
+}
+
+/**
+ * Get the parsed styles of the first element.
+ *
+ * @private
+ * @category CSS
+ * @param el - Element to get styles from.
+ * @param props - Optionally the names of the properties of interest.
+ * @returns The parsed styles.
+ */
+function getCss(el: AnyNode, props?: string[]): Record;
+/**
+ * Get a property from the parsed styles of the first element.
+ *
+ * @private
+ * @category CSS
+ * @param el - Element to get styles from.
+ * @param prop - Name of the prop.
+ * @returns The value of the property.
+ */
+function getCss(el: AnyNode, prop: string): string | undefined;
+function getCss(
+ el: AnyNode,
+ prop?: string | string[],
+): Record | string | undefined {
+ if (!el || !isTag(el)) return;
+
+ const styles = parse(el.attribs['style']);
+ if (typeof prop === 'string') {
+ return styles[prop];
+ }
+ if (Array.isArray(prop)) {
+ const newStyles: Record = {};
+ for (const item of prop) {
+ if (styles[item] != null) {
+ newStyles[item] = styles[item];
+ }
+ }
+ return newStyles;
+ }
+ return styles;
+}
+
+/**
+ * Stringify `obj` to styles.
+ *
+ * @private
+ * @category CSS
+ * @param obj - Object to stringify.
+ * @returns The serialized styles.
+ */
+function stringify(obj: Record): string {
+ return Object.keys(obj).reduce(
+ (str, prop) => `${str}${str ? ' ' : ''}${prop}: ${obj[prop]};`,
+ '',
+ );
+}
+
+/**
+ * Parse `styles`.
+ *
+ * @private
+ * @category CSS
+ * @param styles - Styles to be parsed.
+ * @returns The parsed styles.
+ */
+function parse(styles: string): Record {
+ styles = (styles || '').trim();
+
+ if (!styles) return {};
+
+ const obj: Record = {};
+
+ let key: string | undefined;
+
+ for (const str of styles.split(';')) {
+ const n = str.indexOf(':');
+ // If there is no :, or if it is the first/last character, add to the previous item's value
+ if (n < 1 || n === str.length - 1) {
+ const trimmed = str.trimEnd();
+ if (trimmed.length > 0 && key !== undefined) {
+ obj[key] += `;${trimmed}`;
+ }
+ } else {
+ key = str.slice(0, n).trim();
+ obj[key] = str.slice(n + 1).trim();
+ }
+ }
+
+ return obj;
+}
diff --git a/frontend/node_modules/cheerio/src/api/extract.spec.ts b/frontend/node_modules/cheerio/src/api/extract.spec.ts
new file mode 100644
index 0000000..b243212
--- /dev/null
+++ b/frontend/node_modules/cheerio/src/api/extract.spec.ts
@@ -0,0 +1,121 @@
+import { describe, it, expect } from 'vitest';
+import * as fixtures from '../__fixtures__/fixtures.js';
+import { load } from '../load-parse.js';
+
+interface RedSelObject {
+ red: string | undefined;
+ sel: string | undefined;
+}
+
+interface RedSelMultipleObject {
+ red: string[];
+ sel: string[];
+}
+
+describe('$.extract', () => {
+ it('() : should extract values for selectors', () => {
+ const $ = load(fixtures.eleven);
+ const $root = load(fixtures.eleven).root();
+ // An empty object should lead to an empty extraction.
+
+ // $ExpectType ExtractedMap<{}>
+ const emptyExtract = $root.extract({});
+ expect(emptyExtract).toStrictEqual({});
+ // Non-existent values should be undefined.
+
+ // $ExpectType ExtractedMap<{ foo: string; }>
+ const simpleExtract = $root.extract({ foo: 'bar' });
+ expect(simpleExtract).toStrictEqual({ foo: undefined });
+
+ // Existing values should be extracted.
+ expect<{ red: string | undefined }>(
+ $root.extract({ red: '.red' }),
+ ).toStrictEqual({
+ red: 'Four',
+ });
+ expect(
+ $root.extract({ red: '.red', sel: '.sel' }),
+ ).toStrictEqual({
+ red: 'Four',
+ sel: 'Three',
+ });
+ // Descriptors for extractions should be supported
+ expect(
+ $root.extract({
+ red: { selector: '.red' },
+ sel: { selector: '.sel' },
+ }),
+ ).toStrictEqual({ red: 'Four', sel: 'Three' });
+ // Should support extraction of multiple values.
+
+ // $ExpectType ExtractedMap<{ red: [string]; sel: [string]; }>
+ const multipleExtract = $root.extract({
+ red: ['.red'],
+ sel: ['.sel'],
+ });
+ expect(multipleExtract).toStrictEqual({
+ red: ['Four', 'Five', 'Nine'],
+ sel: ['Three', 'Nine', 'Eleven'],
+ });
+ // Should support custom `prop`s.
+ expect(
+ $root.extract({
+ red: { selector: '.red', value: 'outerHTML' },
+ sel: { selector: '.sel', value: 'tagName' },
+ }),
+ ).toStrictEqual({ red: 'Four ', sel: 'LI' });
+ // Should support custom `prop`s for multiple values.
+ expect<{ red: string[] }>(
+ $root.extract({
+ red: [{ selector: '.red', value: 'outerHTML' }],
+ }),
+ ).toStrictEqual({
+ red: [
+ 'Four ',
+ 'Five ',
+ 'Nine ',
+ ],
+ });
+ // Should support custom extraction functions.
+ expect<{ red: string | undefined }>(
+ $root.extract({
+ red: {
+ selector: '.red',
+ value: (el, key) => `${key}=${$(el).text()}`,
+ },
+ }),
+ ).toStrictEqual({ red: 'red=Four' });
+ // Should support custom extraction functions for multiple values.
+ expect<{ red: string[] }>(
+ $root.extract({
+ red: [
+ {
+ selector: '.red',
+ value: (el, key) => `${key}=${$(el).text()}`,
+ },
+ ],
+ }),
+ ).toStrictEqual({ red: ['red=Four', 'red=Five', 'red=Nine'] });
+ // Should support extraction objects
+
+ // $ExpectType ExtractedMap<{ section: { selector: string; value: { red: string; sel: string; }; }; }>
+ const subExtractObject = $root.extract({
+ section: {
+ selector: 'ul:nth(1)',
+ value: {
+ red: '.red',
+ sel: '.blue',
+ },
+ },
+ });
+
+ expect<{ section: RedSelObject | undefined }>(
+ subExtractObject,
+ ).toStrictEqual({
+ section: {
+ red: 'Five',
+ sel: 'Seven',
+ },
+ });
+ });
+});
diff --git a/frontend/node_modules/cheerio/src/api/extract.ts b/frontend/node_modules/cheerio/src/api/extract.ts
new file mode 100644
index 0000000..10bd529
--- /dev/null
+++ b/frontend/node_modules/cheerio/src/api/extract.ts
@@ -0,0 +1,92 @@
+import type { AnyNode, Element } from 'domhandler';
+import type { Cheerio } from '../cheerio.js';
+import type { prop } from './attributes.js';
+
+type ExtractDescriptorFn = (
+ el: Element,
+ key: string,
+ // TODO: This could be typed with ExtractedMap
+ obj: Record,
+) => unknown;
+
+interface ExtractDescriptor {
+ selector: string;
+ value?: string | ExtractDescriptorFn | ExtractMap;
+}
+
+type ExtractValue = string | ExtractDescriptor | [string | ExtractDescriptor];
+
+export interface ExtractMap {
+ [key: string]: ExtractValue;
+}
+
+type ExtractedValue = V extends [
+ string | ExtractDescriptor,
+]
+ ? NonNullable>[]
+ : V extends string
+ ? string | undefined
+ : V extends ExtractDescriptor
+ ? V['value'] extends ExtractMap
+ ? ExtractedMap | undefined
+ : V['value'] extends ExtractDescriptorFn
+ ? ReturnType | undefined
+ : ReturnType | undefined
+ : never;
+
+export type ExtractedMap = {
+ [key in keyof M]: ExtractedValue;
+};
+
+function getExtractDescr(
+ descr: string | ExtractDescriptor,
+): Required {
+ if (typeof descr === 'string') {
+ return { selector: descr, value: 'textContent' };
+ }
+
+ return {
+ selector: descr.selector,
+ value: descr.value ?? 'textContent',
+ };
+}
+
+/**
+ * Extract multiple values from a document, and store them in an object.
+ *
+ * @param map - An object containing key-value pairs. The keys are the names of
+ * the properties to be created on the object, and the values are the
+ * selectors to be used to extract the values.
+ * @returns An object containing the extracted values.
+ */
+export function extract(
+ this: Cheerio,
+ map: M,
+): ExtractedMap {
+ const ret: Record = {};
+
+ for (const key in map) {
+ const descr = map[key];
+ const isArray = Array.isArray(descr);
+
+ const { selector, value } = getExtractDescr(isArray ? descr[0] : descr);
+
+ const fn: ExtractDescriptorFn =
+ typeof value === 'function'
+ ? value
+ : typeof value === 'string'
+ ? (el: Element) => this._make(el).prop(value)
+ : (el: Element) => this._make(el).extract(value);
+
+ if (isArray) {
+ ret[key] = this._findBySelector(selector, Number.POSITIVE_INFINITY)
+ .map((_, el) => fn(el, key, ret))
+ .get();
+ } else {
+ const $ = this._findBySelector(selector, 1);
+ ret[key] = $.length > 0 ? fn($[0], key, ret) : undefined;
+ }
+ }
+
+ return ret as ExtractedMap;
+}
diff --git a/frontend/node_modules/cheerio/src/api/forms.spec.ts b/frontend/node_modules/cheerio/src/api/forms.spec.ts
new file mode 100644
index 0000000..ddd3d75
--- /dev/null
+++ b/frontend/node_modules/cheerio/src/api/forms.spec.ts
@@ -0,0 +1,155 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { type CheerioAPI } from '../index.js';
+import { cheerio, forms } from '../__fixtures__/fixtures.js';
+
+describe('$(...)', () => {
+ let $: CheerioAPI;
+
+ beforeEach(() => {
+ $ = cheerio.load(forms);
+ });
+
+ describe('.serializeArray', () => {
+ it('() : should get form controls', () => {
+ expect($('form#simple').serializeArray()).toStrictEqual([
+ {
+ name: 'fruit',
+ value: 'Apple',
+ },
+ ]);
+ });
+
+ it('() : should get nested form controls', () => {
+ expect($('form#nested').serializeArray()).toHaveLength(2);
+ const data = $('form#nested').serializeArray();
+ data.sort((a, b) => (a.value > b.value ? 1 : -1));
+ expect(data).toStrictEqual([
+ {
+ name: 'fruit',
+ value: 'Apple',
+ },
+ {
+ name: 'vegetable',
+ value: 'Carrot',
+ },
+ ]);
+ });
+
+ it('() : should not get disabled form controls', () => {
+ expect($('form#disabled').serializeArray()).toStrictEqual([]);
+ });
+
+ it('() : should not get form controls with the wrong type', () => {
+ expect($('form#submit').serializeArray()).toStrictEqual([
+ {
+ name: 'fruit',
+ value: 'Apple',
+ },
+ ]);
+ });
+
+ it('() : should get selected options', () => {
+ expect($('form#select').serializeArray()).toStrictEqual([
+ {
+ name: 'fruit',
+ value: 'Orange',
+ },
+ ]);
+ });
+
+ it('() : should not get unnamed form controls', () => {
+ expect($('form#unnamed').serializeArray()).toStrictEqual([
+ {
+ name: 'fruit',
+ value: 'Apple',
+ },
+ ]);
+ });
+
+ it('() : should get multiple selected options', () => {
+ expect($('form#multiple').serializeArray()).toHaveLength(2);
+ const data = $('form#multiple').serializeArray();
+ data.sort((a, b) => (a.value > b.value ? 1 : -1));
+ expect(data).toStrictEqual([
+ {
+ name: 'fruit',
+ value: 'Apple',
+ },
+ {
+ name: 'fruit',
+ value: 'Orange',
+ },
+ ]);
+ });
+
+ it('() : should get individually selected elements', () => {
+ const data = $('form#nested input').serializeArray();
+ data.sort((a, b) => (a.value > b.value ? 1 : -1));
+ expect(data).toStrictEqual([
+ {
+ name: 'fruit',
+ value: 'Apple',
+ },
+ {
+ name: 'vegetable',
+ value: 'Carrot',
+ },
+ ]);
+ });
+
+ it('() : should standardize line breaks', () => {
+ expect($('form#textarea').serializeArray()).toStrictEqual([
+ {
+ name: 'fruits',
+ value: 'Apple\r\nOrange',
+ },
+ ]);
+ });
+
+ it("() : shouldn't serialize the empty string", () => {
+ expect($('').serializeArray()).toStrictEqual([]);
+ expect(
+ $('').serializeArray(),
+ ).toStrictEqual([]);
+ expect(
+ $('').serializeArray(),
+ ).toStrictEqual([
+ {
+ name: 'fruit',
+ value: 'pineapple',
+ },
+ ]);
+ });
+
+ it('() : should serialize inputs without value attributes', () => {
+ expect($('').serializeArray()).toStrictEqual([
+ {
+ name: 'fruit',
+ value: '',
+ },
+ ]);
+ });
+ });
+
+ describe('.serialize', () => {
+ it('() : should get form controls', () => {
+ expect($('form#simple').serialize()).toBe('fruit=Apple');
+ });
+
+ it('() : should get nested form controls', () => {
+ expect($('form#nested').serialize()).toBe('fruit=Apple&vegetable=Carrot');
+ });
+
+ it('() : should not get disabled form controls', () => {
+ expect($('form#disabled').serialize()).toBe('');
+ });
+
+ it('() : should get multiple selected options', () => {
+ expect($('form#multiple').serialize()).toBe('fruit=Apple&fruit=Orange');
+ });
+
+ it("() : should encode spaces as +'s", () => {
+ expect($('form#spaces').serialize()).toBe('fruit=Blood+orange');
+ });
+ });
+});
diff --git a/frontend/node_modules/cheerio/src/api/forms.ts b/frontend/node_modules/cheerio/src/api/forms.ts
new file mode 100644
index 0000000..902f919
--- /dev/null
+++ b/frontend/node_modules/cheerio/src/api/forms.ts
@@ -0,0 +1,103 @@
+import { isTag, type AnyNode } from 'domhandler';
+import type { Cheerio } from '../cheerio.js';
+
+/*
+ * https://github.com/jquery/jquery/blob/2.1.3/src/manipulation/var/rcheckableType.js
+ * https://github.com/jquery/jquery/blob/2.1.3/src/serialize.js
+ */
+const submittableSelector = 'input,select,textarea,keygen';
+const r20 = /%20/g;
+const rCRLF = /\r?\n/g;
+
+/**
+ * Encode a set of form elements as a string for submission.
+ *
+ * @category Forms
+ * @example
+ *
+ * ```js
+ * $('').serialize();
+ * //=> 'foo=bar'
+ * ```
+ *
+ * @returns The serialized form.
+ * @see {@link https://api.jquery.com/serialize/}
+ */
+export function serialize(this: Cheerio): string {
+ // Convert form elements into name/value objects
+ const arr = this.serializeArray();
+
+ // Serialize each element into a key/value string
+ const retArr = arr.map(
+ (data) =>
+ `${encodeURIComponent(data.name)}=${encodeURIComponent(data.value)}`,
+ );
+
+ // Return the resulting serialization
+ return retArr.join('&').replace(r20, '+');
+}
+
+/**
+ * Encode a set of form elements as an array of names and values.
+ *
+ * @category Forms
+ * @example
+ *
+ * ```js
+ * $('').serializeArray();
+ * //=> [ { name: 'foo', value: 'bar' } ]
+ * ```
+ *
+ * @returns The serialized form.
+ * @see {@link https://api.jquery.com/serializeArray/}
+ */
+export function serializeArray(
+ this: Cheerio,
+): {
+ name: string;
+ value: string;
+}[] {
+ // Resolve all form elements from either forms or collections of form elements
+ return this.map((_, elem) => {
+ const $elem = this._make(elem);
+ if (isTag(elem) && elem.name === 'form') {
+ return $elem.find(submittableSelector).toArray();
+ }
+ return $elem.filter(submittableSelector).toArray();
+ })
+ .filter(
+ // Verify elements have a name (`attr.name`) and are not disabled (`:enabled`)
+ '[name!=""]:enabled' +
+ // And cannot be clicked (`[type=submit]`) or are used in `x-www-form-urlencoded` (`[type=file]`)
+ ':not(:submit, :button, :image, :reset, :file)' +
+ // And are either checked/don't have a checkable state
+ ':matches([checked], :not(:checkbox, :radio))',
+ // Convert each of the elements to its value(s)
+ )
+ .map<
+ AnyNode,
+ {
+ name: string;
+ value: string;
+ }
+ >((_, elem) => {
+ const $elem = this._make(elem);
+ const name = $elem.attr('name') as string; // We have filtered for elements with a name before.
+ // If there is no value set (e.g. `undefined`, `null`), then default value to empty
+ const value = $elem.val() ?? '';
+
+ // If we have an array of values (e.g. `