@handlewithcare/react-prosemirror 2.8.1 → 2.9.0-tiptap.25

package/dist/cjs/@swc/cli/lib/swc/__tests__/sources.test.js

@@ -0,0 +1,161 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _sources = require("../sources");
+const _fs = /*#__PURE__*/ _interopRequireDefault(require("fs"));
+const _fastGlob = /*#__PURE__*/ _interopRequireDefault(require("fast-glob"));
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+jest.mock("fs");
+jest.mock("fast-glob");
+describe("globSources", ()=>{
+    beforeEach(()=>{
+        _fs.default.resetMockStats();
+    });
+    it("exclude dotfiles sources when includeDotfiles=false", async ()=>{
+        const files = await (0, _sources.globSources)([
+            ".dotfile"
+        ], [], [], false);
+        expect([
+            ...files
+        ]).toEqual([]);
+    });
+    it("include dotfiles sources when includeDotfiles=true", async ()=>{
+        _fs.default.setMockStats({
+            ".dotfile": {
+                isDirectory: ()=>false
+            }
+        });
+        const files = await (0, _sources.globSources)([
+            ".dotfile"
+        ], [], [], true);
+        expect([
+            ...files
+        ]).toEqual([
+            ".dotfile"
+        ]);
+    });
+    it("include multiple file sources", async ()=>{
+        _fs.default.setMockStats({
+            ".dotfile": {
+                isDirectory: ()=>false
+            }
+        });
+        _fs.default.setMockStats({
+            file: {
+                isDirectory: ()=>false
+            }
+        });
+        const files = await (0, _sources.globSources)([
+            ".dotfile",
+            "file"
+        ], [], [], true);
+        expect([
+            ...files
+        ]).toEqual([
+            ".dotfile",
+            "file"
+        ]);
+    });
+    it("exclude files that errors on stats", async ()=>{
+        _fs.default.setMockStats({
+            ".dotfile": {
+                isDirectory: ()=>false
+            }
+        });
+        _fs.default.setMockStats({
+            file: new Error("Failed stat")
+        });
+        const files = await (0, _sources.globSources)([
+            ".dotfile",
+            "file"
+        ], [], [], true);
+        expect([
+            ...files
+        ]).toEqual([
+            ".dotfile"
+        ]);
+    });
+    it("includes all files from directory", async ()=>{
+        _fs.default.setMockStats({
+            directory: {
+                isDirectory: ()=>true
+            }
+        });
+        _fs.default.setMockStats({
+            file: {
+                isDirectory: ()=>false
+            }
+        });
+        _fastGlob.default.mockResolvedValue([
+            "fileDir1",
+            "fileDir2"
+        ]);
+        const files = await (0, _sources.globSources)([
+            "file",
+            "directory"
+        ], [], [], true);
+        expect([
+            ...files
+        ]).toEqual([
+            "file",
+            "fileDir1",
+            "fileDir2"
+        ]);
+    });
+    it("exclude files from directory that fail to glob", async ()=>{
+        _fs.default.setMockStats({
+            directory: {
+                isDirectory: ()=>true
+            }
+        });
+        _fs.default.setMockStats({
+            file: {
+                isDirectory: ()=>false
+            }
+        });
+        _fastGlob.default.mockRejectedValue(new Error("Failed"));
+        const files = await (0, _sources.globSources)([
+            "file",
+            "directory"
+        ], [], [], true);
+        expect([
+            ...files
+        ]).toEqual([
+            "file"
+        ]);
+    });
+});
+describe("splitCompilableAndCopyable", ()=>{
+    const extensions = [
+        ".ts"
+    ];
+    it("separate compilable and copyable when copyFiles=true", ()=>{
+        const files = [
+            "test.ts",
+            "test.txt"
+        ];
+        const [compilable, copyable] = (0, _sources.splitCompilableAndCopyable)(files, extensions, true);
+        expect(compilable).toEqual([
+            "test.ts"
+        ]);
+        expect(copyable).toEqual([
+            "test.txt"
+        ]);
+    });
+    it("separate compilable and copyable when copyFiles=false", ()=>{
+        const files = [
+            "test.ts",
+            "test.txt"
+        ];
+        const [compilable, copyable] = (0, _sources.splitCompilableAndCopyable)(files, extensions, false);
+        expect(compilable).toEqual([
+            "test.ts"
+        ]);
+        expect(copyable).toEqual([]);
+    });
+}); //# sourceMappingURL=sources.test.js.map

package/dist/cjs/@uiw/react-codemirror/src/__tests__/index.test.js

@@ -0,0 +1,159 @@
+/* eslint-disable jest/no-conditional-expect */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
+const _reacttestrenderer = /*#__PURE__*/ _interop_require_default(require("react-test-renderer"));
+const _react1 = require("@testing-library/react");
+const _ = /*#__PURE__*/ _interop_require_default(require(".."));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+it('CodeMirror', async ()=>{
+    const component = _reacttestrenderer.default.create(/*#__PURE__*/ _react.default.createElement(_.default, null));
+    let tree = component.toJSON();
+    if (tree && !Array.isArray(tree)) {
+        expect(tree.type).toEqual('div');
+        expect(tree.props.className).toEqual('cm-theme-light');
+    }
+});
+it('CodeMirror onChange', async ()=>{
+    const handleChange = jest.fn((value)=>{
+        expect(value).toEqual('# title');
+        return Array.isArray(value) ? value.join() : value;
+    });
+    (0, _react1.render)(/*#__PURE__*/ _react.default.createElement(_.default, {
+        autoFocus: true,
+        value: "console.log('Hello world!')",
+        onChange: handleChange
+    }));
+    const input = await _react1.screen.findByRole('textbox'); // findByRole('textbox');
+    _react1.fireEvent.change(input, {
+        target: {
+            textContent: '# title'
+        }
+    });
+    const elm = _react1.screen.queryByText('# title');
+    expect(elm.cmView.dom.innerHTML).toEqual('# title');
+});
+it('CodeMirror onUpdate', async ()=>{
+    (0, _react1.render)(/*#__PURE__*/ _react.default.createElement(_.default, {
+        value: "console.log('Hello world!')",
+        autoFocus: true,
+        onUpdate: (viewUpdate)=>{
+            expect(viewUpdate.state.doc.length).toEqual(27);
+        }
+    }));
+});
+it('CodeMirror ref', async ()=>{
+    function Demo() {
+        const ref = (0, _react.useRef)(null);
+        (0, _react.useEffect)(()=>{
+            expect(Object.keys(ref.current)).toEqual([
+                'editor',
+                'state',
+                'view'
+            ]);
+        }, [
+            ref
+        ]);
+        return /*#__PURE__*/ _react.default.createElement(_.default, {
+            ref: ref,
+            value: "console.log('Hello world!')"
+        });
+    }
+    (0, _react1.render)(/*#__PURE__*/ _react.default.createElement(Demo, null));
+});
+it('CodeMirror theme', async ()=>{
+    const component = _reacttestrenderer.default.create(/*#__PURE__*/ _react.default.createElement(_.default, {
+        theme: "dark"
+    }));
+    let tree = component.toJSON();
+    if (tree && !Array.isArray(tree)) {
+        expect(tree.type).toEqual('div');
+        expect(tree.props.className).toEqual('cm-theme-dark');
+    }
+});
+it('CodeMirror className', async ()=>{
+    const component = _reacttestrenderer.default.create(/*#__PURE__*/ _react.default.createElement(_.default, {
+        className: "test"
+    }));
+    let tree = component.toJSON();
+    if (tree && !Array.isArray(tree)) {
+        expect(tree.type).toEqual('div');
+        expect(tree.props.className).toEqual('cm-theme-light test');
+    }
+});
+it('CodeMirror placeholder', async ()=>{
+    (0, _react1.render)(/*#__PURE__*/ _react.default.createElement(_.default, {
+        placeholder: "Hello World",
+        className: "test"
+    }));
+    const elm = _react1.screen.queryByText('Hello World');
+    expect(elm.style['pointerEvents']).toEqual('none');
+    expect(elm.className).toEqual('cm-placeholder');
+});
+it('CodeMirror editable', async ()=>{
+    (0, _react1.render)(/*#__PURE__*/ _react.default.createElement(_.default, {
+        editable: false,
+        className: "test"
+    }));
+    const text = _react1.screen.getByRole('textbox');
+    expect(text.className).toEqual('cm-content');
+    expect(text.tagName).toEqual('DIV');
+});
+it("CodeMirror doesn't echo changes", async ()=>{
+    const handleChange = jest.fn();
+    const { rerender } = (0, _react1.render)(/*#__PURE__*/ _react.default.createElement(_.default, {
+        value: "value a",
+        onChange: handleChange
+    }));
+    rerender(/*#__PURE__*/ _react.default.createElement(_.default, {
+        value: "value b",
+        onChange: handleChange
+    }));
+    expect(handleChange).not.toHaveBeenCalled();
+});

package/dist/cjs/StaticEditorView.js

@@ -27,6 +27,9 @@ let StaticEditorView = class StaticEditorView {
     get state() {
         return this.props.state;
     }
+    get isDestroyed() {
+        return false;
+    }
     setProps(props) {
         return this.update({
             ...this.props,

package/dist/cjs/cheerio/src/__tests__/deprecated.spec.js

@@ -0,0 +1,253 @@
+/**
+ * This file includes tests for deprecated APIs. The methods are expected to be
+ * removed in the next major release of Cheerio, but their stability should be
+ * maintained until that time.
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _vitest = require("vitest");
+const _fixtures = require("../__fixtures__/fixtures.js");
+(0, _vitest.describe)('deprecated APIs', ()=>{
+    (0, _vitest.describe)('cheerio module', ()=>{
+        (0, _vitest.describe)('.parseHTML', ()=>{
+            (0, _vitest.it)('(html) : should preserve content', ()=>{
+                const html = '<div>test div</div>';
+                (0, _vitest.expect)((0, _fixtures.cheerio)(_fixtures.cheerio.parseHTML(html)[0]).html()).toBe('test div');
+            });
+        });
+        (0, _vitest.describe)('.merge', ()=>{
+            (0, _vitest.it)('should be a function', ()=>{
+                (0, _vitest.expect)(typeof _fixtures.cheerio.merge).toBe('function');
+            });
+            // #1674 - merge, wont accept Cheerio object
+            (0, _vitest.it)('should be a able merge array and cheerio object', ()=>{
+                const ret = _fixtures.cheerio.merge((0, _fixtures.cheerio)(), [
+                    'elem1',
+                    'elem2'
+                ]);
+                (0, _vitest.expect)(typeof ret).toBe('object');
+                (0, _vitest.expect)(ret).toHaveLength(2);
+            });
+            (0, _vitest.it)('(arraylike, arraylike) : should modify the first array, but not the second', ()=>{
+                const arr1 = [
+                    1,
+                    2,
+                    3
+                ];
+                const arr2 = [
+                    4,
+                    5,
+                    6
+                ];
+                const ret = _fixtures.cheerio.merge(arr1, arr2);
+                (0, _vitest.expect)(typeof ret).toBe('object');
+                (0, _vitest.expect)(Array.isArray(ret)).toBe(true);
+                (0, _vitest.expect)(ret).toBe(arr1);
+                (0, _vitest.expect)(arr1).toHaveLength(6);
+                (0, _vitest.expect)(arr2).toHaveLength(3);
+            });
+            (0, _vitest.it)('(arraylike, arraylike) : should handle objects that arent arrays, but are arraylike', ()=>{
+                const arr1 = {
+                    length: 3,
+                    0: 'a',
+                    1: 'b',
+                    2: 'c'
+                };
+                const arr2 = {
+                    length: 3,
+                    0: 'd',
+                    1: 'e',
+                    2: 'f'
+                };
+                _fixtures.cheerio.merge(arr1, arr2);
+                (0, _vitest.expect)(arr1).toHaveLength(6);
+                (0, _vitest.expect)(arr1[3]).toBe('d');
+                (0, _vitest.expect)(arr1[4]).toBe('e');
+                (0, _vitest.expect)(arr1[5]).toBe('f');
+                (0, _vitest.expect)(arr2).toHaveLength(3);
+            });
+            (0, _vitest.it)('(?, ?) : should gracefully reject invalid inputs', ()=>{
+                (0, _vitest.expect)(_fixtures.cheerio.merge([
+                    4
+                ], 3)).toBeUndefined();
+                (0, _vitest.expect)(_fixtures.cheerio.merge({}, {})).toBeUndefined();
+                (0, _vitest.expect)(_fixtures.cheerio.merge([], {})).toBeUndefined();
+                (0, _vitest.expect)(_fixtures.cheerio.merge({}, [])).toBeUndefined();
+                const fakeArray = {
+                    length: 3,
+                    0: 'a',
+                    1: 'b',
+                    3: 'd'
+                };
+                (0, _vitest.expect)(_fixtures.cheerio.merge(fakeArray, [])).toBeUndefined();
+                (0, _vitest.expect)(_fixtures.cheerio.merge([], fakeArray)).toBeUndefined();
+                (0, _vitest.expect)(_fixtures.cheerio.merge({
+                    length: '7'
+                }, [])).toBeUndefined();
+                (0, _vitest.expect)(_fixtures.cheerio.merge({
+                    length: -1
+                }, [])).toBeUndefined();
+            });
+            (0, _vitest.it)('(?, ?) : should no-op on invalid inputs', ()=>{
+                const fakeArray1 = {
+                    length: 3,
+                    0: 'a',
+                    1: 'b',
+                    3: 'd'
+                };
+                _fixtures.cheerio.merge(fakeArray1, []);
+                (0, _vitest.expect)(fakeArray1).toHaveLength(3);
+                (0, _vitest.expect)(fakeArray1[0]).toBe('a');
+                (0, _vitest.expect)(fakeArray1[1]).toBe('b');
+                (0, _vitest.expect)(fakeArray1[3]).toBe('d');
+                _fixtures.cheerio.merge([], fakeArray1);
+                (0, _vitest.expect)(fakeArray1).toHaveLength(3);
+                (0, _vitest.expect)(fakeArray1[0]).toBe('a');
+                (0, _vitest.expect)(fakeArray1[1]).toBe('b');
+                (0, _vitest.expect)(fakeArray1[3]).toBe('d');
+            });
+        });
+        (0, _vitest.describe)('.contains', ()=>{
+            let $;
+            (0, _vitest.beforeEach)(()=>{
+                $ = _fixtures.cheerio.load(_fixtures.food);
+            });
+            (0, _vitest.it)('(container, contained) : should correctly detect the provided element', ()=>{
+                const $food = $('#food');
+                const $fruits = $('#fruits');
+                const $apple = $('.apple');
+                (0, _vitest.expect)(_fixtures.cheerio.contains($food[0], $fruits[0])).toBe(true);
+                (0, _vitest.expect)(_fixtures.cheerio.contains($food[0], $apple[0])).toBe(true);
+            });
+            (0, _vitest.it)('(container, other) : should not detect elements that are not contained', ()=>{
+                const $fruits = $('#fruits');
+                const $vegetables = $('#vegetables');
+                const $apple = $('.apple');
+                (0, _vitest.expect)(_fixtures.cheerio.contains($vegetables[0], $apple[0])).toBe(false);
+                (0, _vitest.expect)(_fixtures.cheerio.contains($fruits[0], $vegetables[0])).toBe(false);
+                (0, _vitest.expect)(_fixtures.cheerio.contains($vegetables[0], $fruits[0])).toBe(false);
+                (0, _vitest.expect)(_fixtures.cheerio.contains($fruits[0], $fruits[0])).toBe(false);
+                (0, _vitest.expect)(_fixtures.cheerio.contains($vegetables[0], $vegetables[0])).toBe(false);
+            });
+        });
+        (0, _vitest.describe)('.root', ()=>{
+            (0, _vitest.it)('returns an empty selection', ()=>{
+                const $empty = _fixtures.cheerio.root();
+                (0, _vitest.expect)($empty).toHaveLength(1);
+                (0, _vitest.expect)($empty[0].children).toHaveLength(0);
+            });
+        });
+    });
+    (0, _vitest.describe)('Cheerio function', ()=>{
+        (0, _vitest.it)('.load', ()=>{
+            const $1 = _fixtures.cheerio.load(_fixtures.fruits);
+            const $2 = $1.load('<div><p>Some <a>text</a>.</p></div>');
+            (0, _vitest.expect)($2('a')).toHaveLength(1);
+        });
+        /**
+     * The `.html` static method defined on the "loaded" Cheerio factory
+     * function is deprecated.
+     *
+     * In order to promote consistency with the jQuery library, users are
+     * encouraged to instead use the instance method of the same name.
+     *
+     * @example
+     *
+     * ```js
+     * const $ = cheerio.load('<h1>Hello, <span>world</span>.</h1>');
+     *
+     * $('h1').html();
+     * //=> '<h1>Hello, <span>world</span>.'
+     * ```
+     *
+     * @example <caption>To render the markup of an entire document, invoke the
+     * `html` function exported by the Cheerio module with a "root"
+     * selection.</caption>
+     *
+     * ```js
+     * cheerio.html($.root());
+     * //=> '<html><head></head><body><h1>Hello, <span>world</span>.</h1></body></html>'
+     * ```
+     */ (0, _vitest.describe)('.html - deprecated API', ()=>{
+            (0, _vitest.it)('() : of empty cheerio object should return null', ()=>{
+                /*
+         * Note: the direct invocation of the Cheerio constructor function is
+         * also deprecated.
+         */ const $ = (0, _fixtures.cheerio)();
+                (0, _vitest.expect)($.html()).toBe(null);
+            });
+            (0, _vitest.it)('(selector) : should return the outerHTML of the selected element', ()=>{
+                const $ = _fixtures.cheerio.load(_fixtures.fruits);
+                (0, _vitest.expect)($.html('.pear')).toBe('<li class="pear">Pear</li>');
+            });
+        });
+        /**
+     * The `.xml` static method defined on the "loaded" Cheerio factory function
+     * is deprecated. Users are encouraged to instead use the `xml` function
+     * exported by the Cheerio module.
+     *
+     * @example
+     *
+     * ```js
+     * cheerio.xml($.root());
+     * ```
+     */ (0, _vitest.describe)('.xml  - deprecated API', ()=>{
+            (0, _vitest.it)('() :  renders XML', ()=>{
+                const $ = _fixtures.cheerio.load('<foo></foo>', {
+                    xmlMode: true
+                });
+                (0, _vitest.expect)($.xml()).toBe('<foo/>');
+            });
+        });
+        /**
+     * The `.text` static method defined on the "loaded" Cheerio factory
+     * function is deprecated.
+     *
+     * In order to promote consistency with the jQuery library, users are
+     * encouraged to instead use the instance method of the same name.
+     *
+     * @example
+     *
+     * ```js
+     * const $ = cheerio.load('<h1>Hello, <span>world</span>.</h1>');
+     * $('h1').text();
+     * //=> 'Hello, world.'
+     * ```
+     *
+     * @example <caption>To render the text content of an entire document,
+     * invoke the `text` function exported by the Cheerio module with a "root"
+     * selection. </caption>
+     *
+     * ```js
+     * cheerio.text($.root());
+     * //=> 'Hello, world.'
+     * ```
+     */ (0, _vitest.describe)('.text  - deprecated API', ()=>{
+            (0, _vitest.it)('(cheerio object) : should return the text contents of the specified elements', ()=>{
+                const $ = _fixtures.cheerio.load('<a>This is <em>content</em>.</a>');
+                (0, _vitest.expect)($.text($('a'))).toBe('This is content.');
+            });
+            (0, _vitest.it)('(cheerio object) : should omit comment nodes', ()=>{
+                const $ = _fixtures.cheerio.load('<a>This is <!-- a comment --> not a comment.</a>');
+                (0, _vitest.expect)($.text($('a'))).toBe('This is  not a comment.');
+            });
+            (0, _vitest.it)('(cheerio object) : should include text contents of children recursively', ()=>{
+                const $ = _fixtures.cheerio.load('<a>This is <div>a child with <span>another child and <!-- a comment --> not a comment</span> followed by <em>one last child</em> and some final</div> text.</a>');
+                (0, _vitest.expect)($.text($('a'))).toBe('This is a child with another child and  not a comment followed by one last child and some final text.');
+            });
+            (0, _vitest.it)('() : should return the rendered text content of the root', ()=>{
+                const $ = _fixtures.cheerio.load('<a>This is <div>a child with <span>another child and <!-- a comment --> not a comment</span> followed by <em>one last child</em> and some final</div> text.</a>');
+                (0, _vitest.expect)($.text()).toBe('This is a child with another child and  not a comment followed by one last child and some final text.');
+            });
+            (0, _vitest.it)('(cheerio object) : should not omit script tags', ()=>{
+                const $ = _fixtures.cheerio.load('<script>console.log("test")</script>');
+                (0, _vitest.expect)($.text()).toBe('console.log("test")');
+            });
+            (0, _vitest.it)('(cheerio object) : should omit style tags', ()=>{
+                const $ = _fixtures.cheerio.load('<style type="text/css">.cf-hidden { display: none; }</style>');
+                (0, _vitest.expect)($.text()).toBe('.cf-hidden { display: none; }');
+            });
+        });
+    });
+});

