@handlewithcare/react-prosemirror 3.1.0-tiptap.28 → 3.1.0-tiptap.30

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

@@ -0,0 +1,249 @@
+/**
+ * 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.
+ */ import { describe, it, expect, beforeEach } from 'vitest';
+import { cheerio, food, fruits } from '../__fixtures__/fixtures.js';
+describe('deprecated APIs', ()=>{
+    describe('cheerio module', ()=>{
+        describe('.parseHTML', ()=>{
+            it('(html) : should preserve content', ()=>{
+                const html = '<div>test div</div>';
+                expect(cheerio(cheerio.parseHTML(html)[0]).html()).toBe('test div');
+            });
+        });
+        describe('.merge', ()=>{
+            it('should be a function', ()=>{
+                expect(typeof cheerio.merge).toBe('function');
+            });
+            // #1674 - merge, wont accept Cheerio object
+            it('should be a able merge array and cheerio object', ()=>{
+                const ret = cheerio.merge(cheerio(), [
+                    'elem1',
+                    'elem2'
+                ]);
+                expect(typeof ret).toBe('object');
+                expect(ret).toHaveLength(2);
+            });
+            it('(arraylike, arraylike) : should modify the first array, but not the second', ()=>{
+                const arr1 = [
+                    1,
+                    2,
+                    3
+                ];
+                const arr2 = [
+                    4,
+                    5,
+                    6
+                ];
+                const ret = cheerio.merge(arr1, arr2);
+                expect(typeof ret).toBe('object');
+                expect(Array.isArray(ret)).toBe(true);
+                expect(ret).toBe(arr1);
+                expect(arr1).toHaveLength(6);
+                expect(arr2).toHaveLength(3);
+            });
+            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'
+                };
+                cheerio.merge(arr1, arr2);
+                expect(arr1).toHaveLength(6);
+                expect(arr1[3]).toBe('d');
+                expect(arr1[4]).toBe('e');
+                expect(arr1[5]).toBe('f');
+                expect(arr2).toHaveLength(3);
+            });
+            it('(?, ?) : should gracefully reject invalid inputs', ()=>{
+                expect(cheerio.merge([
+                    4
+                ], 3)).toBeUndefined();
+                expect(cheerio.merge({}, {})).toBeUndefined();
+                expect(cheerio.merge([], {})).toBeUndefined();
+                expect(cheerio.merge({}, [])).toBeUndefined();
+                const fakeArray = {
+                    length: 3,
+                    0: 'a',
+                    1: 'b',
+                    3: 'd'
+                };
+                expect(cheerio.merge(fakeArray, [])).toBeUndefined();
+                expect(cheerio.merge([], fakeArray)).toBeUndefined();
+                expect(cheerio.merge({
+                    length: '7'
+                }, [])).toBeUndefined();
+                expect(cheerio.merge({
+                    length: -1
+                }, [])).toBeUndefined();
+            });
+            it('(?, ?) : should no-op on invalid inputs', ()=>{
+                const fakeArray1 = {
+                    length: 3,
+                    0: 'a',
+                    1: 'b',
+                    3: 'd'
+                };
+                cheerio.merge(fakeArray1, []);
+                expect(fakeArray1).toHaveLength(3);
+                expect(fakeArray1[0]).toBe('a');
+                expect(fakeArray1[1]).toBe('b');
+                expect(fakeArray1[3]).toBe('d');
+                cheerio.merge([], fakeArray1);
+                expect(fakeArray1).toHaveLength(3);
+                expect(fakeArray1[0]).toBe('a');
+                expect(fakeArray1[1]).toBe('b');
+                expect(fakeArray1[3]).toBe('d');
+            });
+        });
+        describe('.contains', ()=>{
+            let $;
+            beforeEach(()=>{
+                $ = cheerio.load(food);
+            });
+            it('(container, contained) : should correctly detect the provided element', ()=>{
+                const $food = $('#food');
+                const $fruits = $('#fruits');
+                const $apple = $('.apple');
+                expect(cheerio.contains($food[0], $fruits[0])).toBe(true);
+                expect(cheerio.contains($food[0], $apple[0])).toBe(true);
+            });
+            it('(container, other) : should not detect elements that are not contained', ()=>{
+                const $fruits = $('#fruits');
+                const $vegetables = $('#vegetables');
+                const $apple = $('.apple');
+                expect(cheerio.contains($vegetables[0], $apple[0])).toBe(false);
+                expect(cheerio.contains($fruits[0], $vegetables[0])).toBe(false);
+                expect(cheerio.contains($vegetables[0], $fruits[0])).toBe(false);
+                expect(cheerio.contains($fruits[0], $fruits[0])).toBe(false);
+                expect(cheerio.contains($vegetables[0], $vegetables[0])).toBe(false);
+            });
+        });
+        describe('.root', ()=>{
+            it('returns an empty selection', ()=>{
+                const $empty = cheerio.root();
+                expect($empty).toHaveLength(1);
+                expect($empty[0].children).toHaveLength(0);
+            });
+        });
+    });
+    describe('Cheerio function', ()=>{
+        it('.load', ()=>{
+            const $1 = cheerio.load(fruits);
+            const $2 = $1.load('<div><p>Some <a>text</a>.</p></div>');
+            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>'
+     * ```
+     */ 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('<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());
+     * ```
+     */ describe('.xml  - deprecated API', ()=>{
+            it('() :  renders XML', ()=>{
+                const $ = cheerio.load('<foo></foo>', {
+                    xmlMode: true
+                });
+                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.'
+     * ```
+     */ describe('.text  - deprecated API', ()=>{
+            it('(cheerio object) : should return the text contents of the specified elements', ()=>{
+                const $ = cheerio.load('<a>This is <em>content</em>.</a>');
+                expect($.text($('a'))).toBe('This is content.');
+            });
+            it('(cheerio object) : should omit comment nodes', ()=>{
+                const $ = cheerio.load('<a>This is <!-- a comment --> not a comment.</a>');
+                expect($.text($('a'))).toBe('This is  not a comment.');
+            });
+            it('(cheerio object) : should include text contents of children recursively', ()=>{
+                const $ = 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>');
+                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('<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>');
+                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('<script>console.log("test")</script>');
+                expect($.text()).toBe('console.log("test")');
+            });
+            it('(cheerio object) : should omit style tags', ()=>{
+                const $ = cheerio.load('<style type="text/css">.cf-hidden { display: none; }</style>');
+                expect($.text()).toBe('.cf-hidden { display: none; }');
+            });
+        });
+    });
+});

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

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

package/dist/esm/esm/esm/cjs/@jest/pattern/src/__tests__/TestPathPatterns.test.js

@@ -0,0 +1,286 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _path = /*#__PURE__*/ _interop_require_wildcard(require("path"));
+const _TestPathPatterns = require("../TestPathPatterns");
+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;
+}
+const mockSep = jest.fn();
+const mockIsAbsolute = jest.fn();
+const mockRelative = jest.fn();
+jest.mock('path', ()=>{
+    const actualPath = jest.requireActual('path');
+    return {
+        ...actualPath,
+        isAbsolute (p) {
+            return mockIsAbsolute(p) || actualPath.isAbsolute(p);
+        },
+        relative (from, to) {
+            return mockRelative(from, to) || actualPath.relative(from, to);
+        },
+        get sep () {
+            return mockSep() || actualPath.sep;
+        }
+    };
+});
+const forcePosix = ()=>{
+    mockSep.mockReturnValue(_path.posix.sep);
+    mockIsAbsolute.mockImplementation(_path.posix.isAbsolute);
+    mockRelative.mockImplementation(_path.posix.relative);
+};
+const forceWindows = ()=>{
+    mockSep.mockReturnValue(_path.win32.sep);
+    mockIsAbsolute.mockImplementation(_path.win32.isAbsolute);
+    mockRelative.mockImplementation(_path.win32.relative);
+};
+beforeEach(()=>{
+    jest.resetAllMocks();
+    forcePosix();
+});
+const config = {
+    rootDir: ''
+};
+const testPathPatternsLikeTests = (makePatterns)=>{
+    describe('isSet', ()=>{
+        it('returns false if no patterns specified', ()=>{
+            const testPathPatterns = makePatterns([], config);
+            expect(testPathPatterns.isSet()).toBe(false);
+        });
+        it('returns true if patterns specified', ()=>{
+            const testPathPatterns = makePatterns([
+                'a'
+            ], config);
+            expect(testPathPatterns.isSet()).toBe(true);
+        });
+    });
+    describe('isValid', ()=>{
+        it('succeeds for empty patterns', ()=>{
+            const testPathPatterns = makePatterns([], config);
+            expect(testPathPatterns.isValid()).toBe(true);
+        });
+        it('succeeds for valid patterns', ()=>{
+            const testPathPatterns = makePatterns([
+                'abc+',
+                'z.*'
+            ], config);
+            expect(testPathPatterns.isValid()).toBe(true);
+        });
+        it('fails for at least one invalid pattern', ()=>{
+            const testPathPatterns = makePatterns([
+                'abc+',
+                '(',
+                'z.*'
+            ], config);
+            expect(testPathPatterns.isValid()).toBe(false);
+        });
+    });
+    describe('toPretty', ()=>{
+        it('renders a human-readable string', ()=>{
+            const testPathPatterns = makePatterns([
+                'a/b',
+                'c/d'
+            ], config);
+            expect(testPathPatterns.toPretty()).toMatchSnapshot();
+        });
+    });
+};
+describe('TestPathPatterns', ()=>{
+    testPathPatternsLikeTests((patterns, _)=>new _TestPathPatterns.TestPathPatterns(patterns));
+});
+describe('TestPathPatternsExecutor', ()=>{
+    const makeExecutor = (patterns, options)=>new _TestPathPatterns.TestPathPatternsExecutor(new _TestPathPatterns.TestPathPatterns(patterns), options);
+    testPathPatternsLikeTests(makeExecutor);
+    describe('isMatch', ()=>{
+        it('returns true with no patterns', ()=>{
+            const testPathPatterns = makeExecutor([], config);
+            expect(testPathPatterns.isMatch('/a/b')).toBe(true);
+        });
+        it('returns true for same path', ()=>{
+            const testPathPatterns = makeExecutor([
+                '/a/b'
+            ], config);
+            expect(testPathPatterns.isMatch('/a/b')).toBe(true);
+        });
+        it('returns true for same path with case insensitive', ()=>{
+            const testPathPatternsUpper = makeExecutor([
+                '/A/B'
+            ], config);
+            expect(testPathPatternsUpper.isMatch('/a/b')).toBe(true);
+            expect(testPathPatternsUpper.isMatch('/A/B')).toBe(true);
+            const testPathPatternsLower = makeExecutor([
+                '/a/b'
+            ], config);
+            expect(testPathPatternsLower.isMatch('/A/B')).toBe(true);
+            expect(testPathPatternsLower.isMatch('/a/b')).toBe(true);
+        });
+        it('returns true for contained path', ()=>{
+            const testPathPatterns = makeExecutor([
+                'b/c'
+            ], config);
+            expect(testPathPatterns.isMatch('/a/b/c/d')).toBe(true);
+        });
+        it('returns true for explicit relative path', ()=>{
+            const testPathPatterns = makeExecutor([
+                './b/c'
+            ], {
+                rootDir: '/a'
+            });
+            expect(testPathPatterns.isMatch('/a/b/c')).toBe(true);
+        });
+        it('returns true for explicit relative path for Windows with ./', ()=>{
+            forceWindows();
+            const testPathPatterns = makeExecutor([
+                './b/c'
+            ], {
+                rootDir: 'C:\\a'
+            });
+            expect(testPathPatterns.isMatch('C:\\a\\b\\c')).toBe(true);
+        });
+        it('returns true for explicit relative path for Windows with .\\', ()=>{
+            forceWindows();
+            const testPathPatterns = makeExecutor([
+                '.\\b\\c'
+            ], {
+                rootDir: 'C:\\a'
+            });
+            expect(testPathPatterns.isMatch('C:\\a\\b\\c')).toBe(true);
+        });
+        it('returns true for partial file match', ()=>{
+            const testPathPatterns = makeExecutor([
+                'aaa'
+            ], config);
+            expect(testPathPatterns.isMatch('/foo/..aaa..')).toBe(true);
+            expect(testPathPatterns.isMatch('/foo/..aaa')).toBe(true);
+            expect(testPathPatterns.isMatch('/foo/aaa..')).toBe(true);
+        });
+        it('returns true for path suffix', ()=>{
+            const testPathPatterns = makeExecutor([
+                'c/d'
+            ], config);
+            expect(testPathPatterns.isMatch('/a/b/c/d')).toBe(true);
+        });
+        it('returns true if regex matches', ()=>{
+            const testPathPatterns = makeExecutor([
+                'ab*c?'
+            ], config);
+            expect(testPathPatterns.isMatch('/foo/a')).toBe(true);
+            expect(testPathPatterns.isMatch('/foo/ab')).toBe(true);
+            expect(testPathPatterns.isMatch('/foo/abb')).toBe(true);
+            expect(testPathPatterns.isMatch('/foo/ac')).toBe(true);
+            expect(testPathPatterns.isMatch('/foo/abc')).toBe(true);
+            expect(testPathPatterns.isMatch('/foo/abbc')).toBe(true);
+            expect(testPathPatterns.isMatch('/foo/bc')).toBe(false);
+        });
+        it('returns true only if matches relative path', ()=>{
+            const rootDir = '/home/myuser/';
+            const testPathPatterns = makeExecutor([
+                'home'
+            ], {
+                rootDir
+            });
+            expect(testPathPatterns.isMatch(_path.relative(rootDir, '/home/myuser/LoginPage.js'))).toBe(false);
+            expect(testPathPatterns.isMatch(_path.relative(rootDir, '/home/myuser/HomePage.js'))).toBe(true);
+        });
+        it('matches absolute paths regardless of rootDir', ()=>{
+            forcePosix();
+            const testPathPatterns = makeExecutor([
+                '/a/b'
+            ], {
+                rootDir: '/foo/bar'
+            });
+            expect(testPathPatterns.isMatch('/a/b')).toBe(true);
+        });
+        it('matches absolute paths for Windows', ()=>{
+            forceWindows();
+            const testPathPatterns = makeExecutor([
+                'C:\\a\\b'
+            ], {
+                rootDir: 'C:\\foo\\bar'
+            });
+            expect(testPathPatterns.isMatch('C:\\a\\b')).toBe(true);
+        });
+        it('returns true if match any paths', ()=>{
+            const testPathPatterns = makeExecutor([
+                'a/b',
+                'c/d'
+            ], config);
+            expect(testPathPatterns.isMatch('/foo/a/b')).toBe(true);
+            expect(testPathPatterns.isMatch('/foo/c/d')).toBe(true);
+            expect(testPathPatterns.isMatch('/foo/a')).toBe(false);
+            expect(testPathPatterns.isMatch('/foo/b/c')).toBe(false);
+        });
+        it('does not normalize Windows paths on POSIX', ()=>{
+            forcePosix();
+            const testPathPatterns = makeExecutor([
+                'a\\z',
+                'a\\\\z'
+            ], config);
+            expect(testPathPatterns.isMatch('/foo/a/z')).toBe(false);
+        });
+        it('normalizes paths for Windows', ()=>{
+            forceWindows();
+            const testPathPatterns = makeExecutor([
+                'a/b'
+            ], config);
+            expect(testPathPatterns.isMatch('C:\\foo\\a\\b')).toBe(true);
+        });
+        it('matches absolute path with absPath', ()=>{
+            const pattern = '^/home/app/';
+            const rootDir = '/home/app';
+            const absolutePath = '/home/app/packages/';
+            const testPathPatterns = makeExecutor([
+                pattern
+            ], {
+                rootDir
+            });
+            const relativePath = _path.relative(rootDir, absolutePath);
+            expect(testPathPatterns.isMatch(relativePath)).toBe(false);
+            expect(testPathPatterns.isMatch(absolutePath)).toBe(true);
+        });
+    });
+});

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

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _core = require("@swc/core");
+const _compile = require("../compile");
+jest.mock("@swc/core");
+describe("compile", ()=>{
+    it("compile with sync transform", async ()=>{
+        const options = {};
+        await (0, _compile.compile)("test.ts", options, true, undefined);
+        expect(_core.transformFileSync).toHaveBeenCalledWith("test.ts", options);
+    });
+    it("compile with async transform", async ()=>{
+        const options = {};
+        await (0, _compile.compile)("test.ts", options, false, undefined);
+        expect(_core.transformFile).toHaveBeenCalledWith("test.ts", options);
+    });
+}); //# sourceMappingURL=compile.test.js.map