HomePhorge
Diffusion Ant (type-hints-typescript) Code

ant/src/esm/loader.c
899dad6b8a9etype-hints-typescript

Last Change
Raw File

loader.c
View Options

#include <compat.h> // IWYU pragma: keep
#include "esm/loader.h"
#include "esm/commonjs.h"
#include "esm/library.h"
#include "esm/remote.h"
#include "esm/builtin_bundle.h"
#include "modules/json.h"
#include "modules/napi.h"
#include "modules/uri.h"
#include "errors.h"
#include "gc/modules.h"
#include "internal.h"
#include "reactor.h"
#include "utils.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#ifndef _WIN32
#include <libgen.h>
#include <unistd.h>
#endif
#include <uthash.h>
#include <yyjson.h>
typedef enum {
ESM_MODULE_KIND_CODE = 0,
ESM_MODULE_KIND_JSON,
ESM_MODULE_KIND_TEXT,
ESM_MODULE_KIND_IMAGE,
ESM_MODULE_KIND_NATIVE,
ESM_MODULE_KIND_URL,
} esm_module_kind_t;
typedef struct esm_module {
char *path;
char *cache_key;
char *resolved_path;
char *url_content;
size_t url_content_len;
const uint8_t *embedded_code;
size_t embedded_code_len;
ant_value_t namespace_obj;
ant_value_t default_export;
ant_value_t tla_promise;
UT_hash_handle hh;
esm_module_kind_t kind;
ant_module_format_t format;
bool is_loaded;
bool is_loading;
bool has_tla;
} esm_module_t;
typedef struct {
esm_module_t *modules;
int count;
} esm_module_cache_t;
typedef struct {
char *data;
size_t size;
} esm_file_data_t;
static esm_module_cache_t global_module_cache = {NULL, 0};
static int esm_dynamic_import_depth = 0;
static char *esm_resolve_node_module(const char *specifier, const char *base_path);
static char *esm_canonicalize_path(const char *path);
static char *esm_file_url_to_path(ant_t *js, const char *specifier) {
if (!specifier || strncmp(specifier, "file:", 5) != 0) return NULL;
const char *p = specifier + 5;
if (strncmp(p, "///", 3) == 0) p += 2;
else if (strncmp(p, "//localhost/", 12) == 0) p += 11;
if (*p == '\0') return NULL;
ant_value_t encoded = js_mkstr(js, p, strlen(p));
ant_value_t decoded = js_decodeURI(js, &encoded, 1);
size_t len = 0;
char *str = js_getstr(js, decoded, &len);
return str ? strndup(str, len) : NULL;
}
static char *esm_make_cache_key(const char *module_key) {
if (!module_key) return NULL;
if (esm_has_builtin_scheme(module_key)) return strdup(module_key);
if (esm_is_data_url(module_key)) return strdup(module_key);
if (esm_is_url(module_key)) return strdup(module_key);
return esm_canonicalize_path(module_key);
}
static char *esm_get_extension(const char *path) {
const char *dot = strrchr(path, '.');
const char *slash = strrchr(path, '/');
if (dot && (!slash || dot > slash)) {
return strdup(dot);
}
return strdup(".js");
}
static bool esm_is_relative_specifier(const char *specifier) {
return
strcmp(specifier, ".") == 0 ||
strcmp(specifier, "..") == 0 ||
strncmp(specifier, "./", 2) == 0 ||
strncmp(specifier, "../", 3) == 0;
}
static char *esm_try_resolve(const char *dir, const char *spec, const char *suffix) {
char path[PATH_MAX];
snprintf(path, PATH_MAX, "%s/%s%s", dir, spec, suffix);
char *resolved = realpath(path, NULL);
if (resolved) {
struct stat st;
if (stat(resolved, &st) == 0 && S_ISREG(st.st_mode)) return resolved;
free(resolved);
}
return NULL;
}
static bool esm_has_extension(const char *spec) {
const char *slash = strrchr(spec, '/');
const char *dot = strrchr(slash ? slash : spec, '.');
if (!dot) return false;
for (
const char *const *ext = module_resolve_extensions;
*ext; ext++
) if (strcmp(dot, *ext) == 0) return true;
return false;
}
static char *esm_try_resolve_with_exts(const char *dir, const char *spec, bool has_ext) {
const char *const *exts = module_resolve_extensions;
char *result = NULL;
if ((result = esm_try_resolve(dir, spec, ""))) return result;
if (has_ext) return NULL;
for (int i = 0; exts[i]; i++) {
if ((result = esm_try_resolve(dir, spec, exts[i]))) return result;
}
return NULL;
}
static char *esm_try_resolve_index_with_exts(const char *dir, const char *spec) {
char idx[PATH_MAX];
snprintf(idx, sizeof(idx), "%s/index", spec);
return esm_try_resolve_with_exts(dir, idx, false);
}
static char *esm_try_resolve_relative_typescript_source_fallback(
const char *dir,
const char *spec,
const char *base_path
) {
if (!is_typescript_file(base_path)) return NULL;
char *ts_spec = resolve_typescript_source_fallback(spec);
if (!ts_spec) return NULL;
char *resolved = esm_try_resolve(dir, ts_spec, "");
free(ts_spec);
return resolved;
}
static ant_value_t esm_default_export_or_namespace(ant_t *js, ant_value_t ns) {
ant_value_t default_val = js_get_slot(ns, SLOT_DEFAULT);
return vtype(default_val) != T_UNDEF ? default_val : ns;
}
static ant_value_t esm_make_namespace_object(ant_t *js) {
ant_value_t ns = js_mkobj(js);
js_set_slot(ns, SLOT_BRAND, js_mknum(BRAND_MODULE_NAMESPACE));
js_set_slot(ns, SLOT_MODULE_LOADING, js_true);
return ns;
}
static ant_value_t esm_complete_value_module(esm_module_t *mod, ant_value_t value) {
if (is_err(value)) {
mod->is_loading = false;
return value;
}
mod->namespace_obj = value;
mod->default_export = value;
mod->is_loaded = true;
mod->is_loading = false;
return value;
}
static ant_value_t esm_complete_namespace_module(ant_t *js, esm_module_t *mod, ant_value_t ns) {
mod->namespace_obj = ns;
mod->default_export = esm_default_export_or_namespace(js, ns);
mod->is_loaded = true;
mod->is_loading = false;
js_set_slot(ns, SLOT_MODULE_LOADING, js_mkundef());
return ns;
}
static ant_value_t esm_prepare_eval_ctx(
ant_t *js,
const char *resolved_path,
ant_value_t ns,
ant_module_format_t format,
bool is_main,
const char *fallback_parent_path,
ant_module_t *out_ctx
) {
ant_value_t module_ctx = js_create_module_context(js, resolved_path, is_main);
if (is_err(module_ctx)) return module_ctx;
if (is_object_type(ns)) js_set_slot_wb(js, ns, SLOT_MODULE_CTX, module_ctx);
*out_ctx = (ant_module_t){
.module_ns = ns,
.module_ctx = module_ctx,
.prev_import_meta_prop = js_mkundef(),
.format = format,
.prev = NULL,
};
return js_mkundef();
}
static char *esm_try_resolve_from_extension_list(
const char *dir,
const char *spec,
const char *first_ext,
const char *skip_ext
) {
char *result = NULL;
if (first_ext && first_ext[0]) {
if ((result = esm_try_resolve(dir, spec, first_ext))) return result;
}
const char *const *exts = module_resolve_extensions;
for (int i = 0; exts[i]; i++) {
if (skip_ext && strcmp(skip_ext, exts[i]) == 0) continue;
if ((result = esm_try_resolve(dir, spec, exts[i]))) return result;
}
return NULL;
}
static char *esm_resolve_absolute(const char *specifier) {
char *result = esm_try_resolve_with_exts("", specifier, esm_has_extension(specifier));
if (result) return result;
return esm_try_resolve_index_with_exts("", specifier);
}
static char *esm_get_base_dir(const char *base_path) {
if (!base_path || !base_path[0]) {
char cwd[PATH_MAX];
if (!getcwd(cwd, sizeof(cwd))) return NULL;
return strdup(cwd);
}
char candidate[PATH_MAX];
if (base_path[0] == '/') {
snprintf(candidate, sizeof(candidate), "%s", base_path);
} else {
char cwd[PATH_MAX];
if (!getcwd(cwd, sizeof(cwd))) return NULL;
snprintf(candidate, sizeof(candidate), "%s/%s", cwd, base_path);
}
char *resolved = realpath(candidate, NULL);
const char *resolved_or_candidate = resolved ? resolved : candidate;
struct stat st;
if (stat(resolved_or_candidate, &st) == 0 && S_ISDIR(st.st_mode)) {
char *out = realpath(resolved_or_candidate, NULL);
if (!out) out = strdup(resolved_or_candidate);
if (resolved) free(resolved);
return out;
}
char *tmp = strdup(resolved_or_candidate);
if (resolved) free(resolved);
if (!tmp) return NULL;
char *dir = dirname(tmp);
char *out = realpath(dir, NULL);
if (!out) out = strdup(dir);
free(tmp);
return out;
}
static bool esm_split_package_specifier(
const char *specifier,
char *package_name,
size_t package_name_size,
const char **subpath_out
) {
if (!specifier || !specifier[0]) return false;
if (specifier[0] == '.' || specifier[0] == '/' || specifier[0] == '#') return false;
const char *slash = NULL;
if (specifier[0] == '@') {
const char *first = strchr(specifier, '/');
if (!first || first == specifier + 1) return false;
slash = strchr(first + 1, '/');
if (first[1] == '\0') return false;
if (!slash) {
if (strlen(specifier) >= package_name_size) return false;
strcpy(package_name, specifier);
*subpath_out = NULL;
return true;
}
} else slash = strchr(specifier, '/');
size_t name_len = slash ? (size_t)(slash - specifier) : strlen(specifier);
if (name_len == 0 || name_len >= package_name_size) return false;
memcpy(package_name, specifier, name_len);
package_name[name_len] = '\0';
if (slash && slash[1] != '\0') *subpath_out = slash + 1;
else *subpath_out = NULL;
return true;
}
static char *esm_find_node_module_dir(const char *start_dir, const char *package_name) {
if (!start_dir || !package_name) return NULL;
char current[PATH_MAX];
snprintf(current, sizeof(current), "%s", start_dir);
while (true) {
char candidate[PATH_MAX];
snprintf(candidate, sizeof(candidate), "%s/node_modules/%s", current, package_name);
struct stat st;
if (stat(candidate, &st) == 0 && S_ISDIR(st.st_mode)) {
char *resolved = realpath(candidate, NULL);
return resolved ? resolved : strdup(candidate);
}
if (strcmp(current, "/") == 0) break;
char *slash = strrchr(current, '/');
if (!slash) break;
if (slash == current) current[1] = '\0';
else *slash = '\0';
}
return NULL;
}
static bool esm_matches_pattern_key(const char *key, const char *request, const char **capture, size_t *capture_len) {
const char *star = strchr(key, '*');
if (!star) return false;
size_t key_len = strlen(key);
size_t req_len = strlen(request);
size_t prefix_len = (size_t)(star - key);
size_t suffix_len = key_len - prefix_len - 1;
if (req_len < prefix_len + suffix_len) return false;
if (strncmp(request, key, prefix_len) != 0) return false;
if (suffix_len > 0 && strcmp(request + req_len - suffix_len, star + 1) != 0) return false;
*capture = request + prefix_len;
*capture_len = req_len - prefix_len - suffix_len;
return true;
}
static char *esm_replace_star(const char *pattern, const char *capture, size_t capture_len) {
const char *star = strchr(pattern, '*');
if (!star) return strdup(pattern);
size_t prefix_len = (size_t)(star - pattern);
size_t suffix_len = strlen(star + 1);
size_t out_len = prefix_len + capture_len + suffix_len;
char *out = (char *)malloc(out_len + 1);
if (!out) return NULL;
memcpy(out, pattern, prefix_len);
memcpy(out + prefix_len, capture, capture_len);
memcpy(out + prefix_len + capture_len, star + 1, suffix_len);
out[out_len] = '\0';
return out;
}
static char *esm_resolve_exports_target(
yyjson_val *target,
const char *package_dir,
const char *capture,
size_t capture_len,
const char *base_path,
bool allow_bare_specifiers,
bool prefer_require
) {
if (!target) return NULL;
if (yyjson_is_str(target)) {
const char *target_str = yyjson_get_str(target);
if (!target_str || !target_str[0]) return NULL;
if (target_str[0] == '.' && target_str[1] == '/') {
char *mapped = esm_replace_star(target_str + 2, capture, capture_len);
if (!mapped) return NULL;
char *resolved = esm_try_resolve_with_exts(package_dir, mapped, esm_has_extension(mapped));
if (!resolved) resolved = esm_try_resolve_index_with_exts(package_dir, mapped);
free(mapped);
return resolved;
}
if (!allow_bare_specifiers) return NULL;
if (target_str[0] == '#') return NULL;
return esm_resolve_node_module(target_str, base_path);
}
if (yyjson_is_arr(target)) {
size_t idx, max;
yyjson_val *item;
yyjson_arr_foreach(target, idx, max, item) {
char *resolved = esm_resolve_exports_target(
item, package_dir, capture,
capture_len, base_path, allow_bare_specifiers, prefer_require
);
if (resolved) return resolved;
}
return NULL;
}
if (yyjson_is_obj(target)) {
static const char *const import_conditions[] = {"import", "node", "default"};
static const char *const require_conditions[] = {"require", "node", "default"};
const char *const *conditions = prefer_require
? require_conditions
: import_conditions;
size_t condition_count = prefer_require
? sizeof(require_conditions) / sizeof(require_conditions[0])
: sizeof(import_conditions) / sizeof(import_conditions[0]);
for (size_t i = 0; i < condition_count; i++) {
yyjson_val *cond_target = yyjson_obj_get(target, conditions[i]);
if (!cond_target) continue;
char *resolved = esm_resolve_exports_target(
cond_target, package_dir, capture,
capture_len, base_path, allow_bare_specifiers, prefer_require
);
if (resolved) return resolved;
}
}
return NULL;
}
static char *esm_resolve_package_map(
yyjson_val *map_obj,
const char *request_key,
const char *package_dir,
const char *base_path,
bool allow_bare_specifiers,
bool prefer_require
) {
if (!map_obj || !yyjson_is_obj(map_obj)) return NULL;
yyjson_val *exact = yyjson_obj_get(map_obj, request_key);
if (exact) return esm_resolve_exports_target(
exact, package_dir, "", 0,
base_path, allow_bare_specifiers, prefer_require
);
const char *best_capture = NULL;
size_t best_capture_len = 0;
yyjson_val *best_target = NULL;
size_t best_prefix_len = 0;
size_t idx, max;
yyjson_val *k, *v;
yyjson_obj_foreach(map_obj, idx, max, k, v) {
if (!yyjson_is_str(k)) continue;
const char *key = yyjson_get_str(k);
if (!key) continue;
const char *capture = NULL;
size_t capture_len = 0;
if (!esm_matches_pattern_key(key, request_key, &capture, &capture_len)) continue;
const char *star = strchr(key, '*');
size_t prefix_len = (size_t)(star - key);
if (best_target && prefix_len < best_prefix_len) continue;
best_target = v;
best_capture = capture;
best_capture_len = capture_len;
best_prefix_len = prefix_len;
}
if (!best_target) return NULL;
return esm_resolve_exports_target(
best_target, package_dir, best_capture,
best_capture_len, base_path, allow_bare_specifiers, prefer_require
);
}
static char *esm_resolve_package_main_entry(yyjson_val *root, const char *package_dir) {
if (!root || !yyjson_is_obj(root)) return NULL;
yyjson_val *main = yyjson_obj_get(root, "main");
if (!main || !yyjson_is_str(main)) return NULL;
const char *main_str = yyjson_get_str(main);
if (!main_str || !main_str[0]) return NULL;
char *resolved = esm_try_resolve_with_exts(package_dir, main_str, esm_has_extension(main_str));
if (!resolved) resolved = esm_try_resolve_index_with_exts(package_dir, main_str);
return resolved;
}
static char *esm_resolve_package_entrypoint(const char *package_dir, const char *subpath, const char *base_path, bool prefer_require) {
char pkg_json_path[PATH_MAX];
snprintf(pkg_json_path, sizeof(pkg_json_path), "%s/package.json", package_dir);
yyjson_doc *doc = yyjson_read_file(pkg_json_path, 0, NULL, NULL);
yyjson_val *root = doc ? yyjson_doc_get_root(doc) : NULL;
yyjson_val *exports = (root && yyjson_is_obj(root)) ? yyjson_obj_get(root, "exports") : NULL;
if (exports) {
char subpath_key[PATH_MAX];
if (subpath && subpath[0]) snprintf(subpath_key, sizeof(subpath_key), "./%s", subpath);
else snprintf(subpath_key, sizeof(subpath_key), ".");
char *resolved = NULL;
if (yyjson_is_obj(exports)) {
bool has_subpath_keys = false;
size_t idx, max;
yyjson_val *k, *v;
yyjson_obj_foreach(exports, idx, max, k, v) {
if (!yyjson_is_str(k)) continue;
const char *key = yyjson_get_str(k);
if (key && key[0] == '.') { has_subpath_keys = true; break; }
}
if (has_subpath_keys) resolved = esm_resolve_package_map(exports, subpath_key, package_dir, base_path, false, prefer_require);
else if (!subpath || !subpath[0]) resolved = esm_resolve_exports_target(exports, package_dir, "", 0, base_path, false, prefer_require);
} else if (!subpath || !subpath[0]) resolved = esm_resolve_exports_target(exports, package_dir, "", 0, base_path, false, prefer_require);
if (doc) yyjson_doc_free(doc);
return resolved;
}
if (!subpath || !subpath[0]) {
char *resolved = esm_resolve_package_main_entry(root, package_dir);
if (resolved) {
if (doc) yyjson_doc_free(doc);
return resolved;
}
if (doc) yyjson_doc_free(doc);
return esm_try_resolve_index_with_exts(package_dir, ".");
}
char *resolved = esm_try_resolve_with_exts(package_dir, subpath, esm_has_extension(subpath));
if (!resolved) resolved = esm_try_resolve_index_with_exts(package_dir, subpath);
if (doc) yyjson_doc_free(doc);
return resolved;
}
static char *esm_resolve_package_imports(const char *specifier, const char *base_path, bool prefer_require) {
char *start_dir = esm_get_base_dir(base_path);
if (!start_dir) return NULL;
char current[PATH_MAX];
snprintf(current, sizeof(current), "%s", start_dir);
free(start_dir);
while (true) {
char pkg_json_path[PATH_MAX];
snprintf(pkg_json_path, sizeof(pkg_json_path), "%s/package.json", current);
yyjson_doc *doc = yyjson_read_file(pkg_json_path, 0, NULL, NULL);
if (doc) {
yyjson_val *root = yyjson_doc_get_root(doc);
yyjson_val *imports = (root && yyjson_is_obj(root)) ? yyjson_obj_get(root, "imports") : NULL;
char *resolved = NULL;
if (imports && yyjson_is_obj(imports)) {
resolved = esm_resolve_package_map(
imports, specifier, current,
base_path, true, prefer_require
);
}
yyjson_doc_free(doc);
return resolved;
}
if (strcmp(current, "/") == 0) break;
char *slash = strrchr(current, '/');
if (!slash) break;
if (slash == current) current[1] = '\0';
else *slash = '\0';
}
return NULL;
}
static char *esm_resolve_node_module_cond(const char *specifier, const char *base_path, bool prefer_require) {
char package_name[PATH_MAX];
const char *subpath = NULL;
if (!esm_split_package_specifier(specifier, package_name, sizeof(package_name), &subpath)) {
return NULL;
}
char *start_dir = esm_get_base_dir(base_path);
if (!start_dir) return NULL;
char *package_dir = esm_find_node_module_dir(start_dir, package_name);
free(start_dir);
if (!package_dir) return NULL;
char *resolved = esm_resolve_package_entrypoint(package_dir, subpath, base_path, prefer_require);
free(package_dir);
return resolved;
}
static char *esm_resolve_node_module(const char *specifier, const char *base_path) {
return esm_resolve_node_module_cond(specifier, base_path, false);
}
static char *esm_resolve_relative_path(const char *specifier, const char *base_path) {
char *base_copy = strdup(base_path);
if (!base_copy) return NULL;
char *dir = dirname(base_copy);
char *result = NULL;
const char *spec = specifier;
if (strncmp(specifier, "./", 2) == 0) spec = specifier + 2;
bool has_ext = esm_has_extension(spec);
if ((result = esm_try_resolve(dir, spec, ""))) goto cleanup;
if (has_ext) {
result = esm_try_resolve_relative_typescript_source_fallback(dir, spec, base_path);
goto cleanup;
}
char *base_ext = esm_get_extension(base_path);
if (!base_ext) goto cleanup;
if ((result = esm_try_resolve_from_extension_list(dir, spec, base_ext, base_ext))) goto cleanup_ext;
char idx[PATH_MAX];
snprintf(idx, sizeof(idx), "%s/index%s", spec, base_ext);
if ((result = esm_try_resolve(dir, idx, ""))) goto cleanup_ext;
snprintf(idx, sizeof(idx), "%s/index", spec);
if ((result = esm_try_resolve_from_extension_list(dir, idx, base_ext, base_ext))) goto cleanup_ext;
cleanup_ext: {
free(base_ext);
}
cleanup: {
free(base_copy);
return result;
}
}
static char *esm_resolve_path_cond(const char *specifier, const char *base_path, bool prefer_require) {
if (!specifier || !specifier[0]) return NULL;
if (specifier[0] == '/') {
return esm_resolve_absolute(specifier);
}
if (esm_is_relative_specifier(specifier)) {
return esm_resolve_relative_path(specifier, base_path);
}
if (specifier[0] == '#') {
return esm_resolve_package_imports(specifier, base_path, prefer_require);
}
return esm_resolve_node_module_cond(specifier, base_path, prefer_require);
}
static char *esm_resolve_path(const char *specifier, const char *base_path) {
return esm_resolve_path_cond(specifier, base_path, false);
}
static char *esm_resolve_path_require(const char *specifier, const char *base_path) {
return esm_resolve_path_cond(specifier, base_path, true);
}
static bool esm_has_suffix(const char *path, const char *ext) {
size_t len = strlen(path);
size_t elen = strlen(ext);
return len > elen && strcmp(path + len - elen, ext) == 0;
}
static inline bool esm_is_json(const char *path) {
return esm_has_suffix(path, ".json");
}
static inline bool esm_is_text(const char *path) {
return
esm_has_suffix(path, ".txt") ||
esm_has_suffix(path, ".md") ||
esm_has_suffix(path, ".html") ||
esm_has_suffix(path, ".css");
}
static inline bool esm_is_image(const char *path) {
return
esm_has_suffix(path, ".png") ||
esm_has_suffix(path, ".jpg") ||
esm_has_suffix(path, ".jpeg") ||
esm_has_suffix(path, ".gif") ||
esm_has_suffix(path, ".svg") ||
esm_has_suffix(path, ".webp");
}
static inline bool esm_is_native(const char *path) {
return esm_has_suffix(path, ".node");
}
static inline bool esm_is_cjs_extension(const char *path) {
return
esm_has_suffix(path, ".cjs") ||
esm_has_suffix(path, ".cts");
}
static inline bool esm_is_esm_extension(const char *path) {
return
esm_has_suffix(path, ".mjs") ||
esm_has_suffix(path, ".mts");
}
static bool esm_path_contains_node_modules(const char *path) {
if (!path) return false;
if (strstr(path, "/node_modules/")) return true;
return strstr(path, "\\node_modules\\") != NULL;
}
static bool esm_read_package_json_type_module(const char *pkg_json_path, bool *has_type) {
if (has_type) *has_type = false;
yyjson_doc *doc = yyjson_read_file(pkg_json_path, 0, NULL, NULL);
if (!doc) return false;
yyjson_val *root = yyjson_doc_get_root(doc);
yyjson_val *type = (root && yyjson_is_obj(root)) ? yyjson_obj_get(root, "type") : NULL;
if (!type || !yyjson_is_str(type)) {
yyjson_doc_free(doc);
return false;
}
const char *type_str = yyjson_get_str(type);
if (has_type) *has_type = true;
bool is_module = type_str && strcmp(type_str, "module") == 0;
yyjson_doc_free(doc);
return is_module;
}
static bool esm_lookup_package_type_module(const char *resolved_path, bool *is_module) {
if (is_module) *is_module = false;
if (!resolved_path || !resolved_path[0]) return false;
char path_copy[PATH_MAX];
snprintf(path_copy, sizeof(path_copy), "%s", resolved_path);
char *dir = dirname(path_copy);
if (!dir || !dir[0]) return false;
char current[PATH_MAX];
snprintf(current, sizeof(current), "%s", dir);
while (true) {
char pkg_json_path[PATH_MAX];
snprintf(pkg_json_path, sizeof(pkg_json_path), "%s/package.json", current);
struct stat st;
if (stat(pkg_json_path, &st) == 0 && S_ISREG(st.st_mode)) {
bool has_type = false;
bool pkg_is_module = esm_read_package_json_type_module(pkg_json_path, &has_type);
if (is_module) *is_module = has_type && pkg_is_module;
return true;
}
if (strcmp(current, "/") == 0) break;
char *slash = strrchr(current, '/');
if (!slash) break;
if (slash == current) current[1] = '\0';
else *slash = '\0';
}
return false;
}
static ant_module_format_t esm_decide_module_format(const char *resolved_path) {
if (!resolved_path || !resolved_path[0]) return MODULE_EVAL_FORMAT_ESM;
if (esm_is_cjs_extension(resolved_path)) return MODULE_EVAL_FORMAT_CJS;
if (esm_is_esm_extension(resolved_path)) return MODULE_EVAL_FORMAT_ESM;
if (esm_has_suffix(resolved_path, ".js")) {
bool pkg_is_module = false;
bool has_package_json = esm_lookup_package_type_module(resolved_path, &pkg_is_module);
if (!has_package_json) return MODULE_EVAL_FORMAT_CJS;
return pkg_is_module ? MODULE_EVAL_FORMAT_ESM : MODULE_EVAL_FORMAT_CJS;
}
return MODULE_EVAL_FORMAT_ESM;
}
static ant_value_t esm_eval_module_with_format(
ant_t *js,
const char *resolved_path,
const char *js_code,
size_t js_len,
ant_value_t ns,
ant_module_format_t format
) {
if (format == MODULE_EVAL_FORMAT_CJS) {
return esm_load_commonjs_module(js, resolved_path, js_code, js_len, ns);
}
return js_eval_bytecode_module(js, js_code, js_len);
}
ant_value_t js_esm_eval_module_source(
ant_t *js,
const char *resolved_path, const char *js_code,
size_t js_len, ant_value_t ns
) {
ant_module_format_t format = esm_decide_module_format(resolved_path);
ant_module_t eval_ctx;
ant_value_t prep_res = esm_prepare_eval_ctx(
js, resolved_path, ns, format,
js->module == NULL, NULL, &eval_ctx
);
if (is_err(prep_res)) return prep_res;
js_module_eval_ctx_push(js, &eval_ctx);
ant_value_t result = esm_eval_module_with_format(
js, resolved_path, js_code,
js_len, ns, format
);
js_module_eval_ctx_pop(js, &eval_ctx);
return result;
}
static esm_module_kind_t esm_classify_module_kind(const char *resolved_path) {
if (esm_is_data_url(resolved_path)) return ESM_MODULE_KIND_URL;
if (esm_is_url(resolved_path)) return ESM_MODULE_KIND_URL;
if (esm_is_json(resolved_path)) return ESM_MODULE_KIND_JSON;
if (esm_is_text(resolved_path)) return ESM_MODULE_KIND_TEXT;
if (esm_is_image(resolved_path)) return ESM_MODULE_KIND_IMAGE;
if (esm_is_native(resolved_path)) return ESM_MODULE_KIND_NATIVE;
return ESM_MODULE_KIND_CODE;
}
static char *esm_canonicalize_path(const char *path) {
if (!path) return NULL;
char *canonical = strdup(path);
if (!canonical) return NULL;
char *src = canonical, *dst = canonical;
while (*src) {
if (*src == '/') {
*dst++ = '/';
while (*src == '/') src++;
if (strncmp(src, "./", 2) == 0) {
src += 2;
} else if (strncmp(src, "../", 3) == 0) {
src += 3;
if (dst > canonical + 1) {
dst--;
while (dst > canonical && *(dst - 1) != '/') dst--;
}
}
} else {
*dst++ = *src++;
}
}
*dst = '\0';
if (strlen(canonical) > 1 && canonical[strlen(canonical) - 1] == '/') {
canonical[strlen(canonical) - 1] = '\0';
}
return canonical;
}
static esm_module_t *esm_find_module(const char *module_key) {
char *cache_key = esm_make_cache_key(module_key);
if (!cache_key) return NULL;
esm_module_t *mod = NULL;
HASH_FIND_STR(global_module_cache.modules, cache_key, mod);
free(cache_key);
return mod;
}
static esm_module_t *esm_create_module(
const char *path,
const char *resolved_path,
const char *module_key,
ant_module_format_t format,
const uint8_t *embedded_code,
size_t embedded_code_len
) {
char *cache_key = esm_make_cache_key(module_key);
if (!cache_key) return NULL;
esm_module_t *existing_mod = NULL;
HASH_FIND_STR(global_module_cache.modules, cache_key, existing_mod);
if (existing_mod) {
free(cache_key);
return existing_mod;
}
esm_module_t *mod = (esm_module_t *)malloc(sizeof(esm_module_t));
if (!mod) {
free(cache_key);
return NULL;
}
*mod = (esm_module_t){
.path = strdup(path),
.cache_key = cache_key,
.resolved_path = strdup(resolved_path),
.namespace_obj = js_mkundef(),
.default_export = js_mkundef(),
.is_loaded = false,
.is_loading = false,
.kind = esm_classify_module_kind(resolved_path),
.format = format,
.url_content = NULL,
.url_content_len = 0,
.embedded_code = embedded_code,
.embedded_code_len = embedded_code_len,
.tla_promise = js_mkundef(),
.has_tla = false,
};
if (!mod->path || !mod->resolved_path) {
free(mod->path);
free(mod->cache_key);
free(mod->resolved_path);
free(mod);
return NULL;
}
HASH_ADD_STR(global_module_cache.modules, cache_key, mod);
global_module_cache.count++;
return mod;
}
void js_esm_cleanup_module_cache(void) {
esm_module_t *current, *tmp;
HASH_ITER(hh, global_module_cache.modules, current, tmp) {
HASH_DEL(global_module_cache.modules, current);
if (current->path) free(current->path);
if (current->cache_key) free(current->cache_key);
if (current->resolved_path) free(current->resolved_path);
if (current->url_content) free(current->url_content);
free(current);
}
global_module_cache.count = 0;
}
static ant_value_t esm_read_file(ant_t *js, const char *path, const char *kind, esm_file_data_t *out) {
FILE *fp = fopen(path, "rb");
if (!fp) return js_mkerr(js, "Cannot open %s: %s", kind, path);
fseek(fp, 0, SEEK_END);
long fsize = ftell(fp);
fseek(fp, 0, SEEK_SET);
char *buf = (char *)malloc((size_t)fsize + 1);
if (!buf) {
fclose(fp);
return js_mkerr(js, "OOM loading %s", kind);
}
fread(buf, 1, (size_t)fsize, fp);
fclose(fp);
buf[fsize] = '\0';
out->data = buf;
out->size = (size_t)fsize;
return js_mkundef();
}
static ant_value_t esm_load_json(ant_t *js, const char *path) {
esm_file_data_t file;
ant_value_t err = esm_read_file(js, path, "JSON file", &file);
if (is_err(err)) return err;
ant_value_t json_str = js_mkstr(js, file.data, file.size);
free(file.data);
return json_parse_value(js, json_str);
}
static ant_value_t esm_load_text(ant_t *js, const char *path) {
esm_file_data_t file;
ant_value_t err = esm_read_file(js, path, "text file", &file);
if (is_err(err)) return err;
ant_value_t result = js_mkstr(js, file.data, file.size);
free(file.data);
return result;
}
static ant_value_t esm_load_image(ant_t *js, const char *path) {
esm_file_data_t file;
ant_value_t err = esm_read_file(js, path, "image file", &file);
if (is_err(err)) return err;
unsigned char *content = (unsigned char *)file.data;
size_t size = file.size;
ant_value_t obj = js_mkobj(js);
ant_value_t data_arr = js_mkarr(js);
for (size_t i = 0; i < size; i++) {
js_arr_push(js, data_arr, tov((double)content[i]));
}
js_setprop(js, obj, js_mkstr(js, "data", 4), data_arr);
js_setprop(js, obj, js_mkstr(js, "path", 4), js_mkstr(js, path, strlen(path)));
js_setprop(js, obj, js_mkstr(js, "size", 4), tov((double)size));
free(file.data);
return obj;
}
static ant_value_t esm_load_module(ant_t *js, esm_module_t *mod) {
if (mod->is_loaded) return mod->namespace_obj;
if (mod->is_loading) return mod->namespace_obj;
mod->is_loading = true;
switch (mod->kind) {
case ESM_MODULE_KIND_JSON: {
ant_value_t json_val = esm_load_json(js, mod->resolved_path);
return esm_complete_value_module(mod, json_val);
}
case ESM_MODULE_KIND_TEXT: {
ant_value_t text_val = esm_load_text(js, mod->resolved_path);
return esm_complete_value_module(mod, text_val);
}
case ESM_MODULE_KIND_IMAGE: {
ant_value_t img_val = esm_load_image(js, mod->resolved_path);
return esm_complete_value_module(mod, img_val);
}
case ESM_MODULE_KIND_NATIVE: {
ant_value_t ns = esm_make_namespace_object(js);
mod->namespace_obj = ns;
ant_value_t module_ctx = js_create_module_context(js, mod->resolved_path, false);
if (is_err(module_ctx)) {
mod->is_loading = false;
return module_ctx;
}
js_set_slot_wb(js, ns, SLOT_MODULE_CTX, module_ctx);
ant_value_t native_exports = napi_load_native_module(js, mod->resolved_path, ns);
if (is_err(native_exports)) {
mod->is_loading = false;
return native_exports;
}
return esm_complete_namespace_module(js, mod, ns);
}
case ESM_MODULE_KIND_CODE:
case ESM_MODULE_KIND_URL: break;
}
char *content = NULL;
size_t size = 0;
if (mod->embedded_code) {
content = (char *)malloc(mod->embedded_code_len + 1);
if (!content) {
mod->is_loading = false;
return js_mkerr(js, "OOM loading bundled module");
}
memcpy(content, mod->embedded_code, mod->embedded_code_len);
size = mod->embedded_code_len;
} else if (mod->kind == ESM_MODULE_KIND_URL && esm_is_data_url(mod->resolved_path)) {
content = esm_parse_data_url(mod->resolved_path, &size);
if (!content) {
mod->is_loading = false;
return js_mkerr(js, "Cannot parse data URL module");
}
} else if (mod->kind == ESM_MODULE_KIND_URL) {
if (mod->url_content) {
content = strdup(mod->url_content);
size = mod->url_content_len;
} else {
char *error = NULL;
content = esm_fetch_url(mod->resolved_path, &size, &error);
if (!content) {
mod->is_loading = false;
ant_value_t err = js_mkerr(js, "Cannot fetch module %s: %s", mod->resolved_path, error ? error : "unknown error");
if (error) free(error);
return err;
}
mod->url_content = strdup(content);
mod->url_content_len = size;
}
} else {
esm_file_data_t file;
ant_value_t err = esm_read_file(js, mod->resolved_path, "module", &file);
if (is_err(err)) {
mod->is_loading = false;
return err;
}
content = file.data;
size = file.size;
}
content[size] = '\0';
size_t js_len = size;
const char *strip_detail = NULL;
if (!mod->embedded_code) {
int strip_result = strip_typescript_inplace(
&content, size, mod->resolved_path,
mod->format != MODULE_EVAL_FORMAT_CJS,
&js_len, &strip_detail
);
if (strip_result < 0) {
ant_value_t err = js_mkerr(
js, "TypeScript error: strip failed (%d): %s",
strip_result, strip_detail
);
free(content);
mod->is_loading = false;
return err;
}}
char *js_code = content;
ant_value_t ns = esm_make_namespace_object(js);
mod->namespace_obj = ns;
const char *prev_filename = js->filename;
ant_module_t eval_ctx;
ant_value_t prep_res = esm_prepare_eval_ctx(
js, mod->resolved_path,
ns, mod->format,
false, prev_filename,
&eval_ctx
);
if (is_err(prep_res)) {
free(content);
mod->is_loading = false;
return prep_res;
}
js_set_filename(js, mod->resolved_path);
js_module_eval_ctx_push(js, &eval_ctx);
if (mod->format == MODULE_EVAL_FORMAT_UNKNOWN) {
mod->format = esm_decide_module_format(mod->resolved_path);
eval_ctx.format = mod->format;
}
ant_value_t result = esm_eval_module_with_format(
js, mod->resolved_path, js_code, js_len, ns, mod->format
);
free(content);
if (vtype(result) == T_PROMISE) {
if (esm_dynamic_import_depth > 0) {
mod->has_tla = true;
mod->tla_promise = result;
} else js_run_event_loop(js); }
js_module_eval_ctx_pop(js, &eval_ctx);
js_set_filename(js, prev_filename);
if (is_err(result)) {
mod->is_loading = false;
return result;
}
return esm_complete_namespace_module(js, mod, ns);
}
static ant_value_t esm_get_or_load(
ant_t *js,
const char *specifier,
const char *resolved_path,
const char *module_key,
ant_module_format_t format,
const uint8_t *embedded_code,
size_t embedded_code_len
) {
esm_module_t *mod = esm_find_module(module_key);
if (!mod) {
mod = esm_create_module(
specifier,
resolved_path,
module_key,
format,
embedded_code,
embedded_code_len
);
if (!mod) return js_mkerr(js, "Cannot create module");
}
return esm_load_module(js, mod);
}
static const char *esm_default_base_path(ant_t *js) {
const char *active = js_module_eval_active_filename(js);
return (active && active[0]) ? active : ".";
}
ant_value_t js_esm_import_sync_cstr_from(
ant_t *js,
const char *specifier,
size_t spec_len,
const char *base_path
) {
const ant_builtin_bundle_alias_t *bundle = NULL;
const ant_builtin_bundle_module_t *module = NULL;
char *spec_copy = strndup(specifier, spec_len);
if (!spec_copy) return js_mkerr(js, "oom");
char *file_url_path = esm_file_url_to_path(js, spec_copy);
if (file_url_path) {
free(spec_copy);
spec_copy = file_url_path;
spec_len = strlen(spec_copy);
}
bundle = esm_lookup_builtin_alias(spec_copy, spec_len);
if (bundle) {
module = esm_lookup_builtin_module(bundle->module_id);
if (!module) {
free(spec_copy);
return js_mkerr(js, "Invalid builtin module id");
}
ant_value_t ns = esm_get_or_load(
js, spec_copy,
bundle->source_name,
bundle->source_name,
module->format,
module->code,
module->code_len
);
free(spec_copy);
return ns;
}
bool loaded = false;
ant_value_t lib = js_esm_load_registered_library(js, spec_copy, spec_len, &loaded);
if (loaded) {
free(spec_copy);
return lib;
}
if (!base_path || !base_path[0]) base_path = esm_default_base_path(js);
char *resolved_path = esm_resolve(spec_copy, base_path, esm_resolve_path);
if (!resolved_path) {
ant_value_t err = js_mkerr(js, "Cannot resolve module: %s", spec_copy);
free(spec_copy);
return err;
}
ant_value_t ns = esm_get_or_load(
js,
spec_copy,
resolved_path,
resolved_path,
MODULE_EVAL_FORMAT_UNKNOWN,
NULL,
0
);
free(resolved_path);
free(spec_copy);
return ns;
}
ant_value_t js_esm_import_sync_cstr_from_require(
ant_t *js,
const char *specifier,
size_t spec_len,
const char *base_path
) {
const ant_builtin_bundle_alias_t *bundle = NULL;
const ant_builtin_bundle_module_t *module = NULL;
char *spec_copy = strndup(specifier, spec_len);
if (!spec_copy) return js_mkerr(js, "oom");
char *file_url_path = esm_file_url_to_path(js, spec_copy);
if (file_url_path) {
free(spec_copy);
spec_copy = file_url_path;
spec_len = strlen(spec_copy);
}
bundle = esm_lookup_builtin_alias(spec_copy, spec_len);
if (bundle) {
module = esm_lookup_builtin_module(bundle->module_id);
if (!module) {
free(spec_copy);
return js_mkerr(js, "Invalid builtin module id");
}
ant_value_t ns = esm_get_or_load(
js, spec_copy,
bundle->source_name,
bundle->source_name,
module->format,
module->code,
module->code_len
);
free(spec_copy);
return ns;
}
bool loaded = false;
ant_value_t lib = js_esm_load_registered_library(js, spec_copy, spec_len, &loaded);
if (loaded) {
free(spec_copy);
return lib;
}
if (!base_path || !base_path[0]) base_path = esm_default_base_path(js);
char *resolved_path = esm_resolve(spec_copy, base_path, esm_resolve_path_require);
if (!resolved_path) {
ant_value_t err = js_mkerr(js, "Cannot resolve module: %s", spec_copy);
free(spec_copy);
return err;
}
ant_value_t ns = esm_get_or_load(
js, spec_copy,
resolved_path,
resolved_path,
MODULE_EVAL_FORMAT_UNKNOWN,
NULL, 0
);
free(resolved_path);
free(spec_copy);
return ns;
}
ant_value_t js_esm_import_sync_cstr(ant_t *js, const char *specifier, size_t spec_len) {
return js_esm_import_sync_cstr_from(js, specifier, spec_len, NULL);
}
ant_value_t js_esm_import_sync_from(ant_t *js, ant_value_t specifier, const char *base_path) {
if (vtype(specifier) != T_STR)
return js_mkerr(js, "import() requires a string specifier");
ant_offset_t spec_len = 0;
ant_offset_t spec_off = vstr(js, specifier, &spec_len);
const char *spec_str = (const char *)(uintptr_t)(spec_off);
return js_esm_import_sync_cstr_from(js, spec_str, (size_t)spec_len, base_path);
}
ant_value_t js_esm_import_sync_from_require(ant_t *js, ant_value_t specifier, const char *base_path) {
if (vtype(specifier) != T_STR)
return js_mkerr(js, "require() expects a string specifier");
ant_offset_t spec_len = 0;
ant_offset_t spec_off = vstr(js, specifier, &spec_len);
const char *spec_str = (const char *)(uintptr_t)(spec_off);
return js_esm_import_sync_cstr_from_require(js, spec_str, (size_t)spec_len, base_path);
}
ant_value_t js_esm_import_sync(ant_t *js, ant_value_t specifier) {
return js_esm_import_sync_from(js, specifier, NULL);
}
ant_value_t js_esm_import_dynamic(ant_t *js, ant_value_t specifier, const char *base_path, ant_value_t *out_tla_promise) {
*out_tla_promise = js_mkundef();
esm_dynamic_import_depth++;
ant_value_t ns = js_esm_import_sync_from(js, specifier, base_path);
esm_dynamic_import_depth--;
if (is_err(ns)) return ns;
esm_module_t *mod = NULL, *tmp = NULL;
HASH_ITER(hh, global_module_cache.modules, mod, tmp) {
if (mod->has_tla && mod->namespace_obj == ns) {
*out_tla_promise = mod->tla_promise;
mod->has_tla = false;
mod->tla_promise = js_mkundef();
break;
}}
return ns;
}
ant_value_t js_esm_make_file_url(ant_t *js, const char *path) {
size_t path_len = strlen(path);
size_t raw_len = 7 + path_len;
char *raw = malloc(raw_len + 1);
if (!raw) return js_mkerr(js, "oom");
snprintf(raw, raw_len + 1, "file://%s", path);
ant_value_t raw_val = js_mkstr(js, raw, raw_len);
free(raw);
return js_encodeURI(js, &raw_val, 1);
}
void gc_mark_esm(ant_t *js, gc_mark_fn mark) {
esm_module_t *mod = NULL, *tmp = NULL;
HASH_ITER(hh, global_module_cache.modules, mod, tmp) {
mark(js, mod->namespace_obj);
mark(js, mod->default_export);
if (mod->has_tla) mark(js, mod->tla_promise);
}}
ant_value_t js_esm_resolve_specifier(ant_t *js, ant_value_t specifier, const char *base_path) {
const ant_builtin_bundle_alias_t *bundle = NULL;
if (vtype(specifier) != T_STR) {
return js_mkerr(js, "import.meta.resolve() requires a string specifier");
}
ant_offset_t spec_len = 0;
ant_offset_t spec_off = vstr(js, specifier, &spec_len);
const char *spec_str = (const char *)(uintptr_t)(spec_off);
char *spec_copy = strndup(spec_str, (size_t)spec_len);
if (!spec_copy) return js_mkerr(js, "oom");
bundle = esm_lookup_builtin_alias(spec_copy, (size_t)spec_len);
if (bundle) {
ant_value_t result = js_mkstr(js, bundle->source_name, strlen(bundle->source_name));
free(spec_copy);
return result;
}
if (!base_path || !base_path[0]) base_path = esm_default_base_path(js);
char *resolved_path = esm_resolve(spec_copy, base_path, esm_resolve_path);
free(spec_copy);
if (!resolved_path) {
return js_mkerr(js, "Cannot resolve module");
}
if (esm_is_url(resolved_path)) {
ant_value_t result = js_mkstr(js, resolved_path, strlen(resolved_path));
free(resolved_path);
return result;
}
ant_value_t result = js_esm_make_file_url(js, resolved_path);
free(resolved_path);
return result;
}
ant_value_t js_esm_resolve_specifier_require(ant_t *js, ant_value_t specifier, const char *base_path) {
const ant_builtin_bundle_alias_t *bundle = NULL;
if (vtype(specifier) != T_STR) {
return js_mkerr(js, "require.resolve() expects a string specifier");
}
ant_offset_t spec_len = 0;
ant_offset_t spec_off = vstr(js, specifier, &spec_len);
const char *spec_str = (const char *)(uintptr_t)(spec_off);
char *spec_copy = strndup(spec_str, (size_t)spec_len);
if (!spec_copy) return js_mkerr(js, "oom");
bundle = esm_lookup_builtin_alias(spec_copy, (size_t)spec_len);
if (bundle) {
ant_value_t result = js_mkstr(js, bundle->source_name, strlen(bundle->source_name));
free(spec_copy);
return result;
}
if (!base_path || !base_path[0]) base_path = esm_default_base_path(js);
char *resolved_path = esm_resolve(spec_copy, base_path, esm_resolve_path_require);
free(spec_copy);
if (!resolved_path) {
return js_mkerr(js, "Cannot resolve module");
}
if (esm_is_url(resolved_path)) {
ant_value_t result = js_mkstr(js, resolved_path, strlen(resolved_path));
free(resolved_path);
return result;
}
ant_value_t result = js_esm_make_file_url(js, resolved_path);
free(resolved_path);
return result;
}

Owner Packages

  • No Owners