@fink/loxia/js/identifier/init.js

A fink to JavaScript compiler.

import { _in_ } from "@fink/js-interop/runtime.js";
import types_0 from "@babel/types";
import { rx as rx_0 } from "@fink/std-lib/regex.js";
import { matches as matches_0 } from "@fink/std-lib/regex.js";
import { replace as replace_0 } from "@fink/std-lib/regex.js";
import hamt_0 from "hamt";
const acceptable_idents_0 = rx_0`^(?!(?:
  do|if|in|for|let|new|try|var|case|enum|void|with|break|catch|class|
  const|super|while|yield|delete|export|import|public|return|static|switch|
  typeof|default|extends|finally|package|private|continue|function|
  arguments|interface|protected|implements|instanceof|null|undefined
)$)
[_$\p{L}][_$\p{L}\p{N}]*$`;
const hyphen_replacement_0 = `ᜭ`;

const escape_hyphen_0 = name_0 => {
  const result_0 = replace_0(name_0, rx_0`-`, hyphen_replacement_0);
  return result_0;
};

const is_js_ident_0 = ident_0 => {
  const result_1 = matches_0(ident_0, acceptable_idents_0);
  return result_1;
};

const escape_ident_0 = ident_1 => {
  const name_1 = escape_hyphen_0(ident_1);
  const val_0 = matches_0(name_1, acceptable_idents_0);

  /* istanbul ignore else */
  if (true === val_0) {
    return name_1;
  }

  return `ˆ${name_1}`;
};

const replace_refs_0 = (...args_3) => {
  replace_refs_0: do {
    const dlst_0 = args_3[0];
    const hdm_0 = dlst_0[0];
    const id_0 = undefined === hdm_0 ? false : hdm_0;
    const renames_0 = args_3[1];
    const hdm_1 = args_3[2];
    const out_0 = undefined === hdm_1 ? [] : hdm_1;

    /* istanbul ignore else */
    if (id_0 === false) {
      return out_0;
    }

    const nid_0 = hamt_0.tryGet(false, id_0.i, renames_0);
    let ret_5;

    ret_5: {
      /* istanbul ignore else */
      if (nid_0 === false) {
        const result_10 = escape_ident_0(id_0.i);
        ret_5 = result_10;

        /* istanbul ignore next */
        break ret_5;
      }

      ret_5 = nid_0;

      /* istanbul ignore next */
      break ret_5;
    }

    const new_id_0 = ret_5;
    args_3 = [dlst_0.slice(1), renames_0, [...out_0, { ...id_0,
      i: new_id_0
    }]];
    continue replace_refs_0;
  } while (true);
};

const rename_0 = (...args_4) => {
  rename_0: do {
    const dlst_1 = args_4[0];
    const hdm_2 = dlst_1[0];
    const id_1 = undefined === hdm_2 ? false : hdm_2;
    const renames_1 = args_4[1];
    const hdm_3 = args_4[2];
    const out_1 = undefined === hdm_3 ? [] : hdm_3;

    /* istanbul ignore else */
    if (id_1 === false) {
      return [out_1, renames_1];
    }

    const new_id_1 = escape_ident_0(id_1.i);
    const nrs_0 = hamt_0.set(id_1.i, new_id_1, renames_1);
    args_4 = [dlst_1.slice(1), nrs_0, [...out_1, { ...id_1,
      i: new_id_1
    }]];
    continue rename_0;
  } while (true);
};

const safe_names_0 = (...args_5) => {
  safe_names_0: do {
    const dlst_2 = args_5[0];
    const hdm_4 = dlst_2[0];
    const curr_0 = undefined === hdm_4 ? false : hdm_4;
    const tail_12 = dlst_2.slice(1);
    const hdm_5 = args_5[1];
    const renames_2 = undefined === hdm_5 ? hamt_0.empty : hdm_5;
    const hdm_6 = args_5[2];
    const out_2 = undefined === hdm_6 ? [] : hdm_6;

    /* istanbul ignore else */
    if (curr_0 === false) {
      return [out_2, renames_2];
    }

    /* istanbul ignore else */
    if (null != curr_0) {
      const itm_4 = curr_0[0];

      /* istanbul ignore else */
      if (null != itm_4) {
        /* istanbul ignore else */
        if (true === _in_(itm_4.f, [`int`, `float`, `str`, `bool`])) {
          const dlst_12 = rename_0(curr_0[1], renames_2);
          args_5 = [tail_12, dlst_12[1], [...out_2, [curr_0[0], dlst_12[0]]]];
          continue safe_names_0;
        }
      }
    }

    /* istanbul ignore else */
    if (null != curr_0) {
      const itm_2 = curr_0[0];

      /* istanbul ignore else */
      if (null != itm_2) {
        /* istanbul ignore else */
        if (true === _in_(itm_2.f, [`tpl_i`, `tpl_s`])) {
          const expr_2 = curr_0[0];
          const val_11 = expr_2.args;
          const nargs_2 = replace_refs_0([val_11[0]], renames_2);
          const dlst_10 = rename_0(curr_0[1], renames_2);
          args_5 = [tail_12, dlst_10[1], [...out_2, [{ ...expr_2,
            args: [...nargs_2, ...val_11.slice(1)]
          }, dlst_10[0]]]];
          continue safe_names_0;
        }
      }
    }

    /* istanbul ignore else */
    if (null != curr_0) {
      const itm_0 = curr_0[0];

      /* istanbul ignore else */
      if (null != itm_0) {
        /* istanbul ignore else */
        if (true === _in_(itm_0.f, [`fn`, `cn`])) {
          const expr_1 = curr_0[0];
          const val_8 = expr_1.args;
          const dlst_6 = rename_0(val_8[0], renames_2);
          const dlst_7 = safe_names_0(val_8[1], dlst_6[1]);
          const dlst_8 = rename_0(curr_0[1], dlst_7[1]);
          args_5 = [tail_12, dlst_8[1], [...out_2, [{ ...expr_1,
            args: [dlst_6[0], dlst_7[0]]
          }, dlst_8[0]]]];
          continue safe_names_0;
        }
      }
    }

    const expr_0 = curr_0[0];
    const nargs_0 = replace_refs_0(expr_0.args, renames_2);
    const dlst_4 = rename_0(curr_0[1], renames_2);
    args_5 = [tail_12, dlst_4[1], [...out_2, [{ ...expr_0,
      args: nargs_0
    }, dlst_4[0]]]];
    continue safe_names_0;
  } while (true);
};

const replace_idents_0 = exprs_1 => {
  const dlst_13 = safe_names_0(exprs_1);
  return dlst_13[0];
};

const ident_2 = drec_5 => {
  const sprd_5 = types_0.identifier(drec_5.i);
  return { ...sprd_5,
    loc: drec_5.loc
  };
};

export const acceptable_idents = acceptable_idents_0,
      hyphen_replacement = hyphen_replacement_0,
      escape_hyphen = escape_hyphen_0,
      is_js_ident = is_js_ident_0,
      escape_ident = escape_ident_0,
      replace_refs = replace_refs_0,
      rename = rename_0,
      safe_names = safe_names_0,
      replace_idents = replace_idents_0,
      ident = ident_2;