JSFiddle - React, Tailwind, and code Playground

HTML

Output is in the console.<br>
But only in an up to date Chrome browser

<script type="module">
    window.μ = (() => {
        //build regexes without worrying about
        // - double-backslashing
        // - adding whitespace for readability
        // - adding in comments
        let clean = (piece) => (piece
            .replace(/(?<=^|\n)(?<line>(?:[^\/\\]|\/[^*\/]|\\.)*)\/\*(?:[^*]|\*[^\/])*(\*\/|)/g, '$<line>')
            .replace(/(?<=^|\n)(?<line>(?:[^\/\\]|\/[^\/]|\\.)*)\/\/[^\n]*/g, '$<line>')
            .replace(/\n\s*/g, '')
        );
        let regex = ({raw}, ...interpolations) => (
            new RegExp(interpolations.reduce(
                (regex, insert, index) => (regex + insert + clean(raw[index + 1])),
                clean(raw[0])
            ))
        );

        let start = {
            parse : regex`^\s*(?:
                //the end of the string
                //I permit the equal sign or just declaring the input after the destructure definition without one
                (?<done>=?\s*)
                |
                //save self to output?
                (?<read>(?<save>:\s*|))
                //opening either object or array
                (?<next>(?<open>[{[]).*)
            )$`
        };
        let object = {
            parse : regex`^\s*
                (?<read>
                    //closing the object
                    (?<close>\})|

                    //starting from open or comma you can...
                    (?:[,{]\s*)(?:
                        //have a rest operator
                        (?<rest>\.\.\.)
                        |
                        //have a property key
                        (?<key>
                            //a non-negative integer
                            \b\d+\b
                            |
                            //any unencapsulated string of the following
                            \b[A-Za-z$_][\w$]*\b
                            |
                           ...

JavaScript

let out = (func) => {
        try {
            console.log(...func().map((arg) => (JSON.stringify(arg))));
        }
        catch (e) {
            console.error(e);
        }
    };
    let _;
    
    //THE FOLLOWING WORK (AND ARE MEANT TO)
    _ = {a:{aa:7}, b:8};
    out(() => {
        const [input,{a,a:{aa},b}] = [,,].fill(_);
        return [input, a, b, aa];
    });
    out(() => {
        const [input,a,aa,b] = μ`:{a::{aa},b}=${_}`;
        return [input, a, b, aa];
    });

    _ = [[65, -4], 100, [3, 5]];
    out(() => {
        //const [[aa, ab], , c] = input; const [ca, cb] = c;
        const {0:{0:aa, 1:ab}, 2:c, 2:{0:ca, 1:cb}} = _;
        return [aa, ab, c, ca, cb];
    });
    out(() => {
        const [aa,ab,c,ca,cb] = μ`{0:{0,1}, 2::{0,1}}=${_}`;
        return [aa, ab, c, ca, cb];
    });

    _ = {a:{aa:7, ab:[7.5, 7.6, 7.7], 'a c"\'':7.8}, b:8};
    out(() => {
        const [input,{a,a:{aa,ab,ab:{0:aba, ...abb},"a c\"'":ac},b,def='hi'}] = [,,].fill(_);
        return [input, a, aa, ab, aba, abb, ac, b, def];
    });
    out(() => {
        const [input,a,aa,ab,aba,abb,ac,b,def='hi'] = μ`:{a::{aa,ab::{0, ...},"a c\"'"},b}=${_}`;
        return [input, a, aa, ab, aba, abb, ac, b, def];
    });

    _ = [{aa:7, ab:[7.5, {abba:7.6}, 7.7], 'a c"\'':7.8}, 8];
    out(() => {
        const [input,[{aa,ab,ab:[aba,{abba},...abc],"a c\"'":ac}],[a,b,def='hi']] = [,,,].fill(_);
        return [input, a, aa, ab, aba, abba, abc, ac, b, def];
    });
    out(() => {
        const [input,a,aa,ab,aba,abba,abc,ac,b,def='hi'] = μ`:[:{aa,ab::[,{abba},...],"a c\"'"},]=${_}`;
        return [input, a, aa, ab, aba, abba, abc, ac, b, def];
    });

    _ = [[-1,-2],[-3,-4],4,5,6,7,8,9,0,10];
    out(() => {
        const [[a,,,,,,,,,j], [[aa, ab], [ba]]] = [,,].fill(_);
        return [a, aa, ab, ba, j];
    });
    out(() => {
        const [a, aa, ab, ba, j] = μ`[:[ , ], [ ], 7, ] ${_}`;
        return [a, aa, ab, ba, j];
    });


    //THE FOLLOWING FAIL...