Very Popular
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280import { ImportMap, isImportMap, isImports, isScopes, isSpecifierMap, isURL, Scopes, sortObject, SpecifierMap,} from "./_util.ts";
export type { ImportMap, Scopes, SpecifierMap } from "./_util.ts";
/* https://wicg.github.io/import-maps/#sort-and-normalize-a-specifier-map */function sortAndNormalizeSpecifierMap( originalMap: SpecifierMap, baseURL: URL,): SpecifierMap { const normalized: SpecifierMap = {}; for (const [specifierKey, value] of Object.entries(originalMap)) { const normalizedSpecifierKey = normalizeSpecifierKey(specifierKey, baseURL); if (normalizedSpecifierKey === null) continue; if (typeof value !== "string") { console.warn(`addresses need to be strings.`); normalized[normalizedSpecifierKey] = null; continue; } const addressURL = parseUrlLikeImportSpecifier(value, baseURL);
if (addressURL === null) { console.warn(`the address was invalid.`); normalized[normalizedSpecifierKey] = null; continue; } if (specifierKey.endsWith("/") && !serializeURL(addressURL).endsWith("/")) { console.warn( `an invalid address was given for the specifier key specifierKey; since specifierKey ended in a slash, the address needs to as well.`, ); normalized[normalizedSpecifierKey] = null; continue; } normalized[normalizedSpecifierKey] = serializeURL(addressURL); } return sortObject(normalized) as SpecifierMap;}/* https://url.spec.whatwg.org/#concept-url-serializer */function serializeURL(url: URL): string { return url.href;}/* https://wicg.github.io/import-maps/#sort-and-normalize-scopes */function sortAndNormalizeScopes( originalMap: Scopes, baseURL: URL,): Scopes { const normalized: Scopes = {}; for ( const [scopePrefix, potentialSpecifierMap] of Object.entries(originalMap) ) { if (!isSpecifierMap(potentialSpecifierMap)) { throw new TypeError( `the value of the scope with prefix scopePrefix needs to be an object.`, ); } let scopePrefixURL; try { scopePrefixURL = new URL(scopePrefix, baseURL); } catch { console.warn(`the scope prefix URL was not parseable.`); continue; } const normalizedScopePrefix = serializeURL(scopePrefixURL); normalized[normalizedScopePrefix] = sortAndNormalizeSpecifierMap( potentialSpecifierMap, baseURL, ); }
const sorted: Scopes = {}; for (const key of Object.keys(normalized)) { sorted[key] = sortObject(normalized[key]) as SpecifierMap; } return sortObject(sorted) as Scopes;}/* https://wicg.github.io/import-maps/#normalize-a-specifier-key */function normalizeSpecifierKey( specifierKey: string, baseURL: URL,): string | null { if (!specifierKey.length) { console.warn("specifier key cannot be an empty string."); return null; } const url = parseUrlLikeImportSpecifier(specifierKey, baseURL); if (url !== null) { return serializeURL(url); } return specifierKey;}/* https://wicg.github.io/import-maps/#parse-a-url-like-import-specifier */function parseUrlLikeImportSpecifier( specifier: string, baseURL: URL,): URL | null { if ( baseURL && (specifier.startsWith("/") || specifier.startsWith("./") || specifier.startsWith("../")) ) { try { const url = new URL(specifier, baseURL); return url; } catch { return null; } }
try { const url = new URL(specifier); return url; } catch { return null; }}
const specialSchemes = [ "ftp", "file", "http", "https", "ws", "wss",];/* https://url.spec.whatwg.org/#is-special */function isSpecial(asURL: URL): boolean { return specialSchemes.some((scheme) => serializeURL(asURL).startsWith(scheme) );}/* https://wicg.github.io/import-maps/#resolve-an-imports-match */function resolveImportsMatch( normalizedSpecifier: string, asURL: URL | null, specifierMap: SpecifierMap,): string | null { for ( const [specifierKey, resolutionResult] of Object.entries(specifierMap) ) { if (specifierKey === normalizedSpecifier) { if (resolutionResult === null) { throw new TypeError( `resolution of specifierKey was blocked by a null entry.`, ); } if (!isURL(resolutionResult)) { throw new TypeError(`resolutionResult must be an URL.`); } return resolutionResult; } else if ( specifierKey.endsWith("/") && normalizedSpecifier.startsWith(specifierKey) && (asURL === null || isSpecial(asURL)) ) { if (resolutionResult === null) { throw new TypeError( `resolution of specifierKey was blocked by a null entry.`, ); } if (!isURL(resolutionResult)) { throw new TypeError(`resolutionResult must be an URL.`); } const afterPrefix = normalizedSpecifier.slice(specifierKey.length);
if (!resolutionResult.endsWith("/")) { throw new TypeError(`resolutionResult does not end with "/"`); }
try { const url = new URL(afterPrefix, resolutionResult); if (!isURL(url)) { throw new TypeError(`url must be an URL.`); } if (!serializeURL(url).startsWith(resolutionResult)) { throw new TypeError( `resolution of normalizedSpecifier was blocked due to it backtracking above its prefix specifierKey.`, ); } return serializeURL(url); } catch { throw new TypeError( `resolution of normalizedSpecifier was blocked since the afterPrefix portion could not be URL-parsed relative to the resolutionResult mapped to by the specifierKey prefix.`, ); } } } return null;}/* https://wicg.github.io/import-maps/#parsing */// do not parse JSON string as done in the specs. That can be done with JSON.parseexport function resolveImportMap( importMap: ImportMap, baseURL: URL,): ImportMap { let sortedAndNormalizedImports = {}; if (!isImportMap(importMap)) { throw new TypeError(`the top-level value needs to be a JSON object.`); } const { imports, scopes } = importMap; if (imports !== undefined) { if (!isImports(imports)) { throw new TypeError(`"imports" top-level key needs to be an object.`); } sortedAndNormalizedImports = sortAndNormalizeSpecifierMap( imports, baseURL, ); } let sortedAndNormalizedScopes = {}; if (scopes !== undefined) { if (!isScopes(scopes)) { throw new TypeError(`"scopes" top-level key needs to be an object.`); } sortedAndNormalizedScopes = sortAndNormalizeScopes( scopes, baseURL, ); } if ( Object.keys(importMap).find((key) => key !== "imports" && key !== "scopes") ) { console.warn(`an invalid top-level key was present in the import map.`); } return { imports: sortedAndNormalizedImports, scopes: sortedAndNormalizedScopes, };}/* https://wicg.github.io/import-maps/#new-resolve-algorithm */export function resolveModuleSpecifier( specifier: string, { imports = {}, scopes = {} }: ImportMap, baseURL: URL,): string { const baseURLString = serializeURL(baseURL); const asURL = parseUrlLikeImportSpecifier(specifier, baseURL); const normalizedSpecifier = asURL !== null ? serializeURL(asURL) : specifier; for (const [scopePrefix, scopeImports] of Object.entries(scopes)) { if ( scopePrefix === baseURLString || (scopePrefix.endsWith("/") && baseURLString.startsWith(scopePrefix)) ) { const scopeImportsMatch = resolveImportsMatch( normalizedSpecifier, asURL, scopeImports, ); if (scopeImportsMatch !== null) { return scopeImportsMatch; } } }
const topLevelImportsMatch = resolveImportsMatch( normalizedSpecifier, asURL, imports, );
if (topLevelImportsMatch !== null) { return topLevelImportsMatch; }
if (asURL !== null) { return serializeURL(asURL); } throw new TypeError( `specifier was a bare specifier, but was not remapped to anything by importMap.`, );}