// fe-web.js — Fe documentation web components bundle
// Usage:
// ============================================================================
// Script-tag loader: reads data-src and data-docs, fetches JSON, populates globals
// ============================================================================
(function() {
"use strict";
var script = document.currentScript || document.querySelector('script[data-src]');
if (!script) return;
var dataSrc = script.getAttribute('data-src');
var dataDocs = script.getAttribute('data-docs');
if (dataDocs) {
window.FE_DOCS_BASE = dataDocs;
}
// Signal that the bundle is loading
window.FE_WEB_READY = new Promise(function(resolve) {
window._feWebResolve = resolve;
});
if (dataSrc) {
(typeof feFetchJson === 'function' ? feFetchJson(dataSrc) :
fetch(dataSrc).then(function(r) {
if (!r.ok) throw new Error("HTTP " + r.status + " loading " + dataSrc);
return r.json();
}))
.then(function(data) {
data = feMigrate(data);
if (data && data.index) {
window.FE_DOC_INDEX = data.index;
if (data.scip) {
window.FE_SCIP_DATA = data.scip;
if (typeof ScipStore !== 'undefined') {
try { window.FE_SCIP = new ScipStore(data.scip); } catch(e) {
console.error('[fe-web] ScipStore init failed:', e);
}
}
}
} else if (data) {
// Fallback — should not happen after migration
window.FE_DOC_INDEX = data;
}
window._feWebResolve();
document.dispatchEvent(new CustomEvent('fe-web-ready'));
})
.catch(function(err) {
console.error('[fe-web] Failed to load', dataSrc, err);
window._feWebResolve();
});
} else {
// No data-src — globals may already be set (e.g. static site)
window._feWebResolve();
}
})();
// ============================================================================
// ScipStore
// ============================================================================
// ScipStore — Pure-JS symbol index built from pre-processed SCIP JSON.
//
// The server (Rust) converts the SCIP protobuf into a compact JSON object
// with two keys:
// symbols: { [scip_symbol]: { name, kind, docs?, enclosing?, doc_url? } }
// files: { [path]: [ { line, cs, ce, sym, def? }, ... ] }
//
// Usage:
// window.FE_SCIP = new ScipStore(window.FE_SCIP_DATA);
// SCIP symbol hover highlighting.
// Colors come from CSS custom properties (--hl-ref-bg, --hl-def-bg,
// --hl-def-underline) defined in :root so they stay in sync with the theme.
// Setting element.style.* directly lets the CSS transition on [class*="sym-"]
// interpolate between transparent ↔ colored.
var _defaultHighlightHash = null;
var _activeHighlightHash = null;
// Read highlight colors from CSS custom properties, with fallbacks.
function _hlColor(prop, fallback) {
var v = getComputedStyle(document.documentElement).getPropertyValue(prop);
return v && v.trim() ? v.trim() : fallback;
}
function feHighlight(symHash) {
if (_activeHighlightHash && _activeHighlightHash !== symHash) {
_setHighlightStyles(_activeHighlightHash, false);
}
_activeHighlightHash = symHash;
if (symHash) _setHighlightStyles(symHash, true);
}
function _applyHighlightTo(root, symHash, refBg, defBg, defUl, on) {
var all = root.querySelectorAll(".sym-" + symHash);
var defs = root.querySelectorAll(".sym-d-" + symHash);
for (var i = 0; i < all.length; i++) {
all[i].style.background = refBg;
all[i].style.borderRadius = on ? "2px" : "";
}
for (var j = 0; j < defs.length; j++) {
defs[j].style.background = defBg;
defs[j].style.textDecoration = on ? "underline" : "";
defs[j].style.textDecorationColor = defUl;
defs[j].style.textUnderlineOffset = on ? "2px" : "";
}
}
function _setHighlightStyles(symHash, on) {
var refBg = on ? _hlColor("--hl-ref-bg", "rgba(99,102,241,0.10)") : "";
var defBg = on ? _hlColor("--hl-def-bg", "rgba(99,102,241,0.18)") : "";
var defUl = on ? _hlColor("--hl-def-underline", "rgba(99,102,241,0.5)") : "";
// Search light DOM
_applyHighlightTo(document, symHash, refBg, defBg, defUl, on);
// Search shadow roots of code blocks
var blocks = document.querySelectorAll("fe-code-block");
for (var i = 0; i < blocks.length; i++) {
if (blocks[i].shadowRoot) {
_applyHighlightTo(blocks[i].shadowRoot, symHash, refBg, defBg, defUl, on);
}
}
}
function feUnhighlight() {
if (_activeHighlightHash) {
_setHighlightStyles(_activeHighlightHash, false);
_activeHighlightHash = null;
}
if (_defaultHighlightHash) {
feHighlight(_defaultHighlightHash);
}
}
// Set the ambient/default symbol highlight for the current page.
// feUnhighlight() restores this instead of fully clearing.
function feSetDefaultHighlight(symHash) {
_defaultHighlightHash = symHash;
if (symHash) feHighlight(symHash);
}
function feClearDefaultHighlight() {
_defaultHighlightHash = null;
feUnhighlight();
}
// ============================================================================
// Schema migration — normalizes old docs.json to the current format.
// When SCHEMA_VERSION is bumped in model.rs, add a migration case here
// and update FE_CURRENT_SCHEMA to match.
// ============================================================================
var FE_CURRENT_SCHEMA = 2;
function feMigrate(data) {
if (!data) return data;
var v = (data.schema_version != null) ? data.schema_version : 0;
// Bare DocIndex (no envelope) — wrap it
if (v === 0 && !data.index && data.items) {
data = { schema_version: 0, index: data, scip: null };
}
if (v > FE_CURRENT_SCHEMA) {
console.warn("[fe-web] docs.json schema v" + v + " > viewer v" + FE_CURRENT_SCHEMA);
return data;
}
if (v === FE_CURRENT_SCHEMA) return data;
if (v < 1) {
// v0 → v1: envelope normalization only, no field changes
data.schema_version = 1;
}
return data;
}
// ============================================================================
// ScipStore
// ============================================================================
function ScipStore(data) {
this._symbols = data.symbols || {};
this._files = data.files || {};
// Build name → [symbol] index for search
this._byName = {};
var syms = this._symbols;
for (var sym in syms) {
if (!syms.hasOwnProperty(sym)) continue;
var name = syms[sym].name || "";
var lower = name.toLowerCase();
if (!this._byName[lower]) this._byName[lower] = [];
this._byName[lower].push(sym);
}
}
// Resolve a symbol at (file, line, col). Returns symbol string or null.
ScipStore.prototype.resolveSymbol = function (file, line, col) {
var occs = this._files[file];
if (!occs) return null;
// Binary search by line, then linear scan within line
var lo = 0, hi = occs.length - 1;
while (lo <= hi) {
var mid = (lo + hi) >>> 1;
if (occs[mid].line < line) lo = mid + 1;
else if (occs[mid].line > line) hi = mid - 1;
else { lo = mid; break; }
}
// Scan all occurrences on this line
for (var i = lo; i < occs.length && occs[i].line === line; i++) {
if (col >= occs[i].cs && col < occs[i].ce) return occs[i].sym;
}
// Also scan backwards in case lo overshot
for (var j = lo - 1; j >= 0 && occs[j].line === line; j--) {
if (col >= occs[j].cs && col < occs[j].ce) return occs[j].sym;
}
return null;
};
// Resolve an occurrence at (file, line, col). Returns {sym, def} or null.
// Like resolveSymbol but also exposes the definition flag for role-aware styling.
ScipStore.prototype.resolveOccurrence = function (file, line, col) {
var occs = this._files[file];
if (!occs) return null;
var lo = 0, hi = occs.length - 1;
while (lo <= hi) {
var mid = (lo + hi) >>> 1;
if (occs[mid].line < line) lo = mid + 1;
else if (occs[mid].line > line) hi = mid - 1;
else { lo = mid; break; }
}
for (var i = lo; i < occs.length && occs[i].line === line; i++) {
if (col >= occs[i].cs && col < occs[i].ce) {
return { sym: occs[i].sym, def: !!occs[i].def };
}
}
for (var j = lo - 1; j >= 0 && occs[j].line === line; j--) {
if (col >= occs[j].cs && col < occs[j].ce) {
return { sym: occs[j].sym, def: !!occs[j].def };
}
}
return null;
};
// Return JSON string with symbol metadata, or null.
ScipStore.prototype.symbolInfo = function (symbol) {
var info = this._symbols[symbol];
if (!info) return null;
return JSON.stringify({
symbol: symbol,
display_name: info.name,
kind: info.kind,
documentation: info.docs || [],
enclosing_symbol: info.enclosing || "",
});
};
// Fuzzy match helper: returns score or -1.
ScipStore.prototype._fuzzyScore = function (query, candidate) {
var qi = 0, score = 0, lastMatch = -1;
for (var ci = 0; ci < candidate.length && qi < query.length; ci++) {
if (candidate.charAt(ci) === query.charAt(qi)) {
score += (lastMatch === ci - 1) ? 3 : 1;
if (ci === 0 || candidate.charAt(ci - 1) === "." || candidate.charAt(ci - 1) === "_") score += 2;
lastMatch = ci;
qi++;
}
}
return qi < query.length ? -1 : score;
};
// Search on display names with fuzzy fallback. Returns JSON array.
ScipStore.prototype.search = function (query) {
if (!query || query.length < 1) return "[]";
var q = query.toLowerCase();
var scored = [];
var syms = this._symbols;
for (var sym in syms) {
if (!syms.hasOwnProperty(sym)) continue;
var entry = syms[sym];
var name = (entry.name || "").toLowerCase();
// Exact substring match (high priority)
if (name.indexOf(q) !== -1) {
scored.push({ s: 1000 + (name === q ? 500 : 0), sym: sym, entry: entry });
} else {
// Fuzzy match fallback
var fs = this._fuzzyScore(q, name);
if (fs > 0) scored.push({ s: fs, sym: sym, entry: entry });
}
}
scored.sort(function (a, b) { return b.s - a.s; });
var results = [];
for (var i = 0; i < scored.length && results.length < 20; i++) {
var e = scored[i];
results.push({
symbol: e.sym,
display_name: e.entry.name,
kind: e.entry.kind,
doc_url: e.entry.doc_url || null,
});
}
return JSON.stringify(results);
};
// Find all occurrences of a symbol. Returns JSON array.
ScipStore.prototype.findReferences = function (symbol) {
var refs = [];
var files = this._files;
for (var file in files) {
if (!files.hasOwnProperty(file)) continue;
var occs = files[file];
for (var i = 0; i < occs.length; i++) {
if (occs[i].sym === symbol) {
refs.push({
file: file,
line: occs[i].line,
col_start: occs[i].cs,
col_end: occs[i].ce,
is_def: !!occs[i].def,
});
}
}
}
return JSON.stringify(refs);
};
// Return the doc URL for a symbol, or null.
ScipStore.prototype.docUrl = function (symbol) {
var info = this._symbols[symbol];
return info ? (info.doc_url || null) : null;
};
// Return a CSS-safe class name for a SCIP symbol (e.g. "sym-a3f1b2").
ScipStore.prototype.symbolClass = function (symbol) {
if (!this._classCache) this._classCache = {};
if (this._classCache[symbol]) return this._classCache[symbol];
// djb2 hash → 6-char hex
var h = 5381;
for (var i = 0; i < symbol.length; i++) {
h = ((h << 5) + h + symbol.charCodeAt(i)) >>> 0;
}
var cls = "sym-" + ("000000" + h.toString(16)).slice(-6);
this._classCache[symbol] = cls;
return cls;
};
// Return just the 6-char hex hash for a symbol (without the "sym-" prefix).
// Used by feHighlight() which generates rules for sym-, sym-d-, sym-r- variants.
ScipStore.prototype.symbolHash = function (symbol) {
return this.symbolClass(symbol).substring(4);
};
// Reverse lookup: find SCIP symbol string for a doc URL. Returns symbol or null.
ScipStore.prototype.symbolForDocUrl = function (docUrl) {
// Lazily build reverse index on first call
if (!this._byDocUrl) {
this._byDocUrl = {};
var syms = this._symbols;
for (var sym in syms) {
if (!syms.hasOwnProperty(sym)) continue;
var url = syms[sym].doc_url;
if (url) this._byDocUrl[url] = sym;
}
}
return this._byDocUrl[docUrl] || null;
};
// ============================================================================
// Shared helpers (used by fe-code-block, fe-doc-item, fe-symbol-link, etc.)
// ============================================================================
/** Escape HTML special characters. */
function feEscapeHtml(s) {
return s.replace(/&/g, "&").replace(//g, ">").replace(/"/g, """);
}
/** Look up a DocIndex item by path. Returns the item or null. */
function feFindItem(path) {
var index = window.FE_DOC_INDEX;
if (!index || !index.items) return null;
for (var i = 0; i < index.items.length; i++) {
if (index.items[i].path === path) return index.items[i];
}
return null;
}
/**
* Wait for FE_DOC_INDEX to be available, then call the callback.
* Returns true if data is already available (callback called synchronously),
* false if waiting (callback will be called later).
*
* Multiple calls coalesce on a single event listener to avoid redundant
* re-renders when many components mount before data loads.
*/
var _feReadyCallbacks = null;
function feWhenReady(callback) {
var index = window.FE_DOC_INDEX;
if (index && index.items) {
return true;
}
if (!_feReadyCallbacks) {
_feReadyCallbacks = [];
document.addEventListener("fe-web-ready", function onReady() {
document.removeEventListener("fe-web-ready", onReady);
var cbs = _feReadyCallbacks;
_feReadyCallbacks = null;
for (var i = 0; i < cbs.length; i++) cbs[i]();
});
}
_feReadyCallbacks.push(callback);
return false;
}
/**
* Enrich an anchor element with SCIP hover highlighting and tooltip.
* `docUrl` is the doc path (e.g. "mylib::Foo/struct").
*/
function feEnrichLink(anchor, docUrl) {
var scip = window.FE_SCIP;
if (!scip) return;
var symbol = scip.symbolForDocUrl(docUrl);
// Fallback: name search
if (!symbol) {
var text = anchor.textContent.trim();
if (text) {
try {
var results = JSON.parse(scip.search(text));
for (var i = 0; i < results.length; i++) {
if (results[i].display_name === text) {
symbol = results[i].symbol;
break;
}
}
} catch (_) {}
}
}
if (!symbol) return;
anchor.classList.add(scip.symbolClass(symbol));
var hash = scip.symbolHash(symbol);
anchor.addEventListener("mouseenter", function () { feHighlight(hash); });
anchor.addEventListener("mouseleave", feUnhighlight);
var info = scip.symbolInfo(symbol);
if (info) {
try {
var parsed = JSON.parse(info);
if (parsed.documentation && parsed.documentation.length > 0) {
anchor.title = parsed.documentation[0].replace(/```[\s\S]*?```/g, "").trim();
}
} catch (_) {}
}
}
// ============================================================================
// Shared fetch cache for `src` attribute — multiple components sharing the
// same URL share a single fetch. Returns a Promise that resolves to
// { index: DocIndex, scip: ScipStore|null }.
// ============================================================================
var _feSrcCache = {};
// Fetch JSON, trying .gz compressed version first.
// Falls back to uncompressed if .gz is not found or DecompressionStream is unavailable.
function feFetchJson(url) {
var canDecompress = typeof DecompressionStream !== "undefined";
var gzUrl = url + ".gz";
var tryGz = canDecompress
? fetch(gzUrl).then(function (r) {
if (!r.ok) return null; // fall back to uncompressed
var ds = new DecompressionStream("gzip");
var decompressed = r.body.pipeThrough(ds);
return new Response(decompressed).json();
}).catch(function () { return null; })
: Promise.resolve(null);
return tryGz.then(function (data) {
if (data) return data;
return fetch(url).then(function (r) {
if (!r.ok) throw new Error("HTTP " + r.status + " loading " + url);
return r.json();
});
});
}
function feLoadSrc(url) {
if (_feSrcCache[url]) return _feSrcCache[url];
_feSrcCache[url] = feFetchJson(url)
.then(function (data) {
// Migrate old docs.json formats to current schema
data = feMigrate(data);
var result = { index: null, scip: null };
if (data && data.index) {
result.index = data.index;
if (data.scip) {
result.scip = new ScipStore(data.scip);
}
} else if (data) {
// Should not happen after migration, but fallback
result.index = data;
}
// Also populate globals if not already set (first component to load wins)
if (!window.FE_DOC_INDEX && result.index) {
window.FE_DOC_INDEX = result.index;
}
if (!window.FE_SCIP && result.scip) {
window.FE_SCIP = result.scip;
document.dispatchEvent(new CustomEvent("fe-web-ready"));
}
return result;
})
.catch(function (err) {
console.error("[fe-web] Failed to load", url, err);
// Evict from cache so a retry can succeed
delete _feSrcCache[url];
return { index: null, scip: null };
});
return _feSrcCache[url];
}
// Explicit global exports — allows loading as type="module" without losing access
window.feHighlight = feHighlight;
window.feUnhighlight = feUnhighlight;
window.feSetDefaultHighlight = feSetDefaultHighlight;
window.feClearDefaultHighlight = feClearDefaultHighlight;
window.feEscapeHtml = feEscapeHtml;
window.feFindItem = feFindItem;
window.feWhenReady = feWhenReady;
window.feEnrichLink = feEnrichLink;
window.feLoadSrc = feLoadSrc;
window.feMigrate = feMigrate;
// ============================================================================
// LSP WebSocket Client (for `fe doc serve` live mode)
// ============================================================================
function feConnectLsp(wsUrl) {
var ws = new WebSocket(wsUrl);
var nextId = 1;
var pending = {};
var diagnostics = {};
var ready = false;
ws.onopen = function () {
sendRequest("initialize", {
processId: null,
capabilities: { textDocument: { publishDiagnostics: { relatedInformation: true } } },
rootUri: null,
}).then(function (result) {
sendNotification("initialized", {});
ready = true;
console.log("[fe-lsp] Connected:", result.serverInfo || {});
});
};
ws.onmessage = function (event) {
var msg;
try { msg = JSON.parse(event.data); } catch (_) { return; }
if (msg.id != null && pending[msg.id]) {
if (msg.error) pending[msg.id].reject(msg.error);
else pending[msg.id].resolve(msg.result);
delete pending[msg.id];
} else if (msg.method === "textDocument/publishDiagnostics") {
var params = msg.params || {};
diagnostics[params.uri] = params.diagnostics || [];
document.dispatchEvent(new CustomEvent("fe-diagnostics", {
detail: { uri: params.uri, diagnostics: params.diagnostics || [] }
}));
} else if (msg.method === "fe/docReload") {
var p = msg.params || {};
if (p.docIndex) window.FE_DOC_INDEX = p.docIndex;
if (p.scipData) {
var obj = typeof p.scipData === "string" ? JSON.parse(p.scipData) : p.scipData;
window.FE_SCIP_DATA = obj;
if (typeof ScipStore !== "undefined") window.FE_SCIP = new ScipStore(obj);
}
document.dispatchEvent(new CustomEvent("fe-web-ready"));
} else if (msg.method === "fe/navigate") {
var path = (msg.params || {}).path;
if (path) document.dispatchEvent(new CustomEvent("fe-navigate", {
bubbles: true, detail: { docPath: path }
}));
}
};
ws.onerror = function (err) { console.warn("[fe-lsp] Error:", err); };
ws.onclose = function () { ready = false; console.log("[fe-lsp] Disconnected"); };
function sendRequest(method, params) {
return new Promise(function (resolve, reject) {
var id = nextId++;
pending[id] = { resolve: resolve, reject: reject };
ws.send(JSON.stringify({ jsonrpc: "2.0", id: id, method: method, params: params }));
});
}
function sendNotification(method, params) {
ws.send(JSON.stringify({ jsonrpc: "2.0", method: method, params: params }));
}
return {
request: sendRequest,
notify: sendNotification,
getDiagnostics: function (uri) { return diagnostics[uri] || []; },
isReady: function () { return ready; },
close: function () { ws.close(); },
};
}
window.feConnectLsp = feConnectLsp;
// ============================================================================
// Tree-sitter runtime
// ============================================================================
// include: shell.js
// The Module object: Our interface to the outside world. We import
// and export values on it. There are various ways Module can be used:
// 1. Not defined. We create it here
// 2. A function parameter, function(moduleArg) => Promise
// 3. pre-run appended it, var Module = {}; ..generated code..
// 4. External script tag defines var Module.
// We need to check if Module already exists (e.g. case 3 above).
// Substitution will be replaced with actual code on later stage of the build,
// this way Closure Compiler will not mangle it (e.g. case 4. above).
// Note that if you want to run closure, and also to use Module
// after the generated code, you will need to define var Module = {};
// before the code. Then that object will be used in the code, and you
// can continue to use Module afterwards as well.
var Module = typeof Module != "undefined" ? Module : {};
// Determine the runtime environment we are in. You can customize this by
// setting the ENVIRONMENT setting at compile time (see settings.js).
// Attempt to auto-detect the environment
var ENVIRONMENT_IS_WEB = typeof window == "object";
var ENVIRONMENT_IS_WORKER = typeof importScripts == "function";
// N.b. Electron.js environment is simultaneously a NODE-environment, but
// also a web environment.
var ENVIRONMENT_IS_NODE = typeof process == "object" && typeof process.versions == "object" && typeof process.versions.node == "string";
if (ENVIRONMENT_IS_NODE) {}
// --pre-jses are emitted after the Module integration code, so that they can
// refer to Module (if they choose; they can also define Module)
// include: /src/lib/binding_web/prefix.js
var TreeSitter = function() {
var initPromise;
var document = typeof window == "object" ? {
currentScript: window.document.currentScript
} : null;
class Parser {
constructor() {
this.initialize();
}
initialize() {
throw new Error("cannot construct a Parser before calling `init()`");
}
static init(moduleOptions) {
if (initPromise) return initPromise;
Module = Object.assign({}, Module, moduleOptions);
return initPromise = new Promise(resolveInitPromise => {
// end include: /src/lib/binding_web/prefix.js
// Sometimes an existing Module object exists with properties
// meant to overwrite the default module functionality. Here
// we collect those properties and reapply _after_ we configure
// the current environment's defaults to avoid having to be so
// defensive during initialization.
var moduleOverrides = Object.assign({}, Module);
var arguments_ = [];
var thisProgram = "./this.program";
var quit_ = (status, toThrow) => {
throw toThrow;
};
// `/` should be present at the end if `scriptDirectory` is not empty
var scriptDirectory = "";
function locateFile(path) {
if (Module["locateFile"]) {
return Module["locateFile"](path, scriptDirectory);
}
return scriptDirectory + path;
}
// Hooks that are implemented differently in different runtime environments.
var readAsync, readBinary;
if (ENVIRONMENT_IS_NODE) {
// These modules will usually be used on Node.js. Load them eagerly to avoid
// the complexity of lazy-loading.
var fs = require("fs");
var nodePath = require("path");
scriptDirectory = __dirname + "/";
// include: node_shell_read.js
readBinary = filename => {
// We need to re-wrap `file://` strings to URLs. Normalizing isn't
// necessary in that case, the path should already be absolute.
filename = isFileURI(filename) ? new URL(filename) : nodePath.normalize(filename);
var ret = fs.readFileSync(filename);
return ret;
};
readAsync = (filename, binary = true) => {
// See the comment in the `readBinary` function.
filename = isFileURI(filename) ? new URL(filename) : nodePath.normalize(filename);
return new Promise((resolve, reject) => {
fs.readFile(filename, binary ? undefined : "utf8", (err, data) => {
if (err) reject(err); else resolve(binary ? data.buffer : data);
});
});
};
// end include: node_shell_read.js
if (!Module["thisProgram"] && process.argv.length > 1) {
thisProgram = process.argv[1].replace(/\\/g, "/");
}
arguments_ = process.argv.slice(2);
if (typeof module != "undefined") {
module["exports"] = Module;
}
quit_ = (status, toThrow) => {
process.exitCode = status;
throw toThrow;
};
} else // Note that this includes Node.js workers when relevant (pthreads is enabled).
// Node.js workers are detected as a combination of ENVIRONMENT_IS_WORKER and
// ENVIRONMENT_IS_NODE.
if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
if (ENVIRONMENT_IS_WORKER) {
// Check worker, not web, since window could be polyfilled
scriptDirectory = self.location.href;
} else if (typeof document != "undefined" && document.currentScript) {
// web
scriptDirectory = document.currentScript.src;
}
// blob urls look like blob:http://site.com/etc/etc and we cannot infer anything from them.
// otherwise, slice off the final part of the url to find the script directory.
// if scriptDirectory does not contain a slash, lastIndexOf will return -1,
// and scriptDirectory will correctly be replaced with an empty string.
// If scriptDirectory contains a query (starting with ?) or a fragment (starting with #),
// they are removed because they could contain a slash.
if (scriptDirectory.startsWith("blob:")) {
scriptDirectory = "";
} else {
scriptDirectory = scriptDirectory.substr(0, scriptDirectory.replace(/[?#].*/, "").lastIndexOf("/") + 1);
}
{
// include: web_or_worker_shell_read.js
if (ENVIRONMENT_IS_WORKER) {
readBinary = url => {
var xhr = new XMLHttpRequest;
xhr.open("GET", url, false);
xhr.responseType = "arraybuffer";
xhr.send(null);
return new Uint8Array(/** @type{!ArrayBuffer} */ (xhr.response));
};
}
readAsync = url => {
// Fetch has some additional restrictions over XHR, like it can't be used on a file:// url.
// See https://github.com/github/fetch/pull/92#issuecomment-140665932
// Cordova or Electron apps are typically loaded from a file:// url.
// So use XHR on webview if URL is a file URL.
if (isFileURI(url)) {
return new Promise((reject, resolve) => {
var xhr = new XMLHttpRequest;
xhr.open("GET", url, true);
xhr.responseType = "arraybuffer";
xhr.onload = () => {
if (xhr.status == 200 || (xhr.status == 0 && xhr.response)) {
// file URLs can return 0
resolve(xhr.response);
}
reject(xhr.status);
};
xhr.onerror = reject;
xhr.send(null);
});
}
return fetch(url, {
credentials: "same-origin"
}).then(response => {
if (response.ok) {
return response.arrayBuffer();
}
return Promise.reject(new Error(response.status + " : " + response.url));
});
};
}
} else // end include: web_or_worker_shell_read.js
{}
var out = Module["print"] || console.log.bind(console);
var err = Module["printErr"] || console.error.bind(console);
// Merge back in the overrides
Object.assign(Module, moduleOverrides);
// Free the object hierarchy contained in the overrides, this lets the GC
// reclaim data used.
moduleOverrides = null;
// Emit code to handle expected values on the Module object. This applies Module.x
// to the proper local x. This has two benefits: first, we only emit it if it is
// expected to arrive, and second, by using a local everywhere else that can be
// minified.
if (Module["arguments"]) arguments_ = Module["arguments"];
if (Module["thisProgram"]) thisProgram = Module["thisProgram"];
if (Module["quit"]) quit_ = Module["quit"];
// perform assertions in shell.js after we set up out() and err(), as otherwise if an assertion fails it cannot print the message
// end include: shell.js
// include: preamble.js
// === Preamble library stuff ===
// Documentation for the public APIs defined in this file must be updated in:
// site/source/docs/api_reference/preamble.js.rst
// A prebuilt local version of the documentation is available at:
// site/build/text/docs/api_reference/preamble.js.txt
// You can also build docs locally as HTML or other formats in site/
// An online HTML version (which may be of a different version of Emscripten)
// is up at http://kripken.github.io/emscripten-site/docs/api_reference/preamble.js.html
var dynamicLibraries = Module["dynamicLibraries"] || [];
var wasmBinary;
if (Module["wasmBinary"]) wasmBinary = Module["wasmBinary"];
// Wasm globals
var wasmMemory;
//========================================
// Runtime essentials
//========================================
// whether we are quitting the application. no code should run after this.
// set in exit() and abort()
var ABORT = false;
// set by exit() and abort(). Passed to 'onExit' handler.
// NOTE: This is also used as the process return code code in shell environments
// but only when noExitRuntime is false.
var EXITSTATUS;
// Memory management
var /** @type {!Int8Array} */ HEAP8, /** @type {!Uint8Array} */ HEAPU8, /** @type {!Int16Array} */ HEAP16, /** @type {!Uint16Array} */ HEAPU16, /** @type {!Int32Array} */ HEAP32, /** @type {!Uint32Array} */ HEAPU32, /** @type {!Float32Array} */ HEAPF32, /** @type {!Float64Array} */ HEAPF64;
var HEAP_DATA_VIEW;
// include: runtime_shared.js
function updateMemoryViews() {
var b = wasmMemory.buffer;
Module["HEAP_DATA_VIEW"] = HEAP_DATA_VIEW = new DataView(b);
Module["HEAP8"] = HEAP8 = new Int8Array(b);
Module["HEAP16"] = HEAP16 = new Int16Array(b);
Module["HEAPU8"] = HEAPU8 = new Uint8Array(b);
Module["HEAPU16"] = HEAPU16 = new Uint16Array(b);
Module["HEAP32"] = HEAP32 = new Int32Array(b);
Module["HEAPU32"] = HEAPU32 = new Uint32Array(b);
Module["HEAPF32"] = HEAPF32 = new Float32Array(b);
Module["HEAPF64"] = HEAPF64 = new Float64Array(b);
}
// end include: runtime_shared.js
// In non-standalone/normal mode, we create the memory here.
// include: runtime_init_memory.js
// Create the wasm memory. (Note: this only applies if IMPORTED_MEMORY is defined)
// check for full engine support (use string 'subarray' to avoid closure compiler confusion)
if (Module["wasmMemory"]) {
wasmMemory = Module["wasmMemory"];
} else {
var INITIAL_MEMORY = Module["INITIAL_MEMORY"] || 33554432;
wasmMemory = new WebAssembly.Memory({
"initial": INITIAL_MEMORY / 65536,
// In theory we should not need to emit the maximum if we want "unlimited"
// or 4GB of memory, but VMs error on that atm, see
// https://github.com/emscripten-core/emscripten/issues/14130
// And in the pthreads case we definitely need to emit a maximum. So
// always emit one.
"maximum": 2147483648 / 65536
});
}
updateMemoryViews();
// end include: runtime_init_memory.js
// include: runtime_stack_check.js
// end include: runtime_stack_check.js
// include: runtime_assertions.js
// end include: runtime_assertions.js
var __ATPRERUN__ = [];
// functions called before the runtime is initialized
var __ATINIT__ = [];
// functions called during startup
var __ATMAIN__ = [];
// functions called during shutdown
var __ATPOSTRUN__ = [];
// functions called after the main() is called
var __RELOC_FUNCS__ = [];
var runtimeInitialized = false;
function preRun() {
if (Module["preRun"]) {
if (typeof Module["preRun"] == "function") Module["preRun"] = [ Module["preRun"] ];
while (Module["preRun"].length) {
addOnPreRun(Module["preRun"].shift());
}
}
callRuntimeCallbacks(__ATPRERUN__);
}
function initRuntime() {
runtimeInitialized = true;
callRuntimeCallbacks(__RELOC_FUNCS__);
callRuntimeCallbacks(__ATINIT__);
}
function preMain() {
callRuntimeCallbacks(__ATMAIN__);
}
function postRun() {
if (Module["postRun"]) {
if (typeof Module["postRun"] == "function") Module["postRun"] = [ Module["postRun"] ];
while (Module["postRun"].length) {
addOnPostRun(Module["postRun"].shift());
}
}
callRuntimeCallbacks(__ATPOSTRUN__);
}
function addOnPreRun(cb) {
__ATPRERUN__.unshift(cb);
}
function addOnInit(cb) {
__ATINIT__.unshift(cb);
}
function addOnPostRun(cb) {
__ATPOSTRUN__.unshift(cb);
}
// include: runtime_math.js
// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/imul
// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/fround
// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/clz32
// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/trunc
// end include: runtime_math.js
// A counter of dependencies for calling run(). If we need to
// do asynchronous work before running, increment this and
// decrement it. Incrementing must happen in a place like
// Module.preRun (used by emcc to add file preloading).
// Note that you can add dependencies in preRun, even though
// it happens right before run - run will be postponed until
// the dependencies are met.
var runDependencies = 0;
var runDependencyWatcher = null;
var dependenciesFulfilled = null;
// overridden to take different actions when all run dependencies are fulfilled
function getUniqueRunDependency(id) {
return id;
}
function addRunDependency(id) {
runDependencies++;
Module["monitorRunDependencies"]?.(runDependencies);
}
function removeRunDependency(id) {
runDependencies--;
Module["monitorRunDependencies"]?.(runDependencies);
if (runDependencies == 0) {
if (runDependencyWatcher !== null) {
clearInterval(runDependencyWatcher);
runDependencyWatcher = null;
}
if (dependenciesFulfilled) {
var callback = dependenciesFulfilled;
dependenciesFulfilled = null;
callback();
}
}
}
/** @param {string|number=} what */ function abort(what) {
Module["onAbort"]?.(what);
what = "Aborted(" + what + ")";
// TODO(sbc): Should we remove printing and leave it up to whoever
// catches the exception?
err(what);
ABORT = true;
EXITSTATUS = 1;
what += ". Build with -sASSERTIONS for more info.";
// Use a wasm runtime error, because a JS error might be seen as a foreign
// exception, which means we'd run destructors on it. We need the error to
// simply make the program stop.
// FIXME This approach does not work in Wasm EH because it currently does not assume
// all RuntimeErrors are from traps; it decides whether a RuntimeError is from
// a trap or not based on a hidden field within the object. So at the moment
// we don't have a way of throwing a wasm trap from JS. TODO Make a JS API that
// allows this in the wasm spec.
// Suppress closure compiler warning here. Closure compiler's builtin extern
// definition for WebAssembly.RuntimeError claims it takes no arguments even
// though it can.
// TODO(https://github.com/google/closure-compiler/pull/3913): Remove if/when upstream closure gets fixed.
/** @suppress {checkTypes} */ var e = new WebAssembly.RuntimeError(what);
// Throw the error whether or not MODULARIZE is set because abort is used
// in code paths apart from instantiation where an exception is expected
// to be thrown when abort is called.
throw e;
}
// include: memoryprofiler.js
// end include: memoryprofiler.js
// include: URIUtils.js
// Prefix of data URIs emitted by SINGLE_FILE and related options.
var dataURIPrefix = "data:application/octet-stream;base64,";
/**
* Indicates whether filename is a base64 data URI.
* @noinline
*/ var isDataURI = filename => filename.startsWith(dataURIPrefix);
/**
* Indicates whether filename is delivered via file protocol (as opposed to http/https)
* @noinline
*/ var isFileURI = filename => filename.startsWith("file://");
// end include: URIUtils.js
// include: runtime_exceptions.js
// end include: runtime_exceptions.js
function findWasmBinary() {
var f = "tree-sitter.wasm";
if (!isDataURI(f)) {
return locateFile(f);
}
return f;
}
var wasmBinaryFile;
function getBinarySync(file) {
if (file == wasmBinaryFile && wasmBinary) {
return new Uint8Array(wasmBinary);
}
if (readBinary) {
return readBinary(file);
}
throw "both async and sync fetching of the wasm failed";
}
function getBinaryPromise(binaryFile) {
// If we don't have the binary yet, load it asynchronously using readAsync.
if (!wasmBinary) {
// Fetch the binary using readAsync
return readAsync(binaryFile).then(response => new Uint8Array(/** @type{!ArrayBuffer} */ (response)), // Fall back to getBinarySync if readAsync fails
() => getBinarySync(binaryFile));
}
// Otherwise, getBinarySync should be able to get it synchronously
return Promise.resolve().then(() => getBinarySync(binaryFile));
}
function instantiateArrayBuffer(binaryFile, imports, receiver) {
return getBinaryPromise(binaryFile).then(binary => WebAssembly.instantiate(binary, imports)).then(receiver, reason => {
err(`failed to asynchronously prepare wasm: ${reason}`);
abort(reason);
});
}
function instantiateAsync(binary, binaryFile, imports, callback) {
if (!binary && typeof WebAssembly.instantiateStreaming == "function" && !isDataURI(binaryFile) && // Don't use streaming for file:// delivered objects in a webview, fetch them synchronously.
!isFileURI(binaryFile) && // Avoid instantiateStreaming() on Node.js environment for now, as while
// Node.js v18.1.0 implements it, it does not have a full fetch()
// implementation yet.
// Reference:
// https://github.com/emscripten-core/emscripten/pull/16917
!ENVIRONMENT_IS_NODE && typeof fetch == "function") {
return fetch(binaryFile, {
credentials: "same-origin"
}).then(response => {
// Suppress closure warning here since the upstream definition for
// instantiateStreaming only allows Promise rather than
// an actual Response.
// TODO(https://github.com/google/closure-compiler/pull/3913): Remove if/when upstream closure is fixed.
/** @suppress {checkTypes} */ var result = WebAssembly.instantiateStreaming(response, imports);
return result.then(callback, function(reason) {
// We expect the most common failure cause to be a bad MIME type for the binary,
// in which case falling back to ArrayBuffer instantiation should work.
err(`wasm streaming compile failed: ${reason}`);
err("falling back to ArrayBuffer instantiation");
return instantiateArrayBuffer(binaryFile, imports, callback);
});
});
}
return instantiateArrayBuffer(binaryFile, imports, callback);
}
function getWasmImports() {
// prepare imports
return {
"env": wasmImports,
"wasi_snapshot_preview1": wasmImports,
"GOT.mem": new Proxy(wasmImports, GOTHandler),
"GOT.func": new Proxy(wasmImports, GOTHandler)
};
}
// Create the wasm instance.
// Receives the wasm imports, returns the exports.
function createWasm() {
var info = getWasmImports();
// Load the wasm module and create an instance of using native support in the JS engine.
// handle a generated wasm instance, receiving its exports and
// performing other necessary setup
/** @param {WebAssembly.Module=} module*/ function receiveInstance(instance, module) {
wasmExports = instance.exports;
wasmExports = relocateExports(wasmExports, 1024);
var metadata = getDylinkMetadata(module);
if (metadata.neededDynlibs) {
dynamicLibraries = metadata.neededDynlibs.concat(dynamicLibraries);
}
mergeLibSymbols(wasmExports, "main");
LDSO.init();
loadDylibs();
addOnInit(wasmExports["__wasm_call_ctors"]);
__RELOC_FUNCS__.push(wasmExports["__wasm_apply_data_relocs"]);
removeRunDependency("wasm-instantiate");
return wasmExports;
}
// wait for the pthread pool (if any)
addRunDependency("wasm-instantiate");
// Prefer streaming instantiation if available.
function receiveInstantiationResult(result) {
// 'result' is a ResultObject object which has both the module and instance.
// receiveInstance() will swap in the exports (to Module.asm) so they can be called
receiveInstance(result["instance"], result["module"]);
}
// User shell pages can write their own Module.instantiateWasm = function(imports, successCallback) callback
// to manually instantiate the Wasm module themselves. This allows pages to
// run the instantiation parallel to any other async startup actions they are
// performing.
// Also pthreads and wasm workers initialize the wasm instance through this
// path.
if (Module["instantiateWasm"]) {
try {
return Module["instantiateWasm"](info, receiveInstance);
} catch (e) {
err(`Module.instantiateWasm callback failed with error: ${e}`);
return false;
}
}
if (!wasmBinaryFile) wasmBinaryFile = findWasmBinary();
instantiateAsync(wasmBinary, wasmBinaryFile, info, receiveInstantiationResult);
return {};
}
// include: runtime_debug.js
// end include: runtime_debug.js
// === Body ===
var ASM_CONSTS = {};
// end include: preamble.js
/** @constructor */ function ExitStatus(status) {
this.name = "ExitStatus";
this.message = `Program terminated with exit(${status})`;
this.status = status;
}
var GOT = {};
var currentModuleWeakSymbols = new Set([]);
var GOTHandler = {
get(obj, symName) {
var rtn = GOT[symName];
if (!rtn) {
rtn = GOT[symName] = new WebAssembly.Global({
"value": "i32",
"mutable": true
});
}
if (!currentModuleWeakSymbols.has(symName)) {
// Any non-weak reference to a symbol marks it as `required`, which
// enabled `reportUndefinedSymbols` to report undefeind symbol errors
// correctly.
rtn.required = true;
}
return rtn;
}
};
var LE_HEAP_LOAD_F32 = byteOffset => HEAP_DATA_VIEW.getFloat32(byteOffset, true);
var LE_HEAP_LOAD_F64 = byteOffset => HEAP_DATA_VIEW.getFloat64(byteOffset, true);
var LE_HEAP_LOAD_I16 = byteOffset => HEAP_DATA_VIEW.getInt16(byteOffset, true);
var LE_HEAP_LOAD_I32 = byteOffset => HEAP_DATA_VIEW.getInt32(byteOffset, true);
var LE_HEAP_LOAD_U32 = byteOffset => HEAP_DATA_VIEW.getUint32(byteOffset, true);
var LE_HEAP_STORE_F32 = (byteOffset, value) => HEAP_DATA_VIEW.setFloat32(byteOffset, value, true);
var LE_HEAP_STORE_F64 = (byteOffset, value) => HEAP_DATA_VIEW.setFloat64(byteOffset, value, true);
var LE_HEAP_STORE_I16 = (byteOffset, value) => HEAP_DATA_VIEW.setInt16(byteOffset, value, true);
var LE_HEAP_STORE_I32 = (byteOffset, value) => HEAP_DATA_VIEW.setInt32(byteOffset, value, true);
var LE_HEAP_STORE_U32 = (byteOffset, value) => HEAP_DATA_VIEW.setUint32(byteOffset, value, true);
var callRuntimeCallbacks = callbacks => {
while (callbacks.length > 0) {
// Pass the module as the first argument.
callbacks.shift()(Module);
}
};
var UTF8Decoder = typeof TextDecoder != "undefined" ? new TextDecoder : undefined;
/**
* Given a pointer 'idx' to a null-terminated UTF8-encoded string in the given
* array that contains uint8 values, returns a copy of that string as a
* Javascript String object.
* heapOrArray is either a regular array, or a JavaScript typed array view.
* @param {number} idx
* @param {number=} maxBytesToRead
* @return {string}
*/ var UTF8ArrayToString = (heapOrArray, idx, maxBytesToRead) => {
var endIdx = idx + maxBytesToRead;
var endPtr = idx;
// TextDecoder needs to know the byte length in advance, it doesn't stop on
// null terminator by itself. Also, use the length info to avoid running tiny
// strings through TextDecoder, since .subarray() allocates garbage.
// (As a tiny code save trick, compare endPtr against endIdx using a negation,
// so that undefined means Infinity)
while (heapOrArray[endPtr] && !(endPtr >= endIdx)) ++endPtr;
if (endPtr - idx > 16 && heapOrArray.buffer && UTF8Decoder) {
return UTF8Decoder.decode(heapOrArray.subarray(idx, endPtr));
}
var str = "";
// If building with TextDecoder, we have already computed the string length
// above, so test loop end condition against that
while (idx < endPtr) {
// For UTF8 byte structure, see:
// http://en.wikipedia.org/wiki/UTF-8#Description
// https://www.ietf.org/rfc/rfc2279.txt
// https://tools.ietf.org/html/rfc3629
var u0 = heapOrArray[idx++];
if (!(u0 & 128)) {
str += String.fromCharCode(u0);
continue;
}
var u1 = heapOrArray[idx++] & 63;
if ((u0 & 224) == 192) {
str += String.fromCharCode(((u0 & 31) << 6) | u1);
continue;
}
var u2 = heapOrArray[idx++] & 63;
if ((u0 & 240) == 224) {
u0 = ((u0 & 15) << 12) | (u1 << 6) | u2;
} else {
u0 = ((u0 & 7) << 18) | (u1 << 12) | (u2 << 6) | (heapOrArray[idx++] & 63);
}
if (u0 < 65536) {
str += String.fromCharCode(u0);
} else {
var ch = u0 - 65536;
str += String.fromCharCode(55296 | (ch >> 10), 56320 | (ch & 1023));
}
}
return str;
};
var getDylinkMetadata = binary => {
var offset = 0;
var end = 0;
function getU8() {
return binary[offset++];
}
function getLEB() {
var ret = 0;
var mul = 1;
while (1) {
var byte = binary[offset++];
ret += ((byte & 127) * mul);
mul *= 128;
if (!(byte & 128)) break;
}
return ret;
}
function getString() {
var len = getLEB();
offset += len;
return UTF8ArrayToString(binary, offset - len, len);
}
/** @param {string=} message */ function failIf(condition, message) {
if (condition) throw new Error(message);
}
var name = "dylink.0";
if (binary instanceof WebAssembly.Module) {
var dylinkSection = WebAssembly.Module.customSections(binary, name);
if (dylinkSection.length === 0) {
name = "dylink";
dylinkSection = WebAssembly.Module.customSections(binary, name);
}
failIf(dylinkSection.length === 0, "need dylink section");
binary = new Uint8Array(dylinkSection[0]);
end = binary.length;
} else {
var int32View = new Uint32Array(new Uint8Array(binary.subarray(0, 24)).buffer);
var magicNumberFound = int32View[0] == 1836278016 || int32View[0] == 6386541;
failIf(!magicNumberFound, "need to see wasm magic number");
// \0asm
// we should see the dylink custom section right after the magic number and wasm version
failIf(binary[8] !== 0, "need the dylink section to be first");
offset = 9;
var section_size = getLEB();
//section size
end = offset + section_size;
name = getString();
}
var customSection = {
neededDynlibs: [],
tlsExports: new Set,
weakImports: new Set
};
if (name == "dylink") {
customSection.memorySize = getLEB();
customSection.memoryAlign = getLEB();
customSection.tableSize = getLEB();
customSection.tableAlign = getLEB();
// shared libraries this module needs. We need to load them first, so that
// current module could resolve its imports. (see tools/shared.py
// WebAssembly.make_shared_library() for "dylink" section extension format)
var neededDynlibsCount = getLEB();
for (var i = 0; i < neededDynlibsCount; ++i) {
var libname = getString();
customSection.neededDynlibs.push(libname);
}
} else {
failIf(name !== "dylink.0");
var WASM_DYLINK_MEM_INFO = 1;
var WASM_DYLINK_NEEDED = 2;
var WASM_DYLINK_EXPORT_INFO = 3;
var WASM_DYLINK_IMPORT_INFO = 4;
var WASM_SYMBOL_TLS = 256;
var WASM_SYMBOL_BINDING_MASK = 3;
var WASM_SYMBOL_BINDING_WEAK = 1;
while (offset < end) {
var subsectionType = getU8();
var subsectionSize = getLEB();
if (subsectionType === WASM_DYLINK_MEM_INFO) {
customSection.memorySize = getLEB();
customSection.memoryAlign = getLEB();
customSection.tableSize = getLEB();
customSection.tableAlign = getLEB();
} else if (subsectionType === WASM_DYLINK_NEEDED) {
var neededDynlibsCount = getLEB();
for (var i = 0; i < neededDynlibsCount; ++i) {
libname = getString();
customSection.neededDynlibs.push(libname);
}
} else if (subsectionType === WASM_DYLINK_EXPORT_INFO) {
var count = getLEB();
while (count--) {
var symname = getString();
var flags = getLEB();
if (flags & WASM_SYMBOL_TLS) {
customSection.tlsExports.add(symname);
}
}
} else if (subsectionType === WASM_DYLINK_IMPORT_INFO) {
var count = getLEB();
while (count--) {
var modname = getString();
var symname = getString();
var flags = getLEB();
if ((flags & WASM_SYMBOL_BINDING_MASK) == WASM_SYMBOL_BINDING_WEAK) {
customSection.weakImports.add(symname);
}
}
} else {
// unknown subsection
offset += subsectionSize;
}
}
}
return customSection;
};
/**
* @param {number} ptr
* @param {string} type
*/ function getValue(ptr, type = "i8") {
if (type.endsWith("*")) type = "*";
switch (type) {
case "i1":
return HEAP8[ptr];
case "i8":
return HEAP8[ptr];
case "i16":
return LE_HEAP_LOAD_I16(((ptr) >> 1) * 2);
case "i32":
return LE_HEAP_LOAD_I32(((ptr) >> 2) * 4);
case "i64":
abort("to do getValue(i64) use WASM_BIGINT");
case "float":
return LE_HEAP_LOAD_F32(((ptr) >> 2) * 4);
case "double":
return LE_HEAP_LOAD_F64(((ptr) >> 3) * 8);
case "*":
return LE_HEAP_LOAD_U32(((ptr) >> 2) * 4);
default:
abort(`invalid type for getValue: ${type}`);
}
}
var newDSO = (name, handle, syms) => {
var dso = {
refcount: Infinity,
name: name,
exports: syms,
global: true
};
LDSO.loadedLibsByName[name] = dso;
if (handle != undefined) {
LDSO.loadedLibsByHandle[handle] = dso;
}
return dso;
};
var LDSO = {
loadedLibsByName: {},
loadedLibsByHandle: {},
init() {
newDSO("__main__", 0, wasmImports);
}
};
var ___heap_base = 78112;
var zeroMemory = (address, size) => {
HEAPU8.fill(0, address, address + size);
return address;
};
var alignMemory = (size, alignment) => Math.ceil(size / alignment) * alignment;
var getMemory = size => {
// After the runtime is initialized, we must only use sbrk() normally.
if (runtimeInitialized) {
// Currently we don't support freeing of static data when modules are
// unloaded via dlclose. This function is tagged as `noleakcheck` to
// avoid having this reported as leak.
return zeroMemory(_malloc(size), size);
}
var ret = ___heap_base;
// Keep __heap_base stack aligned.
var end = ret + alignMemory(size, 16);
___heap_base = end;
GOT["__heap_base"].value = end;
return ret;
};
var isInternalSym = symName => [ "__cpp_exception", "__c_longjmp", "__wasm_apply_data_relocs", "__dso_handle", "__tls_size", "__tls_align", "__set_stack_limits", "_emscripten_tls_init", "__wasm_init_tls", "__wasm_call_ctors", "__start_em_asm", "__stop_em_asm", "__start_em_js", "__stop_em_js" ].includes(symName) || symName.startsWith("__em_js__");
var uleb128Encode = (n, target) => {
if (n < 128) {
target.push(n);
} else {
target.push((n % 128) | 128, n >> 7);
}
};
var sigToWasmTypes = sig => {
var typeNames = {
"i": "i32",
"j": "i64",
"f": "f32",
"d": "f64",
"e": "externref",
"p": "i32"
};
var type = {
parameters: [],
results: sig[0] == "v" ? [] : [ typeNames[sig[0]] ]
};
for (var i = 1; i < sig.length; ++i) {
type.parameters.push(typeNames[sig[i]]);
}
return type;
};
var generateFuncType = (sig, target) => {
var sigRet = sig.slice(0, 1);
var sigParam = sig.slice(1);
var typeCodes = {
"i": 127,
// i32
"p": 127,
// i32
"j": 126,
// i64
"f": 125,
// f32
"d": 124,
// f64
"e": 111
};
// Parameters, length + signatures
target.push(96);
/* form: func */ uleb128Encode(sigParam.length, target);
for (var i = 0; i < sigParam.length; ++i) {
target.push(typeCodes[sigParam[i]]);
}
// Return values, length + signatures
// With no multi-return in MVP, either 0 (void) or 1 (anything else)
if (sigRet == "v") {
target.push(0);
} else {
target.push(1, typeCodes[sigRet]);
}
};
var convertJsFunctionToWasm = (func, sig) => {
// If the type reflection proposal is available, use the new
// "WebAssembly.Function" constructor.
// Otherwise, construct a minimal wasm module importing the JS function and
// re-exporting it.
if (typeof WebAssembly.Function == "function") {
return new WebAssembly.Function(sigToWasmTypes(sig), func);
}
// The module is static, with the exception of the type section, which is
// generated based on the signature passed in.
var typeSectionBody = [ 1 ];
// count: 1
generateFuncType(sig, typeSectionBody);
// Rest of the module is static
var bytes = [ 0, 97, 115, 109, // magic ("\0asm")
1, 0, 0, 0, // version: 1
1 ];
// Write the overall length of the type section followed by the body
uleb128Encode(typeSectionBody.length, bytes);
bytes.push(...typeSectionBody);
// The rest of the module is static
bytes.push(2, 7, // import section
// (import "e" "f" (func 0 (type 0)))
1, 1, 101, 1, 102, 0, 0, 7, 5, // export section
// (export "f" (func 0 (type 0)))
1, 1, 102, 0, 0);
// We can compile this wasm module synchronously because it is very small.
// This accepts an import (at "e.f"), that it reroutes to an export (at "f")
var module = new WebAssembly.Module(new Uint8Array(bytes));
var instance = new WebAssembly.Instance(module, {
"e": {
"f": func
}
});
var wrappedFunc = instance.exports["f"];
return wrappedFunc;
};
var wasmTableMirror = [];
/** @type {WebAssembly.Table} */ var wasmTable = new WebAssembly.Table({
"initial": 28,
"element": "anyfunc"
});
var getWasmTableEntry = funcPtr => {
var func = wasmTableMirror[funcPtr];
if (!func) {
if (funcPtr >= wasmTableMirror.length) wasmTableMirror.length = funcPtr + 1;
wasmTableMirror[funcPtr] = func = wasmTable.get(funcPtr);
}
return func;
};
var updateTableMap = (offset, count) => {
if (functionsInTableMap) {
for (var i = offset; i < offset + count; i++) {
var item = getWasmTableEntry(i);
// Ignore null values.
if (item) {
functionsInTableMap.set(item, i);
}
}
}
};
var functionsInTableMap;
var getFunctionAddress = func => {
// First, create the map if this is the first use.
if (!functionsInTableMap) {
functionsInTableMap = new WeakMap;
updateTableMap(0, wasmTable.length);
}
return functionsInTableMap.get(func) || 0;
};
var freeTableIndexes = [];
var getEmptyTableSlot = () => {
// Reuse a free index if there is one, otherwise grow.
if (freeTableIndexes.length) {
return freeTableIndexes.pop();
}
// Grow the table
try {
wasmTable.grow(1);
} catch (err) {
if (!(err instanceof RangeError)) {
throw err;
}
throw "Unable to grow wasm table. Set ALLOW_TABLE_GROWTH.";
}
return wasmTable.length - 1;
};
var setWasmTableEntry = (idx, func) => {
wasmTable.set(idx, func);
// With ABORT_ON_WASM_EXCEPTIONS wasmTable.get is overridden to return wrapped
// functions so we need to call it here to retrieve the potential wrapper correctly
// instead of just storing 'func' directly into wasmTableMirror
wasmTableMirror[idx] = wasmTable.get(idx);
};
/** @param {string=} sig */ var addFunction = (func, sig) => {
// Check if the function is already in the table, to ensure each function
// gets a unique index.
var rtn = getFunctionAddress(func);
if (rtn) {
return rtn;
}
// It's not in the table, add it now.
var ret = getEmptyTableSlot();
// Set the new value.
try {
// Attempting to call this with JS function will cause of table.set() to fail
setWasmTableEntry(ret, func);
} catch (err) {
if (!(err instanceof TypeError)) {
throw err;
}
var wrapped = convertJsFunctionToWasm(func, sig);
setWasmTableEntry(ret, wrapped);
}
functionsInTableMap.set(func, ret);
return ret;
};
var updateGOT = (exports, replace) => {
for (var symName in exports) {
if (isInternalSym(symName)) {
continue;
}
var value = exports[symName];
if (symName.startsWith("orig$")) {
symName = symName.split("$")[1];
replace = true;
}
GOT[symName] ||= new WebAssembly.Global({
"value": "i32",
"mutable": true
});
if (replace || GOT[symName].value == 0) {
if (typeof value == "function") {
GOT[symName].value = addFunction(value);
} else if (typeof value == "number") {
GOT[symName].value = value;
} else {
err(`unhandled export type for '${symName}': ${typeof value}`);
}
}
}
};
/** @param {boolean=} replace */ var relocateExports = (exports, memoryBase, replace) => {
var relocated = {};
for (var e in exports) {
var value = exports[e];
if (typeof value == "object") {
// a breaking change in the wasm spec, globals are now objects
// https://github.com/WebAssembly/mutable-global/issues/1
value = value.value;
}
if (typeof value == "number") {
value += memoryBase;
}
relocated[e] = value;
}
updateGOT(relocated, replace);
return relocated;
};
var isSymbolDefined = symName => {
// Ignore 'stub' symbols that are auto-generated as part of the original
// `wasmImports` used to instantiate the main module.
var existing = wasmImports[symName];
if (!existing || existing.stub) {
return false;
}
return true;
};
var dynCallLegacy = (sig, ptr, args) => {
sig = sig.replace(/p/g, "i");
var f = Module["dynCall_" + sig];
return f(ptr, ...args);
};
var dynCall = (sig, ptr, args = []) => {
// Without WASM_BIGINT support we cannot directly call function with i64 as
// part of their signature, so we rely on the dynCall functions generated by
// wasm-emscripten-finalize
if (sig.includes("j")) {
return dynCallLegacy(sig, ptr, args);
}
var rtn = getWasmTableEntry(ptr)(...args);
return rtn;
};
var stackSave = () => _emscripten_stack_get_current();
var stackRestore = val => __emscripten_stack_restore(val);
var createInvokeFunction = sig => (ptr, ...args) => {
var sp = stackSave();
try {
return dynCall(sig, ptr, args);
} catch (e) {
stackRestore(sp);
// Create a try-catch guard that rethrows the Emscripten EH exception.
// Exceptions thrown from C++ will be a pointer (number) and longjmp
// will throw the number Infinity. Use the compact and fast "e !== e+0"
// test to check if e was not a Number.
if (e !== e + 0) throw e;
_setThrew(1, 0);
}
};
var resolveGlobalSymbol = (symName, direct = false) => {
var sym;
// First look for the orig$ symbol which is the symbol without i64
// legalization performed.
if (direct && ("orig$" + symName in wasmImports)) {
symName = "orig$" + symName;
}
if (isSymbolDefined(symName)) {
sym = wasmImports[symName];
} else // Asm.js-style exception handling: invoke wrapper generation
if (symName.startsWith("invoke_")) {
// Create (and cache) new invoke_ functions on demand.
sym = wasmImports[symName] = createInvokeFunction(symName.split("_")[1]);
}
return {
sym: sym,
name: symName
};
};
/**
* Given a pointer 'ptr' to a null-terminated UTF8-encoded string in the
* emscripten HEAP, returns a copy of that string as a Javascript String object.
*
* @param {number} ptr
* @param {number=} maxBytesToRead - An optional length that specifies the
* maximum number of bytes to read. You can omit this parameter to scan the
* string until the first 0 byte. If maxBytesToRead is passed, and the string
* at [ptr, ptr+maxBytesToReadr[ contains a null byte in the middle, then the
* string will cut short at that byte index (i.e. maxBytesToRead will not
* produce a string of exact length [ptr, ptr+maxBytesToRead[) N.B. mixing
* frequent uses of UTF8ToString() with and without maxBytesToRead may throw
* JS JIT optimizations off, so it is worth to consider consistently using one
* @return {string}
*/ var UTF8ToString = (ptr, maxBytesToRead) => ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead) : "";
/**
* @param {string=} libName
* @param {Object=} localScope
* @param {number=} handle
*/ var loadWebAssemblyModule = (binary, flags, libName, localScope, handle) => {
var metadata = getDylinkMetadata(binary);
currentModuleWeakSymbols = metadata.weakImports;
// loadModule loads the wasm module after all its dependencies have been loaded.
// can be called both sync/async.
function loadModule() {
// The first thread to load a given module needs to allocate the static
// table and memory regions. Later threads re-use the same table region
// and can ignore the memory region (since memory is shared between
// threads already).
// If `handle` is specified than it is assumed that the calling thread has
// exclusive access to it for the duration of this function. See the
// locking in `dynlink.c`.
var firstLoad = !handle || !HEAP8[(handle) + (8)];
if (firstLoad) {
// alignments are powers of 2
var memAlign = Math.pow(2, metadata.memoryAlign);
// prepare memory
var memoryBase = metadata.memorySize ? alignMemory(getMemory(metadata.memorySize + memAlign), memAlign) : 0;
// TODO: add to cleanups
var tableBase = metadata.tableSize ? wasmTable.length : 0;
if (handle) {
HEAP8[(handle) + (8)] = 1;
LE_HEAP_STORE_U32((((handle) + (12)) >> 2) * 4, memoryBase);
LE_HEAP_STORE_I32((((handle) + (16)) >> 2) * 4, metadata.memorySize);
LE_HEAP_STORE_U32((((handle) + (20)) >> 2) * 4, tableBase);
LE_HEAP_STORE_I32((((handle) + (24)) >> 2) * 4, metadata.tableSize);
}
} else {
memoryBase = LE_HEAP_LOAD_U32((((handle) + (12)) >> 2) * 4);
tableBase = LE_HEAP_LOAD_U32((((handle) + (20)) >> 2) * 4);
}
var tableGrowthNeeded = tableBase + metadata.tableSize - wasmTable.length;
if (tableGrowthNeeded > 0) {
wasmTable.grow(tableGrowthNeeded);
}
// This is the export map that we ultimately return. We declare it here
// so it can be used within resolveSymbol. We resolve symbols against
// this local symbol map in the case there they are not present on the
// global Module object. We need this fallback because Modules sometime
// need to import their own symbols
var moduleExports;
function resolveSymbol(sym) {
var resolved = resolveGlobalSymbol(sym).sym;
if (!resolved && localScope) {
resolved = localScope[sym];
}
if (!resolved) {
resolved = moduleExports[sym];
}
return resolved;
}
// TODO kill ↓↓↓ (except "symbols local to this module", it will likely be
// not needed if we require that if A wants symbols from B it has to link
// to B explicitly: similarly to -Wl,--no-undefined)
// wasm dynamic libraries are pure wasm, so they cannot assist in
// their own loading. When side module A wants to import something
// provided by a side module B that is loaded later, we need to
// add a layer of indirection, but worse, we can't even tell what
// to add the indirection for, without inspecting what A's imports
// are. To do that here, we use a JS proxy (another option would
// be to inspect the binary directly).
var proxyHandler = {
get(stubs, prop) {
// symbols that should be local to this module
switch (prop) {
case "__memory_base":
return memoryBase;
case "__table_base":
return tableBase;
}
if (prop in wasmImports && !wasmImports[prop].stub) {
// No stub needed, symbol already exists in symbol table
return wasmImports[prop];
}
// Return a stub function that will resolve the symbol
// when first called.
if (!(prop in stubs)) {
var resolved;
stubs[prop] = (...args) => {
resolved ||= resolveSymbol(prop);
return resolved(...args);
};
}
return stubs[prop];
}
};
var proxy = new Proxy({}, proxyHandler);
var info = {
"GOT.mem": new Proxy({}, GOTHandler),
"GOT.func": new Proxy({}, GOTHandler),
"env": proxy,
"wasi_snapshot_preview1": proxy
};
function postInstantiation(module, instance) {
// add new entries to functionsInTableMap
updateTableMap(tableBase, metadata.tableSize);
moduleExports = relocateExports(instance.exports, memoryBase);
if (!flags.allowUndefined) {
reportUndefinedSymbols();
}
function addEmAsm(addr, body) {
var args = [];
var arity = 0;
for (;arity < 16; arity++) {
if (body.indexOf("$" + arity) != -1) {
args.push("$" + arity);
} else {
break;
}
}
args = args.join(",");
var func = `(${args}) => { ${body} };`;
ASM_CONSTS[start] = eval(func);
}
// Add any EM_ASM function that exist in the side module
if ("__start_em_asm" in moduleExports) {
var start = moduleExports["__start_em_asm"];
var stop = moduleExports["__stop_em_asm"];
while (start < stop) {
var jsString = UTF8ToString(start);
addEmAsm(start, jsString);
start = HEAPU8.indexOf(0, start) + 1;
}
}
function addEmJs(name, cSig, body) {
// The signature here is a C signature (e.g. "(int foo, char* bar)").
// See `create_em_js` in emcc.py` for the build-time version of this
// code.
var jsArgs = [];
cSig = cSig.slice(1, -1);
if (cSig != "void") {
cSig = cSig.split(",");
for (var i in cSig) {
var jsArg = cSig[i].split(" ").pop();
jsArgs.push(jsArg.replace("*", ""));
}
}
var func = `(${jsArgs}) => ${body};`;
moduleExports[name] = eval(func);
}
for (var name in moduleExports) {
if (name.startsWith("__em_js__")) {
var start = moduleExports[name];
var jsString = UTF8ToString(start);
// EM_JS strings are stored in the data section in the form
// SIG<::>BODY.
var parts = jsString.split("<::>");
addEmJs(name.replace("__em_js__", ""), parts[0], parts[1]);
delete moduleExports[name];
}
}
// initialize the module
var applyRelocs = moduleExports["__wasm_apply_data_relocs"];
if (applyRelocs) {
if (runtimeInitialized) {
applyRelocs();
} else {
__RELOC_FUNCS__.push(applyRelocs);
}
}
var init = moduleExports["__wasm_call_ctors"];
if (init) {
if (runtimeInitialized) {
init();
} else {
// we aren't ready to run compiled code yet
__ATINIT__.push(init);
}
}
return moduleExports;
}
if (flags.loadAsync) {
if (binary instanceof WebAssembly.Module) {
var instance = new WebAssembly.Instance(binary, info);
return Promise.resolve(postInstantiation(binary, instance));
}
return WebAssembly.instantiate(binary, info).then(result => postInstantiation(result.module, result.instance));
}
var module = binary instanceof WebAssembly.Module ? binary : new WebAssembly.Module(binary);
var instance = new WebAssembly.Instance(module, info);
return postInstantiation(module, instance);
}
// now load needed libraries and the module itself.
if (flags.loadAsync) {
return metadata.neededDynlibs.reduce((chain, dynNeeded) => chain.then(() => loadDynamicLibrary(dynNeeded, flags, localScope)), Promise.resolve()).then(loadModule);
}
metadata.neededDynlibs.forEach(needed => loadDynamicLibrary(needed, flags, localScope));
return loadModule();
};
var mergeLibSymbols = (exports, libName) => {
// add symbols into global namespace TODO: weak linking etc.
for (var [sym, exp] of Object.entries(exports)) {
// When RTLD_GLOBAL is enabled, the symbols defined by this shared object
// will be made available for symbol resolution of subsequently loaded
// shared objects.
// We should copy the symbols (which include methods and variables) from
// SIDE_MODULE to MAIN_MODULE.
const setImport = target => {
if (!isSymbolDefined(target)) {
wasmImports[target] = exp;
}
};
setImport(sym);
// Special case for handling of main symbol: If a side module exports
// `main` that also acts a definition for `__main_argc_argv` and vice
// versa.
const main_alias = "__main_argc_argv";
if (sym == "main") {
setImport(main_alias);
}
if (sym == main_alias) {
setImport("main");
}
if (sym.startsWith("dynCall_") && !Module.hasOwnProperty(sym)) {
Module[sym] = exp;
}
}
};
/** @param {boolean=} noRunDep */ var asyncLoad = (url, onload, onerror, noRunDep) => {
var dep = !noRunDep ? getUniqueRunDependency(`al ${url}`) : "";
readAsync(url).then(arrayBuffer => {
onload(new Uint8Array(arrayBuffer));
if (dep) removeRunDependency(dep);
}, err => {
if (onerror) {
onerror();
} else {
throw `Loading data file "${url}" failed.`;
}
});
if (dep) addRunDependency(dep);
};
/**
* @param {number=} handle
* @param {Object=} localScope
*/ function loadDynamicLibrary(libName, flags = {
global: true,
nodelete: true
}, localScope, handle) {
// when loadDynamicLibrary did not have flags, libraries were loaded
// globally & permanently
var dso = LDSO.loadedLibsByName[libName];
if (dso) {
// the library is being loaded or has been loaded already.
if (!flags.global) {
if (localScope) {
Object.assign(localScope, dso.exports);
}
} else if (!dso.global) {
// The library was previously loaded only locally but not
// we have a request with global=true.
dso.global = true;
mergeLibSymbols(dso.exports, libName);
}
// same for "nodelete"
if (flags.nodelete && dso.refcount !== Infinity) {
dso.refcount = Infinity;
}
dso.refcount++;
if (handle) {
LDSO.loadedLibsByHandle[handle] = dso;
}
return flags.loadAsync ? Promise.resolve(true) : true;
}
// allocate new DSO
dso = newDSO(libName, handle, "loading");
dso.refcount = flags.nodelete ? Infinity : 1;
dso.global = flags.global;
// libName -> libData
function loadLibData() {
// for wasm, we can use fetch for async, but for fs mode we can only imitate it
if (handle) {
var data = LE_HEAP_LOAD_U32((((handle) + (28)) >> 2) * 4);
var dataSize = LE_HEAP_LOAD_U32((((handle) + (32)) >> 2) * 4);
if (data && dataSize) {
var libData = HEAP8.slice(data, data + dataSize);
return flags.loadAsync ? Promise.resolve(libData) : libData;
}
}
var libFile = locateFile(libName);
if (flags.loadAsync) {
return new Promise(function(resolve, reject) {
asyncLoad(libFile, resolve, reject);
});
}
// load the binary synchronously
if (!readBinary) {
throw new Error(`${libFile}: file not found, and synchronous loading of external files is not available`);
}
return readBinary(libFile);
}
// libName -> exports
function getExports() {
// module not preloaded - load lib data and create new module from it
if (flags.loadAsync) {
return loadLibData().then(libData => loadWebAssemblyModule(libData, flags, libName, localScope, handle));
}
return loadWebAssemblyModule(loadLibData(), flags, libName, localScope, handle);
}
// module for lib is loaded - update the dso & global namespace
function moduleLoaded(exports) {
if (dso.global) {
mergeLibSymbols(exports, libName);
} else if (localScope) {
Object.assign(localScope, exports);
}
dso.exports = exports;
}
if (flags.loadAsync) {
return getExports().then(exports => {
moduleLoaded(exports);
return true;
});
}
moduleLoaded(getExports());
return true;
}
var reportUndefinedSymbols = () => {
for (var [symName, entry] of Object.entries(GOT)) {
if (entry.value == 0) {
var value = resolveGlobalSymbol(symName, true).sym;
if (!value && !entry.required) {
// Ignore undefined symbols that are imported as weak.
continue;
}
if (typeof value == "function") {
/** @suppress {checkTypes} */ entry.value = addFunction(value, value.sig);
} else if (typeof value == "number") {
entry.value = value;
} else {
throw new Error(`bad export type for '${symName}': ${typeof value}`);
}
}
}
};
var loadDylibs = () => {
if (!dynamicLibraries.length) {
reportUndefinedSymbols();
return;
}
// Load binaries asynchronously
addRunDependency("loadDylibs");
dynamicLibraries.reduce((chain, lib) => chain.then(() => loadDynamicLibrary(lib, {
loadAsync: true,
global: true,
nodelete: true,
allowUndefined: true
})), Promise.resolve()).then(() => {
// we got them all, wonderful
reportUndefinedSymbols();
removeRunDependency("loadDylibs");
});
};
var noExitRuntime = Module["noExitRuntime"] || true;
/**
* @param {number} ptr
* @param {number} value
* @param {string} type
*/ function setValue(ptr, value, type = "i8") {
if (type.endsWith("*")) type = "*";
switch (type) {
case "i1":
HEAP8[ptr] = value;
break;
case "i8":
HEAP8[ptr] = value;
break;
case "i16":
LE_HEAP_STORE_I16(((ptr) >> 1) * 2, value);
break;
case "i32":
LE_HEAP_STORE_I32(((ptr) >> 2) * 4, value);
break;
case "i64":
abort("to do setValue(i64) use WASM_BIGINT");
case "float":
LE_HEAP_STORE_F32(((ptr) >> 2) * 4, value);
break;
case "double":
LE_HEAP_STORE_F64(((ptr) >> 3) * 8, value);
break;
case "*":
LE_HEAP_STORE_U32(((ptr) >> 2) * 4, value);
break;
default:
abort(`invalid type for setValue: ${type}`);
}
}
var ___memory_base = new WebAssembly.Global({
"value": "i32",
"mutable": false
}, 1024);
var ___stack_pointer = new WebAssembly.Global({
"value": "i32",
"mutable": true
}, 78112);
var ___table_base = new WebAssembly.Global({
"value": "i32",
"mutable": false
}, 1);
var __abort_js = () => {
abort("");
};
__abort_js.sig = "v";
var nowIsMonotonic = 1;
var __emscripten_get_now_is_monotonic = () => nowIsMonotonic;
__emscripten_get_now_is_monotonic.sig = "i";
var __emscripten_memcpy_js = (dest, src, num) => HEAPU8.copyWithin(dest, src, src + num);
__emscripten_memcpy_js.sig = "vppp";
var _emscripten_date_now = () => Date.now();
_emscripten_date_now.sig = "d";
var _emscripten_get_now;
// Modern environment where performance.now() is supported:
// N.B. a shorter form "_emscripten_get_now = performance.now;" is
// unfortunately not allowed even in current browsers (e.g. FF Nightly 75).
_emscripten_get_now = () => performance.now();
_emscripten_get_now.sig = "d";
var getHeapMax = () => // Stay one Wasm page short of 4GB: while e.g. Chrome is able to allocate
// full 4GB Wasm memories, the size will wrap back to 0 bytes in Wasm side
// for any code that deals with heap sizes, which would require special
// casing all heap size related code to treat 0 specially.
2147483648;
var growMemory = size => {
var b = wasmMemory.buffer;
var pages = (size - b.byteLength + 65535) / 65536;
try {
// round size grow request up to wasm page size (fixed 64KB per spec)
wasmMemory.grow(pages);
// .grow() takes a delta compared to the previous size
updateMemoryViews();
return 1;
} /*success*/ catch (e) {}
};
// implicit 0 return to save code size (caller will cast "undefined" into 0
// anyhow)
var _emscripten_resize_heap = requestedSize => {
var oldSize = HEAPU8.length;
// With CAN_ADDRESS_2GB or MEMORY64, pointers are already unsigned.
requestedSize >>>= 0;
// With multithreaded builds, races can happen (another thread might increase the size
// in between), so return a failure, and let the caller retry.
// Memory resize rules:
// 1. Always increase heap size to at least the requested size, rounded up
// to next page multiple.
// 2a. If MEMORY_GROWTH_LINEAR_STEP == -1, excessively resize the heap
// geometrically: increase the heap size according to
// MEMORY_GROWTH_GEOMETRIC_STEP factor (default +20%), At most
// overreserve by MEMORY_GROWTH_GEOMETRIC_CAP bytes (default 96MB).
// 2b. If MEMORY_GROWTH_LINEAR_STEP != -1, excessively resize the heap
// linearly: increase the heap size by at least
// MEMORY_GROWTH_LINEAR_STEP bytes.
// 3. Max size for the heap is capped at 2048MB-WASM_PAGE_SIZE, or by
// MAXIMUM_MEMORY, or by ASAN limit, depending on which is smallest
// 4. If we were unable to allocate as much memory, it may be due to
// over-eager decision to excessively reserve due to (3) above.
// Hence if an allocation fails, cut down on the amount of excess
// growth, in an attempt to succeed to perform a smaller allocation.
// A limit is set for how much we can grow. We should not exceed that
// (the wasm binary specifies it, so if we tried, we'd fail anyhow).
var maxHeapSize = getHeapMax();
if (requestedSize > maxHeapSize) {
return false;
}
var alignUp = (x, multiple) => x + (multiple - x % multiple) % multiple;
// Loop through potential heap size increases. If we attempt a too eager
// reservation that fails, cut down on the attempted size and reserve a
// smaller bump instead. (max 3 times, chosen somewhat arbitrarily)
for (var cutDown = 1; cutDown <= 4; cutDown *= 2) {
var overGrownHeapSize = oldSize * (1 + .2 / cutDown);
// ensure geometric growth
// but limit overreserving (default to capping at +96MB overgrowth at most)
overGrownHeapSize = Math.min(overGrownHeapSize, requestedSize + 100663296);
var newSize = Math.min(maxHeapSize, alignUp(Math.max(requestedSize, overGrownHeapSize), 65536));
var replacement = growMemory(newSize);
if (replacement) {
return true;
}
}
return false;
};
_emscripten_resize_heap.sig = "ip";
var _fd_close = fd => 52;
_fd_close.sig = "ii";
var convertI32PairToI53Checked = (lo, hi) => ((hi + 2097152) >>> 0 < 4194305 - !!lo) ? (lo >>> 0) + hi * 4294967296 : NaN;
function _fd_seek(fd, offset_low, offset_high, whence, newOffset) {
var offset = convertI32PairToI53Checked(offset_low, offset_high);
return 70;
}
_fd_seek.sig = "iiiiip";
var printCharBuffers = [ null, [], [] ];
var printChar = (stream, curr) => {
var buffer = printCharBuffers[stream];
if (curr === 0 || curr === 10) {
(stream === 1 ? out : err)(UTF8ArrayToString(buffer, 0));
buffer.length = 0;
} else {
buffer.push(curr);
}
};
var _fd_write = (fd, iov, iovcnt, pnum) => {
// hack to support printf in SYSCALLS_REQUIRE_FILESYSTEM=0
var num = 0;
for (var i = 0; i < iovcnt; i++) {
var ptr = LE_HEAP_LOAD_U32(((iov) >> 2) * 4);
var len = LE_HEAP_LOAD_U32((((iov) + (4)) >> 2) * 4);
iov += 8;
for (var j = 0; j < len; j++) {
printChar(fd, HEAPU8[ptr + j]);
}
num += len;
}
LE_HEAP_STORE_U32(((pnum) >> 2) * 4, num);
return 0;
};
_fd_write.sig = "iippp";
function _tree_sitter_log_callback(isLexMessage, messageAddress) {
if (currentLogCallback) {
const message = UTF8ToString(messageAddress);
currentLogCallback(message, isLexMessage !== 0);
}
}
function _tree_sitter_parse_callback(inputBufferAddress, index, row, column, lengthAddress) {
const INPUT_BUFFER_SIZE = 10 * 1024;
const string = currentParseCallback(index, {
row: row,
column: column
});
if (typeof string === "string") {
setValue(lengthAddress, string.length, "i32");
stringToUTF16(string, inputBufferAddress, INPUT_BUFFER_SIZE);
} else {
setValue(lengthAddress, 0, "i32");
}
}
var runtimeKeepaliveCounter = 0;
var keepRuntimeAlive = () => noExitRuntime || runtimeKeepaliveCounter > 0;
var _proc_exit = code => {
EXITSTATUS = code;
if (!keepRuntimeAlive()) {
Module["onExit"]?.(code);
ABORT = true;
}
quit_(code, new ExitStatus(code));
};
_proc_exit.sig = "vi";
/** @param {boolean|number=} implicit */ var exitJS = (status, implicit) => {
EXITSTATUS = status;
_proc_exit(status);
};
var handleException = e => {
// Certain exception types we do not treat as errors since they are used for
// internal control flow.
// 1. ExitStatus, which is thrown by exit()
// 2. "unwind", which is thrown by emscripten_unwind_to_js_event_loop() and others
// that wish to return to JS event loop.
if (e instanceof ExitStatus || e == "unwind") {
return EXITSTATUS;
}
quit_(1, e);
};
var lengthBytesUTF8 = str => {
var len = 0;
for (var i = 0; i < str.length; ++i) {
// Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code
// unit, not a Unicode code point of the character! So decode
// UTF16->UTF32->UTF8.
// See http://unicode.org/faq/utf_bom.html#utf16-3
var c = str.charCodeAt(i);
// possibly a lead surrogate
if (c <= 127) {
len++;
} else if (c <= 2047) {
len += 2;
} else if (c >= 55296 && c <= 57343) {
len += 4;
++i;
} else {
len += 3;
}
}
return len;
};
var stringToUTF8Array = (str, heap, outIdx, maxBytesToWrite) => {
// Parameter maxBytesToWrite is not optional. Negative values, 0, null,
// undefined and false each don't write out any bytes.
if (!(maxBytesToWrite > 0)) return 0;
var startIdx = outIdx;
var endIdx = outIdx + maxBytesToWrite - 1;
// -1 for string null terminator.
for (var i = 0; i < str.length; ++i) {
// Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code
// unit, not a Unicode code point of the character! So decode
// UTF16->UTF32->UTF8.
// See http://unicode.org/faq/utf_bom.html#utf16-3
// For UTF8 byte structure, see http://en.wikipedia.org/wiki/UTF-8#Description
// and https://www.ietf.org/rfc/rfc2279.txt
// and https://tools.ietf.org/html/rfc3629
var u = str.charCodeAt(i);
// possibly a lead surrogate
if (u >= 55296 && u <= 57343) {
var u1 = str.charCodeAt(++i);
u = 65536 + ((u & 1023) << 10) | (u1 & 1023);
}
if (u <= 127) {
if (outIdx >= endIdx) break;
heap[outIdx++] = u;
} else if (u <= 2047) {
if (outIdx + 1 >= endIdx) break;
heap[outIdx++] = 192 | (u >> 6);
heap[outIdx++] = 128 | (u & 63);
} else if (u <= 65535) {
if (outIdx + 2 >= endIdx) break;
heap[outIdx++] = 224 | (u >> 12);
heap[outIdx++] = 128 | ((u >> 6) & 63);
heap[outIdx++] = 128 | (u & 63);
} else {
if (outIdx + 3 >= endIdx) break;
heap[outIdx++] = 240 | (u >> 18);
heap[outIdx++] = 128 | ((u >> 12) & 63);
heap[outIdx++] = 128 | ((u >> 6) & 63);
heap[outIdx++] = 128 | (u & 63);
}
}
// Null-terminate the pointer to the buffer.
heap[outIdx] = 0;
return outIdx - startIdx;
};
var stringToUTF8 = (str, outPtr, maxBytesToWrite) => stringToUTF8Array(str, HEAPU8, outPtr, maxBytesToWrite);
var stackAlloc = sz => __emscripten_stack_alloc(sz);
var stringToUTF8OnStack = str => {
var size = lengthBytesUTF8(str) + 1;
var ret = stackAlloc(size);
stringToUTF8(str, ret, size);
return ret;
};
var stringToUTF16 = (str, outPtr, maxBytesToWrite) => {
// Backwards compatibility: if max bytes is not specified, assume unsafe unbounded write is allowed.
maxBytesToWrite ??= 2147483647;
if (maxBytesToWrite < 2) return 0;
maxBytesToWrite -= 2;
// Null terminator.
var startPtr = outPtr;
var numCharsToWrite = (maxBytesToWrite < str.length * 2) ? (maxBytesToWrite / 2) : str.length;
for (var i = 0; i < numCharsToWrite; ++i) {
// charCodeAt returns a UTF-16 encoded code unit, so it can be directly written to the HEAP.
var codeUnit = str.charCodeAt(i);
// possibly a lead surrogate
LE_HEAP_STORE_I16(((outPtr) >> 1) * 2, codeUnit);
outPtr += 2;
}
// Null-terminate the pointer to the HEAP.
LE_HEAP_STORE_I16(((outPtr) >> 1) * 2, 0);
return outPtr - startPtr;
};
var AsciiToString = ptr => {
var str = "";
while (1) {
var ch = HEAPU8[ptr++];
if (!ch) return str;
str += String.fromCharCode(ch);
}
};
var wasmImports = {
/** @export */ __heap_base: ___heap_base,
/** @export */ __indirect_function_table: wasmTable,
/** @export */ __memory_base: ___memory_base,
/** @export */ __stack_pointer: ___stack_pointer,
/** @export */ __table_base: ___table_base,
/** @export */ _abort_js: __abort_js,
/** @export */ _emscripten_get_now_is_monotonic: __emscripten_get_now_is_monotonic,
/** @export */ _emscripten_memcpy_js: __emscripten_memcpy_js,
/** @export */ emscripten_get_now: _emscripten_get_now,
/** @export */ emscripten_resize_heap: _emscripten_resize_heap,
/** @export */ fd_close: _fd_close,
/** @export */ fd_seek: _fd_seek,
/** @export */ fd_write: _fd_write,
/** @export */ memory: wasmMemory,
/** @export */ tree_sitter_log_callback: _tree_sitter_log_callback,
/** @export */ tree_sitter_parse_callback: _tree_sitter_parse_callback
};
var wasmExports = createWasm();
var ___wasm_call_ctors = () => (___wasm_call_ctors = wasmExports["__wasm_call_ctors"])();
var ___wasm_apply_data_relocs = () => (___wasm_apply_data_relocs = wasmExports["__wasm_apply_data_relocs"])();
var _malloc = Module["_malloc"] = a0 => (_malloc = Module["_malloc"] = wasmExports["malloc"])(a0);
var _calloc = Module["_calloc"] = (a0, a1) => (_calloc = Module["_calloc"] = wasmExports["calloc"])(a0, a1);
var _realloc = Module["_realloc"] = (a0, a1) => (_realloc = Module["_realloc"] = wasmExports["realloc"])(a0, a1);
var _free = Module["_free"] = a0 => (_free = Module["_free"] = wasmExports["free"])(a0);
var _ts_language_symbol_count = Module["_ts_language_symbol_count"] = a0 => (_ts_language_symbol_count = Module["_ts_language_symbol_count"] = wasmExports["ts_language_symbol_count"])(a0);
var _ts_language_state_count = Module["_ts_language_state_count"] = a0 => (_ts_language_state_count = Module["_ts_language_state_count"] = wasmExports["ts_language_state_count"])(a0);
var _ts_language_version = Module["_ts_language_version"] = a0 => (_ts_language_version = Module["_ts_language_version"] = wasmExports["ts_language_version"])(a0);
var _ts_language_field_count = Module["_ts_language_field_count"] = a0 => (_ts_language_field_count = Module["_ts_language_field_count"] = wasmExports["ts_language_field_count"])(a0);
var _ts_language_next_state = Module["_ts_language_next_state"] = (a0, a1, a2) => (_ts_language_next_state = Module["_ts_language_next_state"] = wasmExports["ts_language_next_state"])(a0, a1, a2);
var _ts_language_symbol_name = Module["_ts_language_symbol_name"] = (a0, a1) => (_ts_language_symbol_name = Module["_ts_language_symbol_name"] = wasmExports["ts_language_symbol_name"])(a0, a1);
var _ts_language_symbol_for_name = Module["_ts_language_symbol_for_name"] = (a0, a1, a2, a3) => (_ts_language_symbol_for_name = Module["_ts_language_symbol_for_name"] = wasmExports["ts_language_symbol_for_name"])(a0, a1, a2, a3);
var _strncmp = Module["_strncmp"] = (a0, a1, a2) => (_strncmp = Module["_strncmp"] = wasmExports["strncmp"])(a0, a1, a2);
var _ts_language_symbol_type = Module["_ts_language_symbol_type"] = (a0, a1) => (_ts_language_symbol_type = Module["_ts_language_symbol_type"] = wasmExports["ts_language_symbol_type"])(a0, a1);
var _ts_language_field_name_for_id = Module["_ts_language_field_name_for_id"] = (a0, a1) => (_ts_language_field_name_for_id = Module["_ts_language_field_name_for_id"] = wasmExports["ts_language_field_name_for_id"])(a0, a1);
var _ts_lookahead_iterator_new = Module["_ts_lookahead_iterator_new"] = (a0, a1) => (_ts_lookahead_iterator_new = Module["_ts_lookahead_iterator_new"] = wasmExports["ts_lookahead_iterator_new"])(a0, a1);
var _ts_lookahead_iterator_delete = Module["_ts_lookahead_iterator_delete"] = a0 => (_ts_lookahead_iterator_delete = Module["_ts_lookahead_iterator_delete"] = wasmExports["ts_lookahead_iterator_delete"])(a0);
var _ts_lookahead_iterator_reset_state = Module["_ts_lookahead_iterator_reset_state"] = (a0, a1) => (_ts_lookahead_iterator_reset_state = Module["_ts_lookahead_iterator_reset_state"] = wasmExports["ts_lookahead_iterator_reset_state"])(a0, a1);
var _ts_lookahead_iterator_reset = Module["_ts_lookahead_iterator_reset"] = (a0, a1, a2) => (_ts_lookahead_iterator_reset = Module["_ts_lookahead_iterator_reset"] = wasmExports["ts_lookahead_iterator_reset"])(a0, a1, a2);
var _ts_lookahead_iterator_next = Module["_ts_lookahead_iterator_next"] = a0 => (_ts_lookahead_iterator_next = Module["_ts_lookahead_iterator_next"] = wasmExports["ts_lookahead_iterator_next"])(a0);
var _ts_lookahead_iterator_current_symbol = Module["_ts_lookahead_iterator_current_symbol"] = a0 => (_ts_lookahead_iterator_current_symbol = Module["_ts_lookahead_iterator_current_symbol"] = wasmExports["ts_lookahead_iterator_current_symbol"])(a0);
var _memset = Module["_memset"] = (a0, a1, a2) => (_memset = Module["_memset"] = wasmExports["memset"])(a0, a1, a2);
var _memcpy = Module["_memcpy"] = (a0, a1, a2) => (_memcpy = Module["_memcpy"] = wasmExports["memcpy"])(a0, a1, a2);
var _ts_parser_delete = Module["_ts_parser_delete"] = a0 => (_ts_parser_delete = Module["_ts_parser_delete"] = wasmExports["ts_parser_delete"])(a0);
var _ts_parser_reset = Module["_ts_parser_reset"] = a0 => (_ts_parser_reset = Module["_ts_parser_reset"] = wasmExports["ts_parser_reset"])(a0);
var _ts_parser_set_language = Module["_ts_parser_set_language"] = (a0, a1) => (_ts_parser_set_language = Module["_ts_parser_set_language"] = wasmExports["ts_parser_set_language"])(a0, a1);
var _ts_parser_timeout_micros = Module["_ts_parser_timeout_micros"] = a0 => (_ts_parser_timeout_micros = Module["_ts_parser_timeout_micros"] = wasmExports["ts_parser_timeout_micros"])(a0);
var _ts_parser_set_timeout_micros = Module["_ts_parser_set_timeout_micros"] = (a0, a1, a2) => (_ts_parser_set_timeout_micros = Module["_ts_parser_set_timeout_micros"] = wasmExports["ts_parser_set_timeout_micros"])(a0, a1, a2);
var _ts_parser_set_included_ranges = Module["_ts_parser_set_included_ranges"] = (a0, a1, a2) => (_ts_parser_set_included_ranges = Module["_ts_parser_set_included_ranges"] = wasmExports["ts_parser_set_included_ranges"])(a0, a1, a2);
var _memmove = Module["_memmove"] = (a0, a1, a2) => (_memmove = Module["_memmove"] = wasmExports["memmove"])(a0, a1, a2);
var _memcmp = Module["_memcmp"] = (a0, a1, a2) => (_memcmp = Module["_memcmp"] = wasmExports["memcmp"])(a0, a1, a2);
var _ts_query_new = Module["_ts_query_new"] = (a0, a1, a2, a3, a4) => (_ts_query_new = Module["_ts_query_new"] = wasmExports["ts_query_new"])(a0, a1, a2, a3, a4);
var _ts_query_delete = Module["_ts_query_delete"] = a0 => (_ts_query_delete = Module["_ts_query_delete"] = wasmExports["ts_query_delete"])(a0);
var _iswspace = Module["_iswspace"] = a0 => (_iswspace = Module["_iswspace"] = wasmExports["iswspace"])(a0);
var _iswalnum = Module["_iswalnum"] = a0 => (_iswalnum = Module["_iswalnum"] = wasmExports["iswalnum"])(a0);
var _ts_query_pattern_count = Module["_ts_query_pattern_count"] = a0 => (_ts_query_pattern_count = Module["_ts_query_pattern_count"] = wasmExports["ts_query_pattern_count"])(a0);
var _ts_query_capture_count = Module["_ts_query_capture_count"] = a0 => (_ts_query_capture_count = Module["_ts_query_capture_count"] = wasmExports["ts_query_capture_count"])(a0);
var _ts_query_string_count = Module["_ts_query_string_count"] = a0 => (_ts_query_string_count = Module["_ts_query_string_count"] = wasmExports["ts_query_string_count"])(a0);
var _ts_query_capture_name_for_id = Module["_ts_query_capture_name_for_id"] = (a0, a1, a2) => (_ts_query_capture_name_for_id = Module["_ts_query_capture_name_for_id"] = wasmExports["ts_query_capture_name_for_id"])(a0, a1, a2);
var _ts_query_string_value_for_id = Module["_ts_query_string_value_for_id"] = (a0, a1, a2) => (_ts_query_string_value_for_id = Module["_ts_query_string_value_for_id"] = wasmExports["ts_query_string_value_for_id"])(a0, a1, a2);
var _ts_query_predicates_for_pattern = Module["_ts_query_predicates_for_pattern"] = (a0, a1, a2) => (_ts_query_predicates_for_pattern = Module["_ts_query_predicates_for_pattern"] = wasmExports["ts_query_predicates_for_pattern"])(a0, a1, a2);
var _ts_query_disable_capture = Module["_ts_query_disable_capture"] = (a0, a1, a2) => (_ts_query_disable_capture = Module["_ts_query_disable_capture"] = wasmExports["ts_query_disable_capture"])(a0, a1, a2);
var _ts_tree_copy = Module["_ts_tree_copy"] = a0 => (_ts_tree_copy = Module["_ts_tree_copy"] = wasmExports["ts_tree_copy"])(a0);
var _ts_tree_delete = Module["_ts_tree_delete"] = a0 => (_ts_tree_delete = Module["_ts_tree_delete"] = wasmExports["ts_tree_delete"])(a0);
var _ts_init = Module["_ts_init"] = () => (_ts_init = Module["_ts_init"] = wasmExports["ts_init"])();
var _ts_parser_new_wasm = Module["_ts_parser_new_wasm"] = () => (_ts_parser_new_wasm = Module["_ts_parser_new_wasm"] = wasmExports["ts_parser_new_wasm"])();
var _ts_parser_enable_logger_wasm = Module["_ts_parser_enable_logger_wasm"] = (a0, a1) => (_ts_parser_enable_logger_wasm = Module["_ts_parser_enable_logger_wasm"] = wasmExports["ts_parser_enable_logger_wasm"])(a0, a1);
var _ts_parser_parse_wasm = Module["_ts_parser_parse_wasm"] = (a0, a1, a2, a3, a4) => (_ts_parser_parse_wasm = Module["_ts_parser_parse_wasm"] = wasmExports["ts_parser_parse_wasm"])(a0, a1, a2, a3, a4);
var _ts_parser_included_ranges_wasm = Module["_ts_parser_included_ranges_wasm"] = a0 => (_ts_parser_included_ranges_wasm = Module["_ts_parser_included_ranges_wasm"] = wasmExports["ts_parser_included_ranges_wasm"])(a0);
var _ts_language_type_is_named_wasm = Module["_ts_language_type_is_named_wasm"] = (a0, a1) => (_ts_language_type_is_named_wasm = Module["_ts_language_type_is_named_wasm"] = wasmExports["ts_language_type_is_named_wasm"])(a0, a1);
var _ts_language_type_is_visible_wasm = Module["_ts_language_type_is_visible_wasm"] = (a0, a1) => (_ts_language_type_is_visible_wasm = Module["_ts_language_type_is_visible_wasm"] = wasmExports["ts_language_type_is_visible_wasm"])(a0, a1);
var _ts_tree_root_node_wasm = Module["_ts_tree_root_node_wasm"] = a0 => (_ts_tree_root_node_wasm = Module["_ts_tree_root_node_wasm"] = wasmExports["ts_tree_root_node_wasm"])(a0);
var _ts_tree_root_node_with_offset_wasm = Module["_ts_tree_root_node_with_offset_wasm"] = a0 => (_ts_tree_root_node_with_offset_wasm = Module["_ts_tree_root_node_with_offset_wasm"] = wasmExports["ts_tree_root_node_with_offset_wasm"])(a0);
var _ts_tree_edit_wasm = Module["_ts_tree_edit_wasm"] = a0 => (_ts_tree_edit_wasm = Module["_ts_tree_edit_wasm"] = wasmExports["ts_tree_edit_wasm"])(a0);
var _ts_tree_included_ranges_wasm = Module["_ts_tree_included_ranges_wasm"] = a0 => (_ts_tree_included_ranges_wasm = Module["_ts_tree_included_ranges_wasm"] = wasmExports["ts_tree_included_ranges_wasm"])(a0);
var _ts_tree_get_changed_ranges_wasm = Module["_ts_tree_get_changed_ranges_wasm"] = (a0, a1) => (_ts_tree_get_changed_ranges_wasm = Module["_ts_tree_get_changed_ranges_wasm"] = wasmExports["ts_tree_get_changed_ranges_wasm"])(a0, a1);
var _ts_tree_cursor_new_wasm = Module["_ts_tree_cursor_new_wasm"] = a0 => (_ts_tree_cursor_new_wasm = Module["_ts_tree_cursor_new_wasm"] = wasmExports["ts_tree_cursor_new_wasm"])(a0);
var _ts_tree_cursor_delete_wasm = Module["_ts_tree_cursor_delete_wasm"] = a0 => (_ts_tree_cursor_delete_wasm = Module["_ts_tree_cursor_delete_wasm"] = wasmExports["ts_tree_cursor_delete_wasm"])(a0);
var _ts_tree_cursor_reset_wasm = Module["_ts_tree_cursor_reset_wasm"] = a0 => (_ts_tree_cursor_reset_wasm = Module["_ts_tree_cursor_reset_wasm"] = wasmExports["ts_tree_cursor_reset_wasm"])(a0);
var _ts_tree_cursor_reset_to_wasm = Module["_ts_tree_cursor_reset_to_wasm"] = (a0, a1) => (_ts_tree_cursor_reset_to_wasm = Module["_ts_tree_cursor_reset_to_wasm"] = wasmExports["ts_tree_cursor_reset_to_wasm"])(a0, a1);
var _ts_tree_cursor_goto_first_child_wasm = Module["_ts_tree_cursor_goto_first_child_wasm"] = a0 => (_ts_tree_cursor_goto_first_child_wasm = Module["_ts_tree_cursor_goto_first_child_wasm"] = wasmExports["ts_tree_cursor_goto_first_child_wasm"])(a0);
var _ts_tree_cursor_goto_last_child_wasm = Module["_ts_tree_cursor_goto_last_child_wasm"] = a0 => (_ts_tree_cursor_goto_last_child_wasm = Module["_ts_tree_cursor_goto_last_child_wasm"] = wasmExports["ts_tree_cursor_goto_last_child_wasm"])(a0);
var _ts_tree_cursor_goto_first_child_for_index_wasm = Module["_ts_tree_cursor_goto_first_child_for_index_wasm"] = a0 => (_ts_tree_cursor_goto_first_child_for_index_wasm = Module["_ts_tree_cursor_goto_first_child_for_index_wasm"] = wasmExports["ts_tree_cursor_goto_first_child_for_index_wasm"])(a0);
var _ts_tree_cursor_goto_first_child_for_position_wasm = Module["_ts_tree_cursor_goto_first_child_for_position_wasm"] = a0 => (_ts_tree_cursor_goto_first_child_for_position_wasm = Module["_ts_tree_cursor_goto_first_child_for_position_wasm"] = wasmExports["ts_tree_cursor_goto_first_child_for_position_wasm"])(a0);
var _ts_tree_cursor_goto_next_sibling_wasm = Module["_ts_tree_cursor_goto_next_sibling_wasm"] = a0 => (_ts_tree_cursor_goto_next_sibling_wasm = Module["_ts_tree_cursor_goto_next_sibling_wasm"] = wasmExports["ts_tree_cursor_goto_next_sibling_wasm"])(a0);
var _ts_tree_cursor_goto_previous_sibling_wasm = Module["_ts_tree_cursor_goto_previous_sibling_wasm"] = a0 => (_ts_tree_cursor_goto_previous_sibling_wasm = Module["_ts_tree_cursor_goto_previous_sibling_wasm"] = wasmExports["ts_tree_cursor_goto_previous_sibling_wasm"])(a0);
var _ts_tree_cursor_goto_descendant_wasm = Module["_ts_tree_cursor_goto_descendant_wasm"] = (a0, a1) => (_ts_tree_cursor_goto_descendant_wasm = Module["_ts_tree_cursor_goto_descendant_wasm"] = wasmExports["ts_tree_cursor_goto_descendant_wasm"])(a0, a1);
var _ts_tree_cursor_goto_parent_wasm = Module["_ts_tree_cursor_goto_parent_wasm"] = a0 => (_ts_tree_cursor_goto_parent_wasm = Module["_ts_tree_cursor_goto_parent_wasm"] = wasmExports["ts_tree_cursor_goto_parent_wasm"])(a0);
var _ts_tree_cursor_current_node_type_id_wasm = Module["_ts_tree_cursor_current_node_type_id_wasm"] = a0 => (_ts_tree_cursor_current_node_type_id_wasm = Module["_ts_tree_cursor_current_node_type_id_wasm"] = wasmExports["ts_tree_cursor_current_node_type_id_wasm"])(a0);
var _ts_tree_cursor_current_node_state_id_wasm = Module["_ts_tree_cursor_current_node_state_id_wasm"] = a0 => (_ts_tree_cursor_current_node_state_id_wasm = Module["_ts_tree_cursor_current_node_state_id_wasm"] = wasmExports["ts_tree_cursor_current_node_state_id_wasm"])(a0);
var _ts_tree_cursor_current_node_is_named_wasm = Module["_ts_tree_cursor_current_node_is_named_wasm"] = a0 => (_ts_tree_cursor_current_node_is_named_wasm = Module["_ts_tree_cursor_current_node_is_named_wasm"] = wasmExports["ts_tree_cursor_current_node_is_named_wasm"])(a0);
var _ts_tree_cursor_current_node_is_missing_wasm = Module["_ts_tree_cursor_current_node_is_missing_wasm"] = a0 => (_ts_tree_cursor_current_node_is_missing_wasm = Module["_ts_tree_cursor_current_node_is_missing_wasm"] = wasmExports["ts_tree_cursor_current_node_is_missing_wasm"])(a0);
var _ts_tree_cursor_current_node_id_wasm = Module["_ts_tree_cursor_current_node_id_wasm"] = a0 => (_ts_tree_cursor_current_node_id_wasm = Module["_ts_tree_cursor_current_node_id_wasm"] = wasmExports["ts_tree_cursor_current_node_id_wasm"])(a0);
var _ts_tree_cursor_start_position_wasm = Module["_ts_tree_cursor_start_position_wasm"] = a0 => (_ts_tree_cursor_start_position_wasm = Module["_ts_tree_cursor_start_position_wasm"] = wasmExports["ts_tree_cursor_start_position_wasm"])(a0);
var _ts_tree_cursor_end_position_wasm = Module["_ts_tree_cursor_end_position_wasm"] = a0 => (_ts_tree_cursor_end_position_wasm = Module["_ts_tree_cursor_end_position_wasm"] = wasmExports["ts_tree_cursor_end_position_wasm"])(a0);
var _ts_tree_cursor_start_index_wasm = Module["_ts_tree_cursor_start_index_wasm"] = a0 => (_ts_tree_cursor_start_index_wasm = Module["_ts_tree_cursor_start_index_wasm"] = wasmExports["ts_tree_cursor_start_index_wasm"])(a0);
var _ts_tree_cursor_end_index_wasm = Module["_ts_tree_cursor_end_index_wasm"] = a0 => (_ts_tree_cursor_end_index_wasm = Module["_ts_tree_cursor_end_index_wasm"] = wasmExports["ts_tree_cursor_end_index_wasm"])(a0);
var _ts_tree_cursor_current_field_id_wasm = Module["_ts_tree_cursor_current_field_id_wasm"] = a0 => (_ts_tree_cursor_current_field_id_wasm = Module["_ts_tree_cursor_current_field_id_wasm"] = wasmExports["ts_tree_cursor_current_field_id_wasm"])(a0);
var _ts_tree_cursor_current_depth_wasm = Module["_ts_tree_cursor_current_depth_wasm"] = a0 => (_ts_tree_cursor_current_depth_wasm = Module["_ts_tree_cursor_current_depth_wasm"] = wasmExports["ts_tree_cursor_current_depth_wasm"])(a0);
var _ts_tree_cursor_current_descendant_index_wasm = Module["_ts_tree_cursor_current_descendant_index_wasm"] = a0 => (_ts_tree_cursor_current_descendant_index_wasm = Module["_ts_tree_cursor_current_descendant_index_wasm"] = wasmExports["ts_tree_cursor_current_descendant_index_wasm"])(a0);
var _ts_tree_cursor_current_node_wasm = Module["_ts_tree_cursor_current_node_wasm"] = a0 => (_ts_tree_cursor_current_node_wasm = Module["_ts_tree_cursor_current_node_wasm"] = wasmExports["ts_tree_cursor_current_node_wasm"])(a0);
var _ts_node_symbol_wasm = Module["_ts_node_symbol_wasm"] = a0 => (_ts_node_symbol_wasm = Module["_ts_node_symbol_wasm"] = wasmExports["ts_node_symbol_wasm"])(a0);
var _ts_node_field_name_for_child_wasm = Module["_ts_node_field_name_for_child_wasm"] = (a0, a1) => (_ts_node_field_name_for_child_wasm = Module["_ts_node_field_name_for_child_wasm"] = wasmExports["ts_node_field_name_for_child_wasm"])(a0, a1);
var _ts_node_children_by_field_id_wasm = Module["_ts_node_children_by_field_id_wasm"] = (a0, a1) => (_ts_node_children_by_field_id_wasm = Module["_ts_node_children_by_field_id_wasm"] = wasmExports["ts_node_children_by_field_id_wasm"])(a0, a1);
var _ts_node_first_child_for_byte_wasm = Module["_ts_node_first_child_for_byte_wasm"] = a0 => (_ts_node_first_child_for_byte_wasm = Module["_ts_node_first_child_for_byte_wasm"] = wasmExports["ts_node_first_child_for_byte_wasm"])(a0);
var _ts_node_first_named_child_for_byte_wasm = Module["_ts_node_first_named_child_for_byte_wasm"] = a0 => (_ts_node_first_named_child_for_byte_wasm = Module["_ts_node_first_named_child_for_byte_wasm"] = wasmExports["ts_node_first_named_child_for_byte_wasm"])(a0);
var _ts_node_grammar_symbol_wasm = Module["_ts_node_grammar_symbol_wasm"] = a0 => (_ts_node_grammar_symbol_wasm = Module["_ts_node_grammar_symbol_wasm"] = wasmExports["ts_node_grammar_symbol_wasm"])(a0);
var _ts_node_child_count_wasm = Module["_ts_node_child_count_wasm"] = a0 => (_ts_node_child_count_wasm = Module["_ts_node_child_count_wasm"] = wasmExports["ts_node_child_count_wasm"])(a0);
var _ts_node_named_child_count_wasm = Module["_ts_node_named_child_count_wasm"] = a0 => (_ts_node_named_child_count_wasm = Module["_ts_node_named_child_count_wasm"] = wasmExports["ts_node_named_child_count_wasm"])(a0);
var _ts_node_child_wasm = Module["_ts_node_child_wasm"] = (a0, a1) => (_ts_node_child_wasm = Module["_ts_node_child_wasm"] = wasmExports["ts_node_child_wasm"])(a0, a1);
var _ts_node_named_child_wasm = Module["_ts_node_named_child_wasm"] = (a0, a1) => (_ts_node_named_child_wasm = Module["_ts_node_named_child_wasm"] = wasmExports["ts_node_named_child_wasm"])(a0, a1);
var _ts_node_child_by_field_id_wasm = Module["_ts_node_child_by_field_id_wasm"] = (a0, a1) => (_ts_node_child_by_field_id_wasm = Module["_ts_node_child_by_field_id_wasm"] = wasmExports["ts_node_child_by_field_id_wasm"])(a0, a1);
var _ts_node_next_sibling_wasm = Module["_ts_node_next_sibling_wasm"] = a0 => (_ts_node_next_sibling_wasm = Module["_ts_node_next_sibling_wasm"] = wasmExports["ts_node_next_sibling_wasm"])(a0);
var _ts_node_prev_sibling_wasm = Module["_ts_node_prev_sibling_wasm"] = a0 => (_ts_node_prev_sibling_wasm = Module["_ts_node_prev_sibling_wasm"] = wasmExports["ts_node_prev_sibling_wasm"])(a0);
var _ts_node_next_named_sibling_wasm = Module["_ts_node_next_named_sibling_wasm"] = a0 => (_ts_node_next_named_sibling_wasm = Module["_ts_node_next_named_sibling_wasm"] = wasmExports["ts_node_next_named_sibling_wasm"])(a0);
var _ts_node_prev_named_sibling_wasm = Module["_ts_node_prev_named_sibling_wasm"] = a0 => (_ts_node_prev_named_sibling_wasm = Module["_ts_node_prev_named_sibling_wasm"] = wasmExports["ts_node_prev_named_sibling_wasm"])(a0);
var _ts_node_descendant_count_wasm = Module["_ts_node_descendant_count_wasm"] = a0 => (_ts_node_descendant_count_wasm = Module["_ts_node_descendant_count_wasm"] = wasmExports["ts_node_descendant_count_wasm"])(a0);
var _ts_node_parent_wasm = Module["_ts_node_parent_wasm"] = a0 => (_ts_node_parent_wasm = Module["_ts_node_parent_wasm"] = wasmExports["ts_node_parent_wasm"])(a0);
var _ts_node_descendant_for_index_wasm = Module["_ts_node_descendant_for_index_wasm"] = a0 => (_ts_node_descendant_for_index_wasm = Module["_ts_node_descendant_for_index_wasm"] = wasmExports["ts_node_descendant_for_index_wasm"])(a0);
var _ts_node_named_descendant_for_index_wasm = Module["_ts_node_named_descendant_for_index_wasm"] = a0 => (_ts_node_named_descendant_for_index_wasm = Module["_ts_node_named_descendant_for_index_wasm"] = wasmExports["ts_node_named_descendant_for_index_wasm"])(a0);
var _ts_node_descendant_for_position_wasm = Module["_ts_node_descendant_for_position_wasm"] = a0 => (_ts_node_descendant_for_position_wasm = Module["_ts_node_descendant_for_position_wasm"] = wasmExports["ts_node_descendant_for_position_wasm"])(a0);
var _ts_node_named_descendant_for_position_wasm = Module["_ts_node_named_descendant_for_position_wasm"] = a0 => (_ts_node_named_descendant_for_position_wasm = Module["_ts_node_named_descendant_for_position_wasm"] = wasmExports["ts_node_named_descendant_for_position_wasm"])(a0);
var _ts_node_start_point_wasm = Module["_ts_node_start_point_wasm"] = a0 => (_ts_node_start_point_wasm = Module["_ts_node_start_point_wasm"] = wasmExports["ts_node_start_point_wasm"])(a0);
var _ts_node_end_point_wasm = Module["_ts_node_end_point_wasm"] = a0 => (_ts_node_end_point_wasm = Module["_ts_node_end_point_wasm"] = wasmExports["ts_node_end_point_wasm"])(a0);
var _ts_node_start_index_wasm = Module["_ts_node_start_index_wasm"] = a0 => (_ts_node_start_index_wasm = Module["_ts_node_start_index_wasm"] = wasmExports["ts_node_start_index_wasm"])(a0);
var _ts_node_end_index_wasm = Module["_ts_node_end_index_wasm"] = a0 => (_ts_node_end_index_wasm = Module["_ts_node_end_index_wasm"] = wasmExports["ts_node_end_index_wasm"])(a0);
var _ts_node_to_string_wasm = Module["_ts_node_to_string_wasm"] = a0 => (_ts_node_to_string_wasm = Module["_ts_node_to_string_wasm"] = wasmExports["ts_node_to_string_wasm"])(a0);
var _ts_node_children_wasm = Module["_ts_node_children_wasm"] = a0 => (_ts_node_children_wasm = Module["_ts_node_children_wasm"] = wasmExports["ts_node_children_wasm"])(a0);
var _ts_node_named_children_wasm = Module["_ts_node_named_children_wasm"] = a0 => (_ts_node_named_children_wasm = Module["_ts_node_named_children_wasm"] = wasmExports["ts_node_named_children_wasm"])(a0);
var _ts_node_descendants_of_type_wasm = Module["_ts_node_descendants_of_type_wasm"] = (a0, a1, a2, a3, a4, a5, a6) => (_ts_node_descendants_of_type_wasm = Module["_ts_node_descendants_of_type_wasm"] = wasmExports["ts_node_descendants_of_type_wasm"])(a0, a1, a2, a3, a4, a5, a6);
var _ts_node_is_named_wasm = Module["_ts_node_is_named_wasm"] = a0 => (_ts_node_is_named_wasm = Module["_ts_node_is_named_wasm"] = wasmExports["ts_node_is_named_wasm"])(a0);
var _ts_node_has_changes_wasm = Module["_ts_node_has_changes_wasm"] = a0 => (_ts_node_has_changes_wasm = Module["_ts_node_has_changes_wasm"] = wasmExports["ts_node_has_changes_wasm"])(a0);
var _ts_node_has_error_wasm = Module["_ts_node_has_error_wasm"] = a0 => (_ts_node_has_error_wasm = Module["_ts_node_has_error_wasm"] = wasmExports["ts_node_has_error_wasm"])(a0);
var _ts_node_is_error_wasm = Module["_ts_node_is_error_wasm"] = a0 => (_ts_node_is_error_wasm = Module["_ts_node_is_error_wasm"] = wasmExports["ts_node_is_error_wasm"])(a0);
var _ts_node_is_missing_wasm = Module["_ts_node_is_missing_wasm"] = a0 => (_ts_node_is_missing_wasm = Module["_ts_node_is_missing_wasm"] = wasmExports["ts_node_is_missing_wasm"])(a0);
var _ts_node_is_extra_wasm = Module["_ts_node_is_extra_wasm"] = a0 => (_ts_node_is_extra_wasm = Module["_ts_node_is_extra_wasm"] = wasmExports["ts_node_is_extra_wasm"])(a0);
var _ts_node_parse_state_wasm = Module["_ts_node_parse_state_wasm"] = a0 => (_ts_node_parse_state_wasm = Module["_ts_node_parse_state_wasm"] = wasmExports["ts_node_parse_state_wasm"])(a0);
var _ts_node_next_parse_state_wasm = Module["_ts_node_next_parse_state_wasm"] = a0 => (_ts_node_next_parse_state_wasm = Module["_ts_node_next_parse_state_wasm"] = wasmExports["ts_node_next_parse_state_wasm"])(a0);
var _ts_query_matches_wasm = Module["_ts_query_matches_wasm"] = (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) => (_ts_query_matches_wasm = Module["_ts_query_matches_wasm"] = wasmExports["ts_query_matches_wasm"])(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
var _ts_query_captures_wasm = Module["_ts_query_captures_wasm"] = (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) => (_ts_query_captures_wasm = Module["_ts_query_captures_wasm"] = wasmExports["ts_query_captures_wasm"])(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
var _iswalpha = Module["_iswalpha"] = a0 => (_iswalpha = Module["_iswalpha"] = wasmExports["iswalpha"])(a0);
var _iswblank = Module["_iswblank"] = a0 => (_iswblank = Module["_iswblank"] = wasmExports["iswblank"])(a0);
var _iswdigit = Module["_iswdigit"] = a0 => (_iswdigit = Module["_iswdigit"] = wasmExports["iswdigit"])(a0);
var _iswlower = Module["_iswlower"] = a0 => (_iswlower = Module["_iswlower"] = wasmExports["iswlower"])(a0);
var _iswupper = Module["_iswupper"] = a0 => (_iswupper = Module["_iswupper"] = wasmExports["iswupper"])(a0);
var _iswxdigit = Module["_iswxdigit"] = a0 => (_iswxdigit = Module["_iswxdigit"] = wasmExports["iswxdigit"])(a0);
var _memchr = Module["_memchr"] = (a0, a1, a2) => (_memchr = Module["_memchr"] = wasmExports["memchr"])(a0, a1, a2);
var _strlen = Module["_strlen"] = a0 => (_strlen = Module["_strlen"] = wasmExports["strlen"])(a0);
var _strcmp = Module["_strcmp"] = (a0, a1) => (_strcmp = Module["_strcmp"] = wasmExports["strcmp"])(a0, a1);
var _strncat = Module["_strncat"] = (a0, a1, a2) => (_strncat = Module["_strncat"] = wasmExports["strncat"])(a0, a1, a2);
var _strncpy = Module["_strncpy"] = (a0, a1, a2) => (_strncpy = Module["_strncpy"] = wasmExports["strncpy"])(a0, a1, a2);
var _towlower = Module["_towlower"] = a0 => (_towlower = Module["_towlower"] = wasmExports["towlower"])(a0);
var _towupper = Module["_towupper"] = a0 => (_towupper = Module["_towupper"] = wasmExports["towupper"])(a0);
var _setThrew = (a0, a1) => (_setThrew = wasmExports["setThrew"])(a0, a1);
var __emscripten_stack_restore = a0 => (__emscripten_stack_restore = wasmExports["_emscripten_stack_restore"])(a0);
var __emscripten_stack_alloc = a0 => (__emscripten_stack_alloc = wasmExports["_emscripten_stack_alloc"])(a0);
var _emscripten_stack_get_current = () => (_emscripten_stack_get_current = wasmExports["emscripten_stack_get_current"])();
var dynCall_jiji = Module["dynCall_jiji"] = (a0, a1, a2, a3, a4) => (dynCall_jiji = Module["dynCall_jiji"] = wasmExports["dynCall_jiji"])(a0, a1, a2, a3, a4);
var _orig$ts_parser_timeout_micros = Module["_orig$ts_parser_timeout_micros"] = a0 => (_orig$ts_parser_timeout_micros = Module["_orig$ts_parser_timeout_micros"] = wasmExports["orig$ts_parser_timeout_micros"])(a0);
var _orig$ts_parser_set_timeout_micros = Module["_orig$ts_parser_set_timeout_micros"] = (a0, a1) => (_orig$ts_parser_set_timeout_micros = Module["_orig$ts_parser_set_timeout_micros"] = wasmExports["orig$ts_parser_set_timeout_micros"])(a0, a1);
// include: postamble.js
// === Auto-generated postamble setup entry stuff ===
Module["AsciiToString"] = AsciiToString;
Module["stringToUTF16"] = stringToUTF16;
var calledRun;
dependenciesFulfilled = function runCaller() {
// If run has never been called, and we should call run (INVOKE_RUN is true, and Module.noInitialRun is not false)
if (!calledRun) run();
if (!calledRun) dependenciesFulfilled = runCaller;
};
// try this again later, after new deps are fulfilled
function callMain(args = []) {
var entryFunction = resolveGlobalSymbol("main").sym;
// Main modules can't tell if they have main() at compile time, since it may
// arrive from a dynamic library.
if (!entryFunction) return;
args.unshift(thisProgram);
var argc = args.length;
var argv = stackAlloc((argc + 1) * 4);
var argv_ptr = argv;
args.forEach(arg => {
LE_HEAP_STORE_U32(((argv_ptr) >> 2) * 4, stringToUTF8OnStack(arg));
argv_ptr += 4;
});
LE_HEAP_STORE_U32(((argv_ptr) >> 2) * 4, 0);
try {
var ret = entryFunction(argc, argv);
// if we're not running an evented main loop, it's time to exit
exitJS(ret, /* implicit = */ true);
return ret;
} catch (e) {
return handleException(e);
}
}
function run(args = arguments_) {
if (runDependencies > 0) {
return;
}
preRun();
// a preRun added a dependency, run will be called later
if (runDependencies > 0) {
return;
}
function doRun() {
// run may have just been called through dependencies being fulfilled just in this very frame,
// or while the async setStatus time below was happening
if (calledRun) return;
calledRun = true;
Module["calledRun"] = true;
if (ABORT) return;
initRuntime();
preMain();
Module["onRuntimeInitialized"]?.();
if (shouldRunNow) callMain(args);
postRun();
}
if (Module["setStatus"]) {
Module["setStatus"]("Running...");
setTimeout(function() {
setTimeout(function() {
Module["setStatus"]("");
}, 1);
doRun();
}, 1);
} else {
doRun();
}
}
if (Module["preInit"]) {
if (typeof Module["preInit"] == "function") Module["preInit"] = [ Module["preInit"] ];
while (Module["preInit"].length > 0) {
Module["preInit"].pop()();
}
}
// shouldRunNow refers to calling main(), not run().
var shouldRunNow = true;
if (Module["noInitialRun"]) shouldRunNow = false;
run();
// end include: postamble.js
// include: /src/lib/binding_web/binding.js
/* eslint-disable-next-line spaced-comment */ /// elements
*/
function highlightFe(source) {
if (!ready) return escHtml(source);
var padded = padForParse(source);
var tree = parser.parse(padded.source);
var captures = query.captures(tree.rootNode);
var offset = padded.offset;
// Eagerly read startIndex/endIndex from each capture node BEFORE deleting
// the tree. In web-tree-sitter, endIndex is a lazy getter that reads WASM
// memory — it returns garbage after tree.delete().
var capData = new Array(captures.length);
for (var ci = 0; ci < captures.length; ci++) {
var cap = captures[ci];
capData[ci] = {
si: cap.node.startIndex - offset,
ei: cap.node.endIndex - offset,
name: cap.name
};
}
tree.delete();
// Sort captures by startIndex, then by length descending (outermost first).
// For overlapping captures, innermost (shortest) wins — we process outermost
// first but let innermost overwrite.
capData.sort(function (a, b) {
var d = a.si - b.si;
if (d !== 0) return d;
return (b.ei - b.si) - (a.ei - a.si);
});
// Build an array of character-level capture assignments.
// Only covers original source length — padding captures are ignored.
var len = source.length;
var charCapture = new Array(len);
for (var ci = 0; ci < capData.length; ci++) {
var cd = capData[ci];
for (var k = Math.max(0, cd.si); k < cd.ei && k < len; k++) {
charCapture[k] = cd.name;
}
}
// Walk through source, grouping contiguous runs of the same capture.
var html = "";
var pos = 0;
while (pos < len) {
var capName = charCapture[pos];
var runEnd = pos + 1;
while (runEnd < len && charCapture[runEnd] === capName) runEnd++;
var text = source.slice(pos, runEnd);
if (!capName) {
html += escHtml(text);
} else {
var cssClass = "hl-" + capName.replace(/\./g, "-");
html += '' + escHtml(text) + " ";
}
pos = runEnd;
}
return html;
}
window.FeHighlighter = {
init: init,
isReady: isReady,
highlightFe: highlightFe,
};
// Auto-init on load
init().catch(function (e) {
console.error("[fe-highlighter] init failed:", e);
});
})();
// ============================================================================
// Highlight CSS (injected for shadow DOM adoption — no DOM scanning needed)
// ============================================================================
var __FE_HIGHLIGHT_CSS_INJECTED__ = "/* Fe syntax highlighting — CSS custom properties define all colors.\n Default: Catppuccin Mocha (dark). Light override via prefers-color-scheme\n or data-theme=\"light\". Host pages can override any --fe-* variable. */\n\n/* ============================================================================\n Color variables\n ============================================================================ */\n\n/* Default: Catppuccin Mocha (dark) */\n:root {\n --fe-hl-keyword: #cba6f7;\n --fe-hl-variable-builtin: #94e2d5;\n --fe-hl-type: #f9e2af;\n --fe-hl-type-interface: #cba6f7;\n --fe-hl-type-variant: #f9e2af;\n --fe-hl-function: #89b4fa;\n --fe-hl-string: #a6e3a1;\n --fe-hl-string-escape: #94e2d5;\n --fe-hl-number: #94e2d5;\n --fe-hl-comment: #6c7086;\n --fe-hl-operator: #94e2d5;\n --fe-hl-variable: #a6e3a1;\n --fe-hl-attribute: #cba6f7;\n --fe-hl-constant: #94e2d5;\n --fe-hl-punctuation: #6c7086;\n\n --fe-code-bg: #1e1e2e;\n --fe-code-border: #313244;\n --fe-code-text: #cdd6f4;\n --fe-code-line-number: #6c7086;\n --fe-code-font: \"JetBrains Mono\", \"Fira Code\", monospace;\n --fe-code-size: 0.8rem;\n --fe-code-line-height: 1.6;\n --fe-code-radius: 6px;\n}\n\n/* Light override: Catppuccin Latte — via OS preference */\n@media (prefers-color-scheme: light) {\n :root:not([data-theme=\"dark\"]) {\n --fe-hl-keyword: #7c3aed;\n --fe-hl-variable-builtin: #0891b2;\n --fe-hl-type: #b08800;\n --fe-hl-type-interface: #7c3aed;\n --fe-hl-type-variant: #b08800;\n --fe-hl-function: #2563eb;\n --fe-hl-string: #16a34a;\n --fe-hl-string-escape: #0d9488;\n --fe-hl-number: #0891b2;\n --fe-hl-comment: #9ca0b0;\n --fe-hl-operator: #0891b2;\n --fe-hl-variable: #0d9488;\n --fe-hl-attribute: #7c3aed;\n --fe-hl-constant: #0891b2;\n --fe-hl-punctuation: #6b7280;\n\n --fe-code-bg: #eff1f5;\n --fe-code-border: #ccd0da;\n --fe-code-text: #4c4f69;\n --fe-code-line-number: #9ca0b0;\n }\n}\n\n/* Light override: explicit toggle */\n:root[data-theme=\"light\"] {\n --fe-hl-keyword: #7c3aed;\n --fe-hl-variable-builtin: #0891b2;\n --fe-hl-type: #b08800;\n --fe-hl-type-interface: #7c3aed;\n --fe-hl-type-variant: #b08800;\n --fe-hl-function: #2563eb;\n --fe-hl-string: #16a34a;\n --fe-hl-string-escape: #0d9488;\n --fe-hl-number: #0891b2;\n --fe-hl-comment: #9ca0b0;\n --fe-hl-operator: #0891b2;\n --fe-hl-variable: #0d9488;\n --fe-hl-attribute: #7c3aed;\n --fe-hl-constant: #0891b2;\n --fe-hl-punctuation: #6b7280;\n\n --fe-code-bg: #eff1f5;\n --fe-code-border: #ccd0da;\n --fe-code-text: #4c4f69;\n --fe-code-line-number: #9ca0b0;\n}\n\n/* ============================================================================\n Syntax highlight rules — read variables, no fallbacks\n ============================================================================ */\n\n.hl-keyword { color: var(--fe-hl-keyword); }\n.hl-variable-builtin { color: var(--fe-hl-variable-builtin); font-style: italic; }\n.hl-type, .hl-type-builtin { color: var(--fe-hl-type); }\n.hl-type-interface { color: var(--fe-hl-type-interface); }\n.hl-type-enum-variant { color: var(--fe-hl-type-variant); }\n.hl-function, .hl-function-definition, .hl-function-method { color: var(--fe-hl-function); }\n.hl-string { color: var(--fe-hl-string); }\n.hl-string-escape { color: var(--fe-hl-string-escape); }\n.hl-number { color: var(--fe-hl-number); }\n.hl-comment, .hl-comment-doc { color: var(--fe-hl-comment); font-style: italic; }\n.hl-operator { color: var(--fe-hl-operator); }\n.hl-property, .hl-variable-parameter { color: var(--fe-hl-variable); }\n.hl-variable { color: var(--fe-hl-variable); }\n.hl-attribute { color: var(--fe-hl-attribute); }\n.hl-constant { color: var(--fe-hl-constant); font-weight: bold; }\n.hl-punctuation-bracket, .hl-punctuation-delimiter, .hl-punctuation-special { color: var(--fe-hl-punctuation); }\n\n/* SCIP symbol hover highlight transitions */\n[class*=\"sym-\"] {\n transition: background 0.2s ease-out, text-decoration 0.2s ease-out,\n text-decoration-color 0.2s ease-out;\n}\n\n/* ============================================================================\n component layout\n ============================================================================ */\n\nfe-code-block {\n display: block;\n margin: 1rem 0;\n}\n\n.fe-code-block-wrapper {\n display: flex;\n background: var(--fe-code-bg);\n border: 1px solid var(--fe-code-border);\n border-radius: var(--fe-code-radius);\n overflow-x: auto;\n max-width: 100%;\n}\n\n.member-header fe-code-block,\n.code-header fe-code-block,\n.implementor-sig fe-code-block {\n margin: 0;\n}\n\n.member-header,\n.code-header,\n.implementor-sig {\n --fe-code-border: transparent;\n}\n\n.fe-line-numbers {\n display: flex;\n flex-direction: column;\n padding: 0.75rem 0.5rem;\n border-right: 1px solid var(--fe-code-border);\n text-align: right;\n user-select: none;\n color: var(--fe-code-line-number);\n font-family: var(--fe-code-font);\n font-size: var(--fe-code-size);\n line-height: var(--fe-code-line-height);\n -webkit-text-size-adjust: 100%;\n text-size-adjust: 100%;\n}\n\n.fe-line-numbers span {\n line-height: var(--fe-code-line-height);\n}\n\n.fe-code-pre {\n flex: 1;\n min-width: 0;\n margin: 0;\n padding: 0.75rem 1rem;\n background: transparent;\n overflow-x: auto;\n font-family: var(--fe-code-font);\n font-size: var(--fe-code-size);\n line-height: var(--fe-code-line-height);\n /* Prevent iOS Safari TextAutoSizing from inflating font-size in code blocks.\n Without this, the algorithm selectively enlarges text in blocks whose\n intrinsic width exceeds the viewport (timing-dependent on first load),\n causing inconsistent sizes across code blocks with identical styles.\n Using 100% (not none) preserves user zoom and accessibility settings. */\n -webkit-text-size-adjust: 100%;\n text-size-adjust: 100%;\n}\n\n.fe-code-pre code {\n font-family: inherit;\n font-size: inherit;\n line-height: inherit;\n color: var(--fe-code-text);\n -webkit-text-size-adjust: 100%;\n text-size-adjust: 100%;\n}\n";
// ============================================================================
// Custom elements
// ============================================================================
// — Custom element for syntax-highlighted Fe code blocks.
//
// Raw source text lives in the light DOM and is never destroyed. The
// rendered (highlighted + SCIP-annotated) version lives in an open
// shadow root, so `element.textContent` always returns the original code.
//
// Call `element.refresh()` to re-render with fresh ScipStore data.
//
// Attributes:
// lang — language name (default "fe")
// line-numbers — show line number gutter
// collapsed — start collapsed with /
// symbol — doc path (e.g. "mylib::Game/struct") to fetch source from FE_DOC_INDEX
// region — extract a named region (// #region name ... // #endregion name) from source
// data-file — SCIP source file path for positional symbol resolution
// data-line-offset — 0-based line offset for source excerpts (maps local line 0 to file line N)
// data-scope — SCIP scope path for signature code blocks (set by server)
// Shared CSSStyleSheet adopted by all shadow roots.
//
// In bundled mode (fe-web.js), the CSS is available as _FE_HIGHLIGHT_CSS
// (injected at build time). In standalone mode (external ";
}
function _diGroupByKind(items, kindFn) {
var groups = {}, order = {};
for (var i = 0; i < items.length; i++) {
var k = kindFn(items[i]);
if (!groups[k.key]) {
groups[k.key] = { kind: k.kind, plural: k.plural, items: [] };
order[k.key] = k.order;
}
groups[k.key].items.push(items[i]);
}
var keys = Object.keys(groups);
keys.sort(function (a, b) { return order[a] - order[b]; });
return keys.map(function (k) { return groups[k]; });
}
// ============================================================================
// Component
// ============================================================================
class FeDocItem extends HTMLElement {
static get observedAttributes() {
return ["symbol", "src", "filter", "filter-kind", "exclude", "base", "compact", "show-source"];
}
attributeChangedCallback(name, oldVal, newVal) {
if (oldVal === newVal) return;
if (name === "src") { this._loadSrc(); return; }
this._renderItem();
}
connectedCallback() {
this._loadSrc();
this._renderItem();
}
_loadSrc() {
var src = this.getAttribute("src");
if (!src) return;
var self = this;
feLoadSrc(src).then(function (result) {
self._index = result.index;
self._scip = result.scip;
self._renderItem();
});
}
_getIndex() {
return this._index || window.FE_DOC_INDEX || { items: [], modules: [] };
}
_findItem(path) {
var index = this._getIndex();
if (!index.items) return null;
for (var i = 0; i < index.items.length; i++) {
if (index.items[i].path === path) return index.items[i];
}
return null;
}
_renderItem() {
var symbolPath = this.getAttribute("symbol");
if (!symbolPath) return;
var index = this._getIndex();
if (!index.items || index.items.length === 0) {
if (!feWhenReady(this._renderItem.bind(this))) return;
return;
}
var item = this._findItem(symbolPath);
if (!item) {
this.innerHTML = 'Item not found: ' +
_diEsc(symbolPath) + " ";
return;
}
this.innerHTML = this._renderFull(item);
this._refreshCodeBlocks();
}
// ---- Filtering ----
_matchesFilter(name, path) {
var filter = this.getAttribute("filter");
if (!filter) return true;
var patterns = filter.split(",");
for (var i = 0; i < patterns.length; i++) {
var pat = patterns[i].trim();
if (!pat) continue;
if (pat.endsWith("*")) {
var prefix = pat.slice(0, -1);
if ((path && path.indexOf(prefix) === 0) || name.indexOf(prefix) === 0) return true;
} else {
if (name === pat || path === pat) return true;
}
}
return false;
}
_isExcluded(name, path) {
var exclude = this.getAttribute("exclude");
if (!exclude) return false;
var patterns = exclude.split(",");
for (var i = 0; i < patterns.length; i++) {
var pat = patterns[i].trim();
if (!pat) continue;
if (pat.endsWith("*")) {
var prefix = pat.slice(0, -1);
if ((path && path.indexOf(prefix) === 0) || name.indexOf(prefix) === 0) return true;
} else {
if (name === pat || path === pat) return true;
}
}
return false;
}
_matchesKind(kind) {
var filterKind = this.getAttribute("filter-kind");
if (!filterKind) return true;
var kinds = filterKind.split(",");
for (var i = 0; i < kinds.length; i++) {
if (kinds[i].trim() === kind) return true;
}
return false;
}
_filterChildren(children) {
if (!children) return [];
var result = [];
for (var i = 0; i < children.length; i++) {
var child = children[i];
if (!this._matchesFilter(child.name, child.path)) continue;
if (this._isExcluded(child.name, child.path)) continue;
if (!this._matchesKind(child.kind)) continue;
result.push(child);
}
return result;
}
_filterTraitImpls(impls) {
if (!impls) return [];
var result = [];
for (var i = 0; i < impls.length; i++) {
if (impls[i].trait_name && this._isExcluded(impls[i].trait_name, "")) continue;
result.push(impls[i]);
}
return result;
}
// ---- Full rendering ----
_renderFull(item) {
var compact = this.hasAttribute("compact");
var showSource = this.hasAttribute("show-source");
var isModule = item.kind === "module";
var parentUrl = item.path + "/" + _diKindStr(item.kind);
var html = '';
// Breadcrumbs
html += this._renderBreadcrumbs(item);
// Header
html += '";
// Source link
if (item.source_text && item.source) {
html += '';
html += _diEsc(item.source.display_file || "");
if (item.source.line) html += ':' + item.source.line;
html += ' ';
html += '' + _diEsc(item.source_text) + ' ';
html += '' + _diEsc(item.source.display_file);
if (item.source.line) html += ':' + item.source.line;
html += '
';
}
// Signature (non-modules)
if (!isModule && item.signature && !compact) {
html += '';
html += this._renderSignature(item);
html += '
\u00a7 ';
html += '
";
return html;
}
// Module members
if (isModule) {
html += this._renderModuleMembers(item);
}
// Children (fields, variants, methods)
var children = this._filterChildren(item.children);
if (children.length > 0) {
html += this._renderChildren(children, parentUrl);
}
// Trait implementations
var impls = this._filterTraitImpls(item.trait_impls);
if (impls.length > 0) {
html += this._renderTraitImpls(impls, parentUrl);
}
// Implementors (for trait pages)
if (item.implementors && item.implementors.length > 0) {
html += this._renderImplementors(item.implementors, parentUrl);
}
html += "";
return html;
}
/** Generate href for a doc path. */
_itemHref(docPath) {
var base = this.getAttribute("base") || "";
return base ? base + "#" + docPath : "#" + docPath;
}
/** Generate href for an in-page anchor (parentUrl~anchorId). */
_anchorHref(parentUrl, anchorId) {
return this._itemHref(parentUrl + "~" + anchorId);
}
_renderBreadcrumbs(item) {
var segments = item.path.split("::");
var base = this.getAttribute("base") || "";
var html = '';
var accumulated = "";
for (var i = 0; i < segments.length; i++) {
if (i > 0) {
accumulated += "::";
html += ':: ';
}
accumulated += segments[i];
if (i === segments.length - 1) {
html += '' + _diEsc(segments[i]) + " ";
} else {
var href = base ? base + "#" + accumulated + "/mod" : "#" + accumulated + "/mod";
html += '' +
_diEsc(segments[i]) + " ";
}
}
html += " ";
return html;
}
_renderSignature(item) {
var attrs = 'lang="fe"';
if (item.sig_scope) attrs += ' data-scope="' + _diEsc(item.sig_scope) + '"';
attrs += ' class="signature"';
return "" + _diEsc(item.signature || "") + " ";
}
_renderDocContent(docs, compact) {
var html = '';
var bodyHtml = docs.html_body || _diEsc(docs.body || "");
html += bodyHtml;
if (!compact && docs.sections && docs.sections.length > 0) {
for (var i = 0; i < docs.sections.length; i++) {
var section = docs.sections[i];
var sectionId = "section-" + section.name.toLowerCase().replace(/\s+/g, "-");
html += '
';
html += '
' + _diEsc(section.name) + "
";
var sectionHtml = section.html_content || _diEsc(section.content || "");
html += '
' + sectionHtml + "
";
html += "
";
}
}
html += "
';
for (var g = 0; g < grouped.length; g++) {
var group = grouped[g];
var info = _CHILD_KIND[group.kind] || { anchor: group.kind };
var sectionId = info.anchor + "s";
html += '
';
html += '' + _diEsc(group.plural) +
'\u00a7 ';
html += '';
for (var j = 0; j < group.items.length; j++) {
var child = group.items[j];
var anchorId = info.anchor + "." + child.name;
html += '
';
html += '";
if (child.docs) {
var childHtml = child.docs.html_body || _diEsc(child.docs.body || child.docs.summary || "");
html += '
' + childHtml + "
";
}
html += "
";
}
html += "
";
}
html += "
" + _diEsc(sig) + " ";
}
_renderTraitImpls(impls, parentUrl) {
var traitImpls = [], inherentImpls = [];
for (var i = 0; i < impls.length; i++) {
if (impls[i].trait_name) traitImpls.push(impls[i]);
else inherentImpls.push(impls[i]);
}
var html = '';
if (inherentImpls.length > 0) {
html += '
';
html += 'Implementations' +
'\u00a7 ';
html += '';
for (var ii = 0; ii < inherentImpls.length; ii++) {
html += this._renderImplBlock(inherentImpls[ii], "impl-" + ii, parentUrl);
}
html += "
";
}
if (traitImpls.length > 0) {
html += '
';
html += 'Trait Implementations' +
'\u00a7 ';
html += '';
for (var ti = 0; ti < traitImpls.length; ti++) {
var anchorId = "impl-" + traitImpls[ti].trait_name.replace(/[<> ,]/g, "_");
html += this._renderImplBlock(traitImpls[ti], anchorId, parentUrl);
}
html += "
";
}
html += "
';
html += "';
if (isTraitImpl && impl_.signature) {
var attrs = 'lang="fe" class="impl-signature"';
if (impl_.sig_scope) attrs += ' data-scope="' + _diEsc(impl_.sig_scope) + '"';
html += "
" + _diEsc(impl_.signature) + " ";
}
var methods = this._filterChildren(impl_.methods);
if (methods.length > 0) {
html += '
';
for (var m = 0; m < methods.length; m++) {
var methodAnchor = anchorId + ".method." + methods[m].name;
html += this._renderMethodItem(methods[m], methodAnchor, parentUrl);
}
html += "
";
}
html += "
";
return html;
}
_renderMethodItem(method, anchorId, parentUrl) {
var sigAttrs = 'lang="fe"';
if (method.sig_scope) sigAttrs += ' data-scope="' + _diEsc(method.sig_scope) + '"';
var anchorLink = '\u00a7 ';
var headerHtml = '';
if (method.docs) {
var docsHtml = method.docs.html_body || _diEsc(method.docs.body || method.docs.summary || "");
return '' +
"" + headerHtml + " " +
'' + docsHtml + "
";
}
return '' + headerHtml + "
";
}
_renderImplementors(implementors, parentUrl) {
var html = '';
html += 'Implementors' +
'\u00a7 ';
html += '';
for (var i = 0; i < implementors.length; i++) {
var imp = implementors[i];
var anchorId = "impl-" + imp.type_name.replace(/[<> ,]/g, "_");
html += '
';
var sigAttrs = 'lang="fe"';
if (imp.sig_scope) sigAttrs += ' data-scope="' + _diEsc(imp.sig_scope) + '"';
html += '
' +
_diEsc(imp.signature || "") + ' ';
// ↪ link to the implementation on the type's page
if (imp.type_url && imp.trait_name) {
var implTarget = imp.type_url + "~impl-" + imp.trait_name.replace(/[<> ,]/g, "_");
html += '
\u21AA ';
}
html += '
\u00a7 ';
html += "
";
}
html += "
";
return html;
}
_renderModuleMembers(item) {
var index = this._getIndex();
var modContent = this._findModuleContent(index.modules || [], item.path)
|| this._findModuleContent(index.builtin_modules || [], item.path);
if (!modContent) return "";
var items = modContent.items;
var submodules = modContent.submodules;
if ((!submodules || submodules.length === 0) && (!items || items.length === 0)) return "";
var base = this.getAttribute("base") || "";
var html = '';
if (submodules && submodules.length > 0) {
html += '
';
html += "Modules ";
html += '';
for (var s = 0; s < submodules.length; s++) {
if (this._isExcluded(submodules[s].name, submodules[s].path)) continue;
var href = this._itemHref(submodules[s].path + "/mod");
var modSummary = this._getModuleSummary(index, submodules[s].path);
html += '
';
html += '
";
html += '
' + _diEsc(modSummary) + "
";
html += "
";
}
html += "
";
}
if (items && items.length > 0) {
// Apply filtering
var filtered = [];
for (var f = 0; f < items.length; f++) {
if (this._isExcluded(items[f].name, items[f].path)) continue;
if (!this._matchesKind(items[f].kind)) continue;
filtered.push(items[f]);
}
var grouped = _diGroupByKind(filtered, function (it) {
return {
key: it.kind,
kind: _diKindStr(it.kind),
plural: _diKindPlural(it.kind),
order: _diKindOrder(it.kind),
};
});
for (var g = 0; g < grouped.length; g++) {
var group = grouped[g];
html += '
';
html += "" + _diEsc(group.plural) + " ";
html += '';
for (var j = 0; j < group.items.length; j++) {
var it = group.items[j];
var url = it.path + "/" + _diKindStr(it.kind);
var itemHref = this._itemHref(url);
html += '
';
html += '
";
html += '
' + _diEsc(it.summary || "") + "
";
html += "
";
}
html += "
";
}
}
html += "
— Inline link to a documented Fe symbol.
//
// Usage:
// Game
// — Client-side doc search with fuzzy matching.
//
// Queries window.FE_DOC_INDEX (set by the static doc site shell).
// Renders an input field and a dropdown of matching results.
/** Fuzzy match: checks if all chars of `query` appear in order in `candidate`.
* Returns a score (higher = tighter match) or -1 if no match. */
function _fuzzyScore(query, candidate) {
var qi = 0;
var score = 0;
var lastMatch = -1;
for (var ci = 0; ci < candidate.length && qi < query.length; ci++) {
if (candidate.charAt(ci) === query.charAt(qi)) {
// Bonus for consecutive matches
score += (lastMatch === ci - 1) ? 3 : 1;
// Bonus for matching at start or after separator
if (ci === 0 || candidate.charAt(ci - 1) === ":" || candidate.charAt(ci - 1) === "_") {
score += 2;
}
lastMatch = ci;
qi++;
}
}
return qi < query.length ? -1 : score;
}
class FeSearch extends HTMLElement {
connectedCallback() {
this._timer = null;
this.render();
}
disconnectedCallback() {
if (this._timer) clearTimeout(this._timer);
}
render() {
const container = document.createElement("div");
container.className = "fe-search-container";
const input = document.createElement("input");
input.type = "text";
input.className = "fe-search-input";
input.placeholder = "Search docs\u2026";
input.setAttribute("aria-label", "Search documentation");
const results = document.createElement("div");
results.className = "fe-search-results";
results.setAttribute("role", "listbox");
input.addEventListener("input", () => {
if (this._timer) clearTimeout(this._timer);
this._timer = setTimeout(() => this.search(input.value, results), 150);
});
container.appendChild(input);
container.appendChild(results);
this.appendChild(container);
}
search(query, resultsEl) {
resultsEl.innerHTML = "";
if (!query || query.length < 2) return;
// Try SCIP-powered search first
var scip = window.FE_SCIP;
if (scip) {
try {
var results = JSON.parse(scip.search(query));
if (results.length > 0) {
for (var k = 0; k < results.length; k++) {
var r = results[k];
var a = document.createElement("a");
a.className = "search-result";
a.href = "#" + (r.doc_url || "");
a.setAttribute("role", "option");
var badge = document.createElement("span");
badge.className = "kind-badge";
badge.textContent = this._scipKindName(r.kind);
var nameEl = document.createElement("span");
nameEl.textContent = r.display_name || "";
a.appendChild(badge);
a.appendChild(nameEl);
resultsEl.appendChild(a);
}
return;
}
} catch (_) {
// Fall through to DocIndex search
}
}
// Fallback: DocIndex search with fuzzy matching
var index = window.FE_DOC_INDEX;
if (!index || !index.items) return;
// kind -> URL suffix (mirrors fe-web.js ITEM_KIND_INFO)
var KIND_SUFFIX = {
module: "mod", function: "fn", struct: "struct", enum: "enum",
trait: "trait", contract: "contract", type_alias: "type",
const: "const", impl: "impl", impl_trait: "impl",
};
var q = query.toLowerCase();
var scored = [];
var items = index.items;
for (var i = 0; i < items.length; i++) {
var item = items[i];
var name = (item.name || "").toLowerCase();
var path = (item.path || "").toLowerCase();
// Try exact substring first (highest priority)
if (name.indexOf(q) !== -1) {
scored.push({ item: item, score: 1000 + (name === q ? 500 : 0) });
} else if (path.indexOf(q) !== -1) {
scored.push({ item: item, score: 500 });
} else {
// Fuzzy match on name
var fs = _fuzzyScore(q, name);
if (fs > 0) {
scored.push({ item: item, score: fs });
}
}
}
// Sort by score descending, take top 15
scored.sort(function (a, b) { return b.score - a.score; });
var matches = scored.slice(0, 15);
for (var j = 0; j < matches.length; j++) {
var m = matches[j].item;
var suffix = KIND_SUFFIX[m.kind] || m.kind;
var a = document.createElement("a");
a.className = "search-result";
a.href = "#" + m.path + "/" + suffix;
a.setAttribute("role", "option");
var badge = document.createElement("span");
badge.className = "kind-badge " + (m.kind || "").toLowerCase();
badge.textContent = m.kind || "";
var nameSpan = document.createElement("span");
nameSpan.textContent = m.name || "";
a.appendChild(badge);
a.appendChild(nameSpan);
resultsEl.appendChild(a);
}
}
_scipKindName(kind) {
var names = {
7: "class", 11: "enum", 12: "member", 15: "field",
17: "fn", 26: "method", 49: "struct", 53: "trait", 54: "type",
};
return names[kind] || "sym";
}
}
customElements.define("fe-search", FeSearch);
// — Navigable module tree for Fe documentation.
//
// Renders a hierarchical module tree from docs.json data. Dispatches
// `fe-navigate` events when an item is clicked so the host page controls
// how navigation happens.
//
// Usage:
// ';
if (this.hasAttribute("show-search")) {
html += '
';
}
html += '';
var modules = index.modules || [];
for (var i = 0; i < modules.length; i++) {
html += this._renderModule(modules[i], active);
}
if (index.builtin_modules) {
for (var j = 0; j < index.builtin_modules.length; j++) {
html += this._renderModule(index.builtin_modules[j], active);
}
}
html += '
';
this.innerHTML = html;
// Attach click handlers that dispatch fe-navigate
var links = this.querySelectorAll("a[data-doc-path]");
for (var k = 0; k < links.length; k++) {
links[k].addEventListener("click", function (e) {
e.preventDefault();
var docPath = this.getAttribute("data-doc-path");
var ev = new CustomEvent("fe-navigate", {
bubbles: true, composed: true, cancelable: true,
detail: { docPath: docPath }
});
self.dispatchEvent(ev);
});
}
}
_renderModule(mod, active) {
if (this._isExcluded(mod.path)) return "";
if (!this._matchesFilter(mod.path)) return "";
var modUrl = mod.path + "/mod";
var isCurrent = modUrl === active;
var isExpanded = isCurrent
|| active.indexOf(mod.path + "::") === 0
|| active.indexOf(mod.path + "/") === 0;
var html = '";
html += '';
html += '' + _feEsc(mod.name) + " ";
html += " ";
html += '';
// Sub-modules
if (mod.children) {
for (var i = 0; i < mod.children.length; i++) {
html += this._renderModule(mod.children[i], active);
}
}
// Items, grouped by kind
if (mod.items && mod.items.length > 0) {
var items = this._filterItems(mod.items);
if (items.length > 0) {
var grouped = _feGroupByKind(items);
for (var g = 0; g < grouped.length; g++) {
var group = grouped[g];
html += '
";
}
}
}
html += "
";
return html;
}
_filterItems(items) {
var result = [];
for (var i = 0; i < items.length; i++) {
var item = items[i];
if (this._isExcluded(item.path)) continue;
if (!this._matchesFilter(item.path)) continue;
if (!this._matchesKind(item.kind)) continue;
result.push(item);
}
return result;
}
}
// Shared helpers (keep small, avoid duplicating fe-web.js internals)
var _FE_KIND_INFO = {
module: { str: "mod", plural: "Modules", order: 0 },
function: { str: "fn", plural: "Functions", order: 6 },
struct: { str: "struct", plural: "Structs", order: 3 },
enum: { str: "enum", plural: "Enums", order: 4 },
trait: { str: "trait", plural: "Traits", order: 1 },
contract: { str: "contract", plural: "Contracts", order: 2 },
type_alias: { str: "type", plural: "Type Aliases", order: 5 },
"const": { str: "const", plural: "Constants", order: 7 },
};
function _feKindStr(kind) {
return (_FE_KIND_INFO[kind] || {}).str || kind;
}
function _feEsc(s) {
var d = document.createElement("div");
d.textContent = s;
return d.innerHTML;
}
function _feGroupByKind(items) {
var groups = {};
var order = {};
for (var i = 0; i < items.length; i++) {
var item = items[i];
var info = _FE_KIND_INFO[item.kind] || { str: item.kind, plural: item.kind, order: 99 };
if (!groups[item.kind]) {
groups[item.kind] = { kind: info.str, plural: info.plural, items: [] };
order[item.kind] = info.order;
}
groups[item.kind].items.push(item);
}
var keys = Object.keys(groups);
keys.sort(function (a, b) { return order[a] - order[b]; });
var result = [];
for (var k = 0; k < keys.length; k++) {
result.push(groups[keys[k]]);
}
return result;
}
customElements.define("fe-doc-nav", FeDocNav);
// — Composable documentation viewer for Fe.
//
// Composes + content rendering + routing into a single
// drop-in component. The host page can use this for a full-featured
// doc browser, or use the sub-components individually for custom layouts.
//
// Usage:
// and content
// filter-kind — passed to
// exclude — passed to and content
class FeDocViewer extends HTMLElement {
static get observedAttributes() {
return ["src", "title", "routing", "filter", "filter-kind", "exclude", "lsp"];
}
attributeChangedCallback(name, oldVal, newVal) {
if (oldVal === newVal) return;
if (name === "src") { this._loadSrc(); return; }
this._render();
}
connectedCallback() {
this._createStructure();
this._loadSrc();
this._setupRouting();
this._connectLsp();
}
disconnectedCallback() {
if (this._hashHandler) {
window.removeEventListener("hashchange", this._hashHandler);
this._hashHandler = null;
}
if (this._targetStyle && this._targetStyle.parentNode) {
this._targetStyle.parentNode.removeChild(this._targetStyle);
this._targetStyle = null;
}
if (this._lsp) {
this._lsp.close();
this._lsp = null;
}
}
// ---- LSP Live Mode ----
_connectLsp() {
var lspUrl = this.getAttribute("lsp");
if (!lspUrl || typeof feConnectLsp !== "function") return;
var self = this;
this._lsp = feConnectLsp(lspUrl);
// Listen for doc reload events (hot reload on save)
document.addEventListener("fe-web-ready", function () {
self._index = window.FE_DOC_INDEX;
self._scip = window.FE_SCIP || null;
self._currentPath = null;
var raw = location.hash.replace(/^#\/?/, "");
if (raw) {
var parts = self._splitHash(raw);
self._showItem(parts.path);
} else {
self._showWelcome();
}
});
}
_createStructure() {
this.innerHTML = "";
this.classList.add("fe-doc-viewer");
// Header
var header = document.createElement("div");
header.className = "fe-doc-viewer-header";
this._headerEl = header;
this.appendChild(header);
// Layout container
var layout = document.createElement("div");
layout.className = "fe-doc-viewer-layout";
// Nav wrapper (for sidebar: nav + outline)
var sidebar = document.createElement("div");
sidebar.className = "fe-doc-viewer-sidebar";
var nav = document.createElement("fe-doc-nav");
nav.setAttribute("show-search", "");
// Exclude landing-page example from API reference nav
var existingExclude = this.getAttribute("exclude") || "";
nav.setAttribute("exclude", existingExclude ? existingExclude + ",landing-page" : "landing-page");
this._navEl = nav;
sidebar.appendChild(nav);
// Outline container (populated after content renders)
var outline = document.createElement("div");
outline.className = "page-outline";
this._outlineEl = outline;
sidebar.appendChild(outline);
layout.appendChild(sidebar);
// Content
var content = document.createElement("div");
content.className = "fe-doc-viewer-content";
this._contentEl = content;
layout.appendChild(content);
this.appendChild(layout);
// Mobile menu
this._initMobileMenu();
// Dynamic style element for anchor highlighting
this._targetStyle = document.createElement("style");
document.head.appendChild(this._targetStyle);
// Listen for navigation events from nav and content
var self = this;
this.addEventListener("fe-navigate", function (e) {
var docPath = e.detail.docPath;
if (!docPath) return;
// Prevent the code block from doing its own location.href navigation
e.preventDefault();
e.stopPropagation();
var routing = self.getAttribute("routing") || "hash";
if (routing === "hash") {
var parts = self._splitHash(docPath);
if (parts.path === self._currentPath) {
// Same page — scroll to top or anchor
self._contentEl.scrollTop = 0;
if (parts.anchor) {
self._scrollToAnchor(parts.anchor);
} else {
self._targetStyle.textContent = "";
}
// Update hash without triggering full re-render
history.replaceState(null, "", "#" + docPath);
} else {
location.hash = "#" + docPath;
}
} else if (routing === "path") {
var base = self.getAttribute("base") || "/";
history.pushState(null, "", base + docPath);
self._showItem(docPath);
} else {
self._showItem(docPath);
}
});
}
// ---- Mobile Menu ----
_initMobileMenu() {
var btn = document.createElement("button");
btn.className = "mobile-menu-btn";
btn.textContent = "\u2630";
btn.setAttribute("aria-label", "Toggle navigation");
this.appendChild(btn);
var backdrop = document.createElement("div");
backdrop.className = "sidebar-backdrop";
this.appendChild(backdrop);
var self = this;
function closeSidebar() {
var sidebar = self.querySelector(".fe-doc-viewer-sidebar");
if (sidebar) sidebar.classList.remove("open");
backdrop.classList.remove("open");
}
btn.addEventListener("click", function () {
var sidebar = self.querySelector(".fe-doc-viewer-sidebar");
if (sidebar) {
var isOpen = sidebar.classList.toggle("open");
backdrop.classList.toggle("open", isOpen);
}
});
backdrop.addEventListener("click", closeSidebar);
window.addEventListener("hashchange", closeSidebar);
document.addEventListener("keydown", function (e) {
if (e.key === "Escape") closeSidebar();
});
}
// ---- Data Loading ----
_loadSrc() {
var src = this.getAttribute("src");
var self = this;
if (src) {
if (this._navEl) this._navEl.setAttribute("src", src);
feLoadSrc(src).then(function (result) {
self._index = result.index;
self._scip = result.scip;
self._onDataReady();
});
} else {
// No src attribute — use globals (self-contained static site mode)
var index = window.FE_DOC_INDEX;
if (index) {
this._index = index;
this._scip = window.FE_SCIP || null;
this._onDataReady();
} else {
// Wait for globals to be populated
var onReady = function () {
document.removeEventListener("fe-web-ready", onReady);
self._index = window.FE_DOC_INDEX;
self._scip = window.FE_SCIP || null;
self._onDataReady();
};
document.addEventListener("fe-web-ready", onReady);
}
}
}
_onDataReady() {
this._render();
var routing = this.getAttribute("routing") || "hash";
if (routing === "hash") {
var raw = location.hash.replace(/^#\/?/, "");
if (raw) {
var parts = this._splitHash(raw);
this._currentPath = null;
this._showItem(parts.path);
if (parts.anchor) this._scrollToAnchor(parts.anchor);
} else {
this._showWelcome();
}
} else if (routing === "path") {
var base = this.getAttribute("base") || "/";
var pathname = location.pathname;
if (pathname.indexOf(base) === 0) {
var docPath = pathname.substring(base.length);
if (docPath) {
this._showItem(docPath);
} else {
this._showWelcome();
}
} else {
this._showWelcome();
}
} else {
this._showWelcome();
}
}
// ---- Routing ----
_setupRouting() {
var routing = this.getAttribute("routing") || "hash";
if (routing !== "hash") return;
var self = this;
this._hashHandler = function () {
var raw = location.hash.replace(/^#\/?/, "");
if (raw) {
var parts = self._splitHash(raw);
if (parts.path !== self._currentPath) {
self._showItem(parts.path);
}
if (parts.anchor) {
self._scrollToAnchor(parts.anchor);
} else {
// Clear anchor highlight when navigating without anchor
self._targetStyle.textContent = "";
}
if (self._navEl) self._navEl.setAttribute("active", parts.path);
} else {
self._currentPath = null;
self._showWelcome();
}
};
window.addEventListener("hashchange", this._hashHandler);
}
_splitHash(raw) {
var decoded = decodeURIComponent(raw);
var tilde = decoded.indexOf("~");
if (tilde !== -1) {
return { path: decoded.substring(0, tilde), anchor: decoded.substring(tilde + 1) };
}
return { path: decoded, anchor: null };
}
// ---- Rendering ----
_render() {
if (this._headerEl) {
var html = "";
var backHref = this.getAttribute("back-href");
var backLabel = this.getAttribute("back-label");
if (backHref) {
html += '' +
_feViewerEsc(backLabel || "Back") + " ";
}
var title = this.getAttribute("title");
if (title) {
html += '' + _feViewerEsc(title) + " ";
}
this._headerEl.innerHTML = html;
}
if (this._navEl) {
var attrs = ["filter", "filter-kind"];
for (var i = 0; i < attrs.length; i++) {
var val = this.getAttribute(attrs[i]);
if (val) this._navEl.setAttribute(attrs[i], val);
else this._navEl.removeAttribute(attrs[i]);
}
// Exclude always includes landing-page
var exclude = this.getAttribute("exclude") || "";
this._navEl.setAttribute("exclude", exclude ? exclude + ",landing-page" : "landing-page");
}
}
// ---- Anchor Highlighting ----
_scrollToAnchor(anchorId) {
this._targetStyle.textContent = anchorId
? "#" + CSS.escape(anchorId) + " { background: var(--target-bg, rgba(99,102,241,0.08)); }"
: "";
var self = this;
setTimeout(function () {
if (!self._contentEl) return;
var el = self._contentEl.querySelector("#" + CSS.escape(anchorId));
if (el) el.scrollIntoView({ behavior: "smooth" });
}, 100);
}
// ---- SCIP Ambient Highlighting ----
_applyDefaultHighlight(docPath) {
var scip = this._scip || window.FE_SCIP;
if (!scip || !docPath) {
if (typeof feClearDefaultHighlight === "function") feClearDefaultHighlight();
return;
}
var sym = scip.symbolForDocUrl(docPath);
if (sym) {
feSetDefaultHighlight(scip.symbolHash(sym));
} else {
if (typeof feClearDefaultHighlight === "function") feClearDefaultHighlight();
}
}
// ---- Show Item ----
_showItem(docPath) {
if (!this._contentEl) return;
var index = this._index || window.FE_DOC_INDEX;
if (!index || !index.items) return;
this._currentPath = docPath;
this._targetStyle.textContent = "";
if (this._navEl) this._navEl.setAttribute("active", docPath);
// Find item
var item = this._findByUrl(index, docPath);
if (!item) {
var slashIdx = docPath.lastIndexOf("/");
var typePath = slashIdx !== -1 ? docPath.substring(0, slashIdx) : docPath;
var tildeIdx = typePath.indexOf("~");
if (tildeIdx !== -1) typePath = typePath.substring(0, tildeIdx);
if (typePath.charAt(0) === "(") {
this._contentEl.innerHTML = '' +
'
Compiler-Generated Type ' +
'
' + _feViewerEsc(typePath) + ' ' +
'
This is a compiler-generated type. Tuple types like ' +
_feViewerEsc(typePath) + ' are created automatically by the compiler ' +
'and do not have dedicated documentation pages.
' +
'
Built-in Type: ' + _feViewerEsc(typePath) + ' ' +
'
' + _feViewerEsc(typePath) +
' is a built-in type provided by the compiler. ' +
'Trait implementations for this type are generated automatically.
' +
'
Item Not Found ' +
'
The documentation item ' + _feViewerEsc(docPath) +
' could not be found.
' +
'
It may have been renamed or removed.
var docItem = document.createElement("fe-doc-item");
docItem.setAttribute("symbol", item.path);
// Exclude landing-page from item rendering too
docItem.setAttribute("exclude", this.getAttribute("exclude")
? this.getAttribute("exclude") + ",landing-page" : "landing-page");
if (this.getAttribute("src")) docItem.setAttribute("src", this.getAttribute("src"));
if (this.getAttribute("base")) docItem.setAttribute("base", this.getAttribute("base"));
var filterAttrs = ["filter", "filter-kind"];
for (var i = 0; i < filterAttrs.length; i++) {
var val = this.getAttribute(filterAttrs[i]);
if (val) docItem.setAttribute(filterAttrs[i], val);
}
this._contentEl.innerHTML = "";
this._contentEl.appendChild(docItem);
this._contentEl.scrollTop = 0;
// Update page title
var viewerTitle = this.getAttribute("title") || "Fe Documentation";
document.title = item.name + " \u2014 " + viewerTitle;
// Build outline after content renders
var self = this;
setTimeout(function () {
self._buildOutline();
self._applyDefaultHighlight(docPath);
// Scroll nav active item into view
if (self._navEl) {
var active = self._navEl.querySelector(".current a, .current");
if (active) active.scrollIntoView({ block: "nearest" });
}
}, 150);
}
// ---- In-Page Outline / TOC ----
_clearOutline() {
if (this._outlineEl) this._outlineEl.innerHTML = "";
}
_buildOutline() {
if (!this._outlineEl || !this._contentEl) return;
this._outlineEl.innerHTML = "";
var targets = this._contentEl.querySelectorAll(
"h2[id], details.impl-block[id], details.method-item[id], div.method-item[id]"
);
if (targets.length === 0) return;
var entries = [];
for (var i = 0; i < targets.length; i++) {
var el = targets[i];
var id = el.id;
if (!id) continue;
var text = "";
var level = 0;
var methodDot = id.indexOf(".method.");
if (el.tagName === "H2") {
text = el.textContent.replace("\u00a7", "").trim();
level = 0;
} else if (methodDot !== -1) {
text = id.substring(methodDot + 8) + "()";
level = 2;
} else if (el.classList.contains("impl-block")) {
var h3 = el.querySelector("summary h3");
text = h3 ? h3.textContent.trim() : id;
if (text.length > 50) text = text.substring(0, 47) + "\u2026";
level = 1;
} else {
var heading = el.querySelector("summary h3, summary h4");
text = heading ? heading.textContent.trim()
: (el.querySelector("summary") || el).textContent
.replace("\u00a7", "").replace(/\u25b6/g, "").trim();
if (text.length > 50) text = text.substring(0, 47) + "\u2026";
level = 1;
}
if (id && text) entries.push({ id: id, text: text, level: level });
}
if (entries.length === 0) return;
var header = document.createElement("h4");
header.className = "outline-header";
header.textContent = "On this page";
this._outlineEl.appendChild(header);
var list = document.createElement("ul");
list.className = "outline-list";
var path = this._currentPath || "";
for (var j = 0; j < entries.length; j++) {
var entry = entries[j];
var li = document.createElement("li");
if (entry.level > 0) li.className = "outline-level-" + entry.level;
var a = document.createElement("a");
a.href = "#" + path + "~" + entry.id;
a.textContent = entry.text;
a.dataset.outlineId = entry.id;
li.appendChild(a);
list.appendChild(li);
}
this._outlineEl.appendChild(list);
this._syncOutlineHighlight();
}
_syncOutlineHighlight() {
var raw = location.hash.replace(/^#\/?/, "");
var parts = this._splitHash(raw);
var anchor = parts.anchor;
var links = this._outlineEl ? this._outlineEl.querySelectorAll(".outline-list a") : [];
for (var i = 0; i < links.length; i++) {
links[i].classList.toggle("active", anchor !== null && links[i].dataset.outlineId === anchor);
}
}
// ---- Welcome / Landing ----
_showWelcome() {
if (!this._contentEl) return;
var index = this._index || window.FE_DOC_INDEX;
if (!index) {
this._contentEl.innerHTML = '' +
'
Loading documentation...
' +
'
' + _feViewerEsc(title) + ' ' +
'
No documented items found.