Scientific notation in Base-16 Input a scientific notation number (base 10), output scientific notation in base 16 (as defined below).
Details
In scientific notation, all non-zero numbers are written in the form
$$ m \times 10^n $$
Where \$ n \$ is an integer, and \$ m \$ is a real number, \$ 1 \leq |m| &lt; 10 \$.
Consider scientific notation in base 16.
$$ m \times 10^n = m' \times 16^{n'} $$
\$ n' \$ is an integer, and \$ m' \$ is a real number where \$ 1 \leq |m'| &lt; 16 \$.
Input / Output
Input a positive real number. You may also choice to input \$m\$, and, \$n\$ separately. For all testcase, -100 &lt; n &lt; 100.
Output the number in hexadecimal scientific notation. Could be a single string or two strings. Number \$m\$, and, \$n\$ should also be formatted as hexadecimal strings.
Output as 1.2E3E4 is not allowed due to ambiguous. (1.2E3×104, or 1.2×103E4) You have to use other notations. For example, 1.2E3E+4, 1.2E3, 4, 1.2E3&amp;4, 1.2e3E4, 1.2E3e4, 1.2E3P4, 1.2E3⏨4, 1.2E3*^4 are all acceptable.
Testcases
m, n -&gt; m', n'
1.6, 1 -&gt; 1, 1
6.25, -2 -&gt; 1, -1
1.0, 1 -&gt; A, 0
7.257672195146994, 93 -&gt; d.eadbeef, 4d
1.234567, 89 -&gt; f.83e0c1c37ba7, 49
1, -99 -&gt; 8.bfbea76c619f, -53

You output may be slightly different from given testcase due to floating point errors. But you should keep at least 4 hex digits precision, and \$1 \leq m' &lt; 16\$.
Rule
This is code golf. Shortest codes in each languages win.
JavaScript (ES6),  134 124  121 bytes
Expects a float and returns an array of 2 strings.
n=&gt;([x,y]=(+(g=n=&gt;s=n.toString(16))(n).replace(r=/[1-f]/g,1)).toExponential().split`e`,[x.replace(r,_=&gt;r.exec(s)),g(+y)])

Try it online!
How?
We first convert the input to hexadecimal and save the result in the variable s.
For instance, 7.257672195146994e93 is turned into:
&quot;deadbeef0000000000000000000000000000000000000000000000000000000000000000000000&quot;

We replace all non-zero hexadecimal digits with 1's:
&quot;111111110000000000000000000000000000000000000000000000000000000000000000000000&quot;

We coerce this back to an integer and invoke the .toExponential() method:
&quot;1.1111111e+77&quot;

We split this string into x = &quot;1.1111111&quot; and y = &quot;+77&quot;.
We replace all 1's in x with the non-zero hexadecimal digits of s in order of appearance:
&quot;d.eadbeef&quot;

Finally, we convert y to hexadecimal:
&quot;4d&quot;

Below is another example with 6e-19:
&quot;0.000000000000000b116b7de48f008&quot;
&quot;0.00000000000000011111111111001&quot;
&quot;1.1111111111001e-16&quot;
[ &quot;1.1111111111001&quot;, &quot;-16&quot; ]
[ &quot;b.116b7de48f008&quot;, &quot;-10&quot; ]

Commented
n =&gt; (                       // n = input
  [x, y] =                   // x = mantissa, y = exponent
    (                        //
      +(                     // coerce to integer:
        g = n =&gt;             //   g is a helper function converting its input ...
          s = n.toString(16) //     ... to a hexadecimal string saved in s
      )(n)                   //   invoke g with n
      .replace(              //   replace:
        r = /[1-f]/g,        //     r = regular expression to match the non-zero
                             //         hexa digits
        1                    //     replace all of them with 1's
      )                      //   end of replace()
    )                        //
    .toExponential()         // convert to exponential notation 
    .split`e`,               // split into [ x, y ] = [ mantissa, exponent ]
  [                          // output array:
    x.replace(               //   replace in x:
      r,                     //     use r a 2nd time to match the 1's
      _ =&gt; r.exec(s)         //     use r a 3rd time to get the next hexa digit
                             //     from s, this time taking advantage of the
                             //     stateful nature of RegExp
    ),                       //   end of replace()
    g(+y)                    //   convert y to hexadecimal
  ]                          // end of output array
)                            //