package/dist/cjs/cheerio/src/__tests__/xml.spec.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _vitest = require("vitest");
+const _index = require("../index.js");
+function xml(str, options) {
+    options = {
+        xml: true,
+        ...options
+    };
+    const $ = (0, _index.load)(str, options);
+    return $.xml();
+}
+function dom(str, options) {
+    const $ = (0, _index.load)('', options);
+    return $(str).html();
+}
+(0, _vitest.describe)('render', ()=>{
+    (0, _vitest.describe)('(xml)', ()=>{
+        (0, _vitest.it)('should render <media:thumbnail /> tags correctly', ()=>{
+            const str = '<media:thumbnail url="http://www.foo.com/keyframe.jpg" width="75" height="50" time="12:05:01.123" />';
+            (0, _vitest.expect)(xml(str)).toBe('<media:thumbnail url="http://www.foo.com/keyframe.jpg" width="75" height="50" time="12:05:01.123"/>');
+        });
+        (0, _vitest.it)('should render <link /> tags (RSS) correctly', ()=>{
+            const str = '<link>http://www.github.com/</link>';
+            (0, _vitest.expect)(xml(str)).toBe('<link>http://www.github.com/</link>');
+        });
+        (0, _vitest.it)('should escape entities', ()=>{
+            const str = '<tag attr="foo &amp; bar"/>';
+            (0, _vitest.expect)(xml(str)).toBe(str);
+        });
+        (0, _vitest.it)('should render HTML as XML', ()=>{
+            const $ = (0, _index.load)('<foo></foo>', null, false);
+            (0, _vitest.expect)($.xml()).toBe('<foo/>');
+        });
+    });
+    (0, _vitest.describe)('(dom)', ()=>{
+        (0, _vitest.it)('should not keep camelCase for new nodes', ()=>{
+            const str = '<g><someElem someAttribute="something">hello</someElem></g>';
+            (0, _vitest.expect)(dom(str, {
+                xml: false
+            })).toBe('<someelem someattribute="something">hello</someelem>');
+        });
+        (0, _vitest.it)('should keep camelCase for new nodes', ()=>{
+            const str = '<g><someElem someAttribute="something">hello</someElem></g>';
+            (0, _vitest.expect)(dom(str, {
+                xml: true
+            })).toBe('<someElem someAttribute="something">hello</someElem>');
+        });
+        (0, _vitest.it)('should maintain the parsing options of distinct contexts independently', ()=>{
+            const str = '<g><someElem someAttribute="something">hello</someElem></g>';
+            const $ = (0, _index.load)('', {
+                xml: false
+            });
+            (0, _vitest.expect)($(str).html()).toBe('<someelem someattribute="something">hello</someelem>');
+        });
+    });
+});