Mangling non-main-entry-export names

[kurtextrem]

Suppose I have the following two files:
_prepare.mjs

const _stringifyCallback = (_, value) => {
  if (!value.isSJS) return value;
  return `${value.type}__sjs`;
};

const _prepare = (schema) => {
  const _preparedString = JSON.stringify(schema, _stringifyCallback);
  const _preparedSchema = JSON.parse(_preparedString);

  return {
    _preparedString,
    _preparedSchema,
  };
};

export { _prepare };

and

main.mjs, which is the entry point.

import { _prepare } from './_prepare.mjs'

function a() { _prepare({}); }
function b() { /* do other stuff */ }

export { a, b }

This results in the following minification:

const _stringifyCallback=(e,r)=>r.t?`${r.type}__sjs`:r,_prepare=e=>{const r=JSON.stringify(e,_stringifyCallback);return{_:r,p:JSON.parse(r)}};function a(){_prepare({})};function b(){};export{a,b};

However, when monitoring closely _stringifyCallback could be mangled, but is not, and also _prepare could be mangled, since it is not exported from the main entry point.
Is there a way to achieve at least one of the mangling?

The following mangle.json did not change anything (I tested a lot):

{
  "minify": {
    "mangle": {
      "toplevel": true,
      "properties": true,
      "keep_fnames": false
    },
    "compress": {
      "keep_fnames": false,
      "reduce_funcs": false,
      "passes": 2
    },
    "toplevel": true
  }
}

[developit]

Hmm - @kurtextrem not sure what's going on - here's the output I get from your example:

const n=(n,s)=>s.isSJS?`${s.type}__sjs`:s;function s(){(s=>{const t=JSON.stringify({},n);JSON.parse(t)})()}function t(){}export{s as a,t as b};

I left some comments on the slow-json-stringify PR.