Specifiers

I have been trying to find a good way to paraphrase intuitive concerns regarding scheme-less specifiers and I think that while import: is different from other ideas proposed for somewhat related purposes, it may be coming from similar but more tangible consideration.

Yesterday I did a little experiment with URL in node, Chrome, and Safari , and Firefox. My general thought is that new URL(x, y) is a resolution formula that follows closest to the web standards so my assumption is that it pairs well with the whatwg expectations on specifiers.

The bottom line is that constructing scheme-less specifiers that depend on scheme-less referrers is not possible, and the hack used just to get through the list of valid specifiers was to resolve the referrer against file://y:/ which is not a proposed solution by all means.

Given the importance of specifier resolution (ie x -> y = z) I am really not comfortable with writing this off to the general sentiment that "there is a package that does that already". (Sorry, nothing against anyone's packages)

I needed a way to parse specifiers independent from URL, not as a solution or a package, just to be able to explore my concerns a little further.

So naturally, I spent the rest of that devising the ugliest Regular Expression I have ever seen, and I think that most of them are ugly anyways, but:

const Specifier = /^(?=(\S*(?=,|;)|\S*(\/)|)[^#?,]*|\S*:)(?:((?:blob:|[a-z]+[+])?[a-z]+[^/\s]*?:(?!\d+\/))?(?:\/{2})?((?:(?:[^/,\s]+)?|\b[^/,\s]+)(?=\/[^#?,]+(?:[#?].*)?$))?)?(?:([.]{0,2}\/)?([^\s,#?]* *)(\?[^,#]*?)?(#.*?)?|(?:([a-z]+\/[^,]*),)?(.*))$/i;

Which comes with it's key:

// prettier-ignore
Specifier.parse = string => {
  let scope, resource;
  const [url, base, separator, scheme, domain, root, path, query, fragment, type, body] =
    Specifier.exec(string.replace(/\\/g, '/')) || '';

  if (domain || path || root) {
    scope = `${scheme ? `${scheme}//` : ''}${domain || ''}${root || ''}` || undefined;
    resource = path ? path.replace(/^\//, '') : undefined;
  } else if (scheme) {
    scope = `${scheme || ''}${type || ''}` || undefined;
    resource = body || undefined;
  }

  // prettier-ignore
  return { url, base, separator , scheme, domain, path, root, query, fragment, type, body, scope, resource };
};

So running a little script, I was able to compare the RegExp with the hacky URL approach: