//? <script>
/// import { HTMLBuilder } from "./HTMLBuilder.src";
/// import { OXRParser } from "./OXRParser.src";
/// import { OXRScanner } from "./OXRScanner.src";
/// import { OXRSymbol } from "./OXRSymbol.src";

/// import { credits } from "./credits.src";

/// export
class OXRGenerator {
  static async main(system, ...args) {
    if (args.length != 2) {
      throw new Error("Two arguments required: OberonXref <indir> <outdir>");
    }

    let table = new OXRScanner.Table();

    let modQueue = [];
    let nextModQueue = [];
    let parsedModules = new Map();
    let parsedModulesWithWhitespace = new Map();
    // let disassemblyForModules = new Map(); // TODO
    let importedModules = new Map();
    
    system.log("=== Scanning ===");

    const $normalize = (dirName, fileName) => {
      if (!dirName.endsWith("/")) dirName += "/";
      return dirName + fileName;
    }

    let names = await system.list(args[0]);
    for (let i = 0, n = names.length; i < n; ++i) {
      if (!names[i].endsWith(".Mod") &&
          !names[i].endsWith(".Mod.txt")) {
        continue;
      }

      let path = $normalize(args[0], names[i]);
      system.log(path);
      let code = await system.read(path);
      let allSyms = [];
      let syms = [];
      let rawStringsFound = OXRScanner.scan(code, syms, allSyms, table);
      let sb = "";
      for (const sym of allSyms) {
        sb += sym.text;
      }

      // assert(sb == code)
      let imports = [];
      let modname = OXRParser.findImportedModules(syms, imports, table);
      if (names[i] != modname + ".Mod.txt" && names[i] != modname + ".Mod") {
        throw new Error("Invalid file name " + names[i] + " for " + modname)
      }
      importedModules.set(modname, imports);
      modQueue.push(modname);
      parsedModules.set(modname, syms);
      parsedModulesWithWhitespace.set(modname, allSyms);
      let rscName = modname + ".rsc";
      await system.read(rscName, true).then((contents) => {
        if (!contents) return void(system.log("(no .rsc file)"));
      });
    }

    system.log("=== Parsing ===");

    let publicScopes = new Map();
    async function $doBuiltIn(name) {
      let $ = (name) => (name + ".Mod.txt");
      let code = await system.read($normalize("resources", $(name)));
      let syms = [];
      let allSyms = [];
      OXRScanner.scan(code, syms, allSyms, table);
      let p = new OXRParser(syms, publicScopes, table);
      let modname = p.parseModule();
      if (modname != name) {
        throw new Error("Invalid builtin name " + modname); // XXX
      }
      return allSyms;
    }
    parsedModulesWithWhitespace.set("BUILTINS", await $doBuiltIn("BUILTINS"));
    parsedModulesWithWhitespace.set("SYSTEM", await $doBuiltIn("SYSTEM"));

    let filesToCheck = new Map();
    while (modQueue.length) {
      for (let mod of modQueue) {
        let lastUnresolvedImport = null;
        for (let dep of importedModules.get(mod)) {
          if (!publicScopes.has(dep)) {
            lastUnresolvedImport = dep;
          }
        }
        if (lastUnresolvedImport != null) {
          if (!filesToCheck.has(lastUnresolvedImport)) {
            filesToCheck.set(lastUnresolvedImport, []);
          }
          filesToCheck.get(lastUnresolvedImport).push(mod);
          continue;
        }
        let symbols = parsedModules.get(mod);
        let p = new OXRParser(symbols, publicScopes, table);
        let modname = p.parseModule();
        if (modname != mod) {
          throw new Error("Module name " + modname + " isn't " + mod); // XXX
        }
        let nextMods = filesToCheck.get(mod);
        if (nextMods !== undefined) {
          nextMods.forEach((x) => nextModQueue.push(x));
          filesToCheck.delete(mod);
        }
      }
      modQueue = nextModQueue;
      nextModQueue = [];
    }
    if (filesToCheck.size) throw new Error("Unsatisfied depedencies"); // XXX

    system.log("=== Building symbol usage lists ===");
    let globalLinkAnchors = new Set();
    let usageLinks = new Set();
    let publicLinkReferences = new Map();
    // XXX
    for (let [ n, allSyms ] of parsedModulesWithWhitespace) {
      let htmlFile = n + ".html";
      let localLinks = [];
      for (let s of allSyms) {
        if (s.type == table.IDENTIFIER_TYPE) {
          if (s.link == null) throw new Error(n + ": no link on " + s) // XXX
        } else if (!OXRParser.isAsterisk(s, table) && s.link != null) { // XXX
          throw new Error(n + ": link on " + s); // XXX
        }
        if (s.link != null) {
          if (s.link.startsWith("=")) {
            globalLinkAnchors.add(htmlFile + "#" + s.link.substr(1));
          } else if (s.link.startsWith("#")) {
            localLinks.push(s.link);
          } else {
            let usageFileName = htmlFile.replace(/\.html/, "-usage.html");
            if (s.link.startsWith(usageFileName + "#")) {
              let link = s.link.replace(/-usage\.html#/, ".html#");
              usageLinks.add(link);
              if (!publicLinkReferences.has(link)) {
                publicLinkReferences.set(link, new Set());
              }
            } else {
              if (!publicLinkReferences.has(s.link)) {
                publicLinkReferences.set(s.link, new Set());
              }
              publicLinkReferences.get(s.link).add(htmlFile);
            }
          }
        }
      }
      for (let localLink of localLinks) {
        if (!globalLinkAnchors.has(htmlFile + localLink)) {
          throw new Error("Dangling link " + htmlFile + localLink); // XXX
        }
      }
    }
    for (let globalLink of publicLinkReferences.keys()) {
      if (!usageLinks.has(globalLink)) throw new Error(globalLink); // XXX
      if (!globalLinkAnchors.has(globalLink)) {
        system.log("Dangling link: " + globalLink); // XXX
      }
    }
    for (let usageLink of usageLinks) {
      if (!publicLinkReferences.has(usageLink)) throw new Error; // XXX
    }

    system.log("=== Exporting HTML files ===");
    let hb = new HTMLBuilder(system, args[1]);
    await hb.copyResource("style.css");
    await hb.copyResource("script.js");
    for (let module of parsedModulesWithWhitespace.keys()) {
      system.log(module);
      let allSyms = parsedModulesWithWhitespace.get(module);
      let contents = hb.writeMainFile(module, allSyms, null); // TODO disasm
      let usageRefs = new Map();
      for (let link of publicLinkReferences.keys()) {
        if (link.startsWith(module + ".html#")) {
          let name = link.substr(module.length + (".html#").length);
          usageRefs.set(name, publicLinkReferences.get(link));
        }
      }
      hb.writeUsageFile(module, usageRefs);
    }
    let $ = Array.from;
    hb.writeIndexFile($(parsedModulesWithWhitespace.keys()), importedModules);

    // XXX
    if ("onfinish" in system) {
      system.onfinish.call(null);
    }
  }
}
//? </script>
//? <script>
/// export
class HTMLBuilder {
  constructor(system, directory) {
    if (directory && !directory.endsWith("/")) directory += "/";

    this.system = system;
    this.directory = directory;
  }

  static h(unescaped) {
    return unescaped.
      replace(/&/g, "&amp;").
      replace(/</g, "&lt;").
      replace(/>/g, "&gt;").
      replace(/"/g, "&quot;");
  }

  async copyResource(name) {
    let contents = await this.system.read("resources/" + name);
    await this.system.write(this.directory + name, contents);
  }

  async writeMainFile(module, source, disassembly) {
    let disassemblyRefs = new Map();
    let allExternalLinks = new Map();
    if (disassembly != null) {
      throw new Error("unimplemented"); // TODO
    }
    let allCodePositions = Array.from(disassemblyRefs.keys());
    let mapCodePositionToIndex = new Map();
    for (let i = 0, n = allCodePositions.length; i < n; ++i) {
      mapCodePositionToIndex.set(allCodePositions[i], i);
    }
    for (let sym of source) {
      if (sym.link && sym.link.includes(".html#") &&
          !sym.link.includes("-usage.html#")) {
        let parts = sym.link.split(".html#");
        if (!allExternalLinks.has(parts[0])) {
          allExternalLinks.set(parts[0], new Set());
        }
        allExternalLinks.get(parts[0]).add(parts[1]);
      }
    }

    const { h } = HTMLBuilder;

    let path = this.directory + module + ".html";
    let bw = new HTMLBuilder.Writer(this.system, path); // XXX
    bw.write("<!DOCTYPE html><html><head>\n");
    bw.write("<meta charset=\"UTF-8\">\n");
    bw.write("<title>" + h(module) + " &ndash; OberonXref</title>\n");
    bw.write("<link rel=\"stylesheet\"");
    bw.write(" type=\"text/css\"");
    bw.write(" href=\"style.css\">\n");
    bw.write("<"+"script type=\"text/javascript\"");
    bw.write(" src=\"script.js\"></"+"script>\n");
    bw.write("</head>");
    bw.write("<body>");
    bw.write("<h1>" + h(module) + "</h1><p id=\"togglebuttons\"></p>\n");
    bw.write("<p class=\"usedexports\"><h2>Used Exports</h2>");
    for (let lf of Array.from(allExternalLinks.keys()).sort()) {
      bw.write("<b>" + h(lf) + ":</b>");
      for (let link of Array.from(allExternalLinks.get(lf)).sort()) {
        bw.write(" <a name=" + $name(lf, link));
        bw.write(" href=" + $href(lf, link) + ">" + h(link) + "</a>");
      }
      bw.write("<br>");
    }
    bw.write("</p>\n");

    function $name(target, fragment) {
      return "\"X_" + h(target) + "_" + h(fragment) + "\"";
    }
    function $href(target, fragment) {
      return "\"" + h(target) + ".html#" + h(fragment) + "\"";
    }

    bw.write("<table class=\"sourcecode showsource\">\n"); // TODO disasm
    let assemblyOffsets = [ -1, -1, -1 ];
    let sourceLine = 1;
    let sourcePos = 0;
    let sourceCharPos = 0;
    let nextAssemblyCharPos = (disassemblyRefs.size) ?
      void function() { throw new Error } () : // TODO
      Infinity;
    function $sourceLineAnchor(number, prefix = "") {
      return "\"" + prefix + "L_" + number + "\"";
    }

    function $symbolLinkAttrs(sym) {
      if (sym.link.startsWith("=")) {
        let part = h(sym.link.substr(1));
        var result = "name=\"" + part + "\" href=\"#" + part + "\"";
      } else {
        var result = "href=\"" + h(sym.link) + "\"";
      }
      if (sym.css) {
        result += " style=\"" + h(sym.css) + "\"";
      }
      return result;
    }

    while (sourcePos < source.length) {
      bw.write("<tr class=\"sl\"><th>");
      let $name = (x) => ($sourceLineAnchor(x));
      let $href = (x) => ($sourceLineAnchor(x, "#"));
      bw.write("<a name=" + $name(sourceLine) + " href=" + $href(sourceLine));
      bw.write(" data-l=\"" + sourceLine + "\">");
      bw.write("</th><td>");
      ++sourceLine;
      while (sourcePos < source.length) {
        let s = source[sourcePos];
        ++sourcePos;
        let endTag = "";
        if (nextAssemblyCharPos == sourceCharPos) {
          throw new Error(); /* XXX
          // this.writeDisassemblyRefs(); // XXX
          nextAssemblyCharPos = (disassemblyRefs.size) ?
            void function() { throw new Error } () : // XXX
            Infinity;
          */
        }
        if (s.link) {
          bw.write("<a " + $symbolLinkAttrs(s) + ">");
          endTag = "</a>";
        } else if (s.css) {
          bw.write("<span style=\"" + h(s.css) + "\">");
          endTag = "</span>";
        }
        let textToPrint = s.text;
        while (nextAssemblyCharPos < sourceCharPos + textToPrint.length) {
          throw new Error(); /* XXX
          let prefixLen = nextAssemblyCharPos - sourceCharPos;
          if (textToPrint.substring(0, prefixLen) != "\n") {
            bw.write(h(textToPrint.substring(0, prefixLen)));
          }
          textToPrint = textToPrint.substring(prefixLen);
          sourceCharPos += prefixLen;
          this.writeDisassemblyRefs(); // XXX
          nextAssemblyCharPos = (disassemblyRefs.size) ?
            void function() { throw new Error } () : // XXX
            Infinity;
          */
        }
        sourceCharPos += textToPrint.length;
        if (textToPrint != "\n") {
          bw.write(h(textToPrint));
        }
        if (sourcePos == source.length) {
          if (nextAssemblyCharPos == sourceCharPos) {
            /* this.writeDisassemblyRefs(); // XXX
            nextAssemblyCharPos = (disassemblyRefs.size) ?
              void function() { throw new Error } () : // XXX
              Infinity;
            */
          }
        }
        bw.write(endTag);
        if (s.text == "\n") { // XXX
          break;
        }
      }
      bw.write("</td></tr>\n");
      if (disassembly && assemblyOffsets[2] == -1) {
        throw new Error(); /* XXX
        assemblyOffsets[2] = 0
        printAssembly(); // XXX
        */
      }
      while (assemblyOffsets[1] < assemblyOffsets[0]) {
        throw new Error(); /* XXX
        ++assemblyOffsets[1];
        printAssembly(); // XXX
        */
      }
    }
    while (disassembly && assemblyOffsets[1] <
           disassembly.codeLines.length - 1) {
      throw new Error(); /* XXX
      ++assemblyOffsets[1];
      printAssembly(); // XXX
      */
    }
    if (disassemblyRefs.size > 0) {
      throw new Error(sourceCharPos + "/" + disassemblyRefs); // XXX
    }
    bw.write("</table></body></html>\n");
    await bw.close();
  }

  async writeUsageFile(module, usageRefs) {
    const { h } = HTMLBuilder;

    let exports = Array.from(usageRefs.keys());
    let path = this.directory + module + "-usage.html";
    let bw = new HTMLBuilder.Writer(this.system, path); // XXX
    bw.write("<!DOCTYPE html><html><head>\n");
    bw.write("<meta charset=\"UTF-8\">\n");
    bw.write("<title>" + h(module) + " Usage &ndash; OberonXref</title>\n");
    bw.write("<link rel=\"stylesheet\"");
    bw.write(" type=\"text/css\"");
    bw.write(" href=\"style.css\">\n");
    bw.write("</head><body><h1>" + h(module) + " Usage</h1>\n");
    for (let xport of exports.sort()) {
      bw.write("<h2><a name=\"" + h(xport) + "\">" + h(xport) + "</a></h2>");
      bw.write("<ul>");
      for (let usage of Array.from(usageRefs.get(xport)).sort()) {
        let usageMod = usage.replace(/\.html$/, "");
        bw.write("<li>");
        bw.write("<a href=" + $href(usage, module, xport) + ">");
        bw.write(h(usageMod) + "</a>")
        bw.write("</li>");
      }
      bw.write("</ul>\n");
    }
    bw.write("</body></html>\n");
    await bw.close();

    function $href(prefix, module, suffix) {
      return "\"" + h(prefix) + "#X_" + h(module) + "_" + h(suffix) + "\"";
    }
  }

  async writeIndexFile(modules, importedModules) {
    const { h } = HTMLBuilder;

    let path = this.directory + "index.html";
    let bw = new HTMLBuilder.Writer(this.system, path); // XXX
    bw.write("<!DOCTYPE html><html><head>\n");
    bw.write("<meta charset=\"UTF-8\">\n");
    bw.write("<title>OberonXref</title>\n");
    bw.write("<link rel=\"stylesheet\"");
    bw.write(" type=\"text/css\"");
    bw.write(" href=\"style.css\">\n");
    bw.write("</head><body><h1>OberonXref</h1>\n");
    for (let module of modules.sort()) {
      if (module == "BUILTINS" || module == "SYSTEM") continue;
      bw.write("<p>");
      bw.write("<b>");
      bw.write("<a href=\"" + h(module) + ".html\">" + h(module) + "</a>");
      bw.write("</b>");
      let imported = importedModules.get(module);
      if (imported.length) {
        bw.write(" (Imports:");
        for (let imp of imported) {
          bw.write(" <a href=\"" + h(imp) + ".html\">" + h(imp) + "</a>");
          bw.write("</b>"); // XXX included as bug-for-bug compatibility
        }
        bw.write(")");
      }
      bw.write("</p>\n");
    }
    bw.write("</body></html>\n");
    await bw.close();
  }
}

HTMLBuilder.Writer = class {
  constructor(system, path) {
    this.system = system;
    this.path = path;
    this.contents = [];
  }

  write(something) {
    this.contents.push(something);
  }

  async close() {
    await this.system.write(this.path, this.contents.join(""));
  }
}
//? </script>
//? <script>
/// import { OXRScope } from "./OXRScope.src";

/// export
class OXRParser {
  constructor(program, publicScopes, table) {
    this.program = program;
    this.publicScopes = publicScopes;
    this.currentScope = new OXRScope(publicScopes.get("BUILTINS"), "#", null);
    this.nextSym = 0;
    this.table = table;
  }

  static isAsterisk(symbol, table) { // XXX hack
    return (symbol == table.TIMES) || table.TIMES.isPrototypeOf(symbol);
  }

  static findImportedModules(program, dependenciesToFill, table) {
    let nextSym = 0;
    while (program[nextSym] == table.MODULE ||
           OXRParser.isAsterisk(program[nextSym], table)) {
      ++nextSym;
    }
    if (program[nextSym].type != table.IDENTIFIER_TYPE) {
      return "";
    }
    let moduleName = program[nextSym].text;
    ++nextSym;
    if (program[nextSym] == table.SEMICOLON) {
      ++nextSym;
    }
    if (program[nextSym] == table.IMPORT) {
      ++nextSym;
      while (program[nextSym].type == table.IDENTIFIER_TYPE) {
        let importedModule = program[nextSym].text;
        ++nextSym;
        if (program[nextSym] == table.BECOMES) {
          ++nextSym;
          if (program[nextSym].type != table.IDENTIFIER_TYPE) {
            break;
          }
          importModule = program[nextSym].text;
          ++nextSym;
        }
        dependenciesToFill.push(importedModule);
        if (program[nextSym] == table.COMMA) {
          ++nextSym;
        }
      }
    }
    return moduleName;
  }

  get symbol() {
    return this.program[this.nextSym];
  }

  get sym() {
    return this.symbol.type;
  }

  _expect(ref, error, skip) {
    const { IDENTIFIER_TYPE } = this.table;
    try {
      if (ref == IDENTIFIER_TYPE) {
        if (this.sym != IDENTIFIER_TYPE) {
          throw new Error(error); // XXX
        }
      } else if (this.symbol != ref) {
        throw new Error(error); // XXX
      }
    } catch (ex) {
      if (typeof(__DEBUG__) != "undefined") {
        ex.parser = this;
      }
      throw ex;
    }
    if (skip) {
      ++this.nextSym;
    }
  }

  setDefinitionLink(scope, symbol) {
    symbol.link = "=" + scope.getIdentifierLink(symbol.text).replace(/^#/, "")
  }

  _checkExport(identifier) {
    const $$ = this.table;
    if (OXRParser.isAsterisk(this.symbol, this.table)) {
      let pubScope = this.currentScope.publicScope;
      if (pubScope == null) {
        throw new Error("remove asterisk"); // XXX
      }
      let identType = this.currentScope.getIdentifierType(identifier);
      pubScope.putIdentifier(identifier, identType, null);
      this.setExportUsageLink(this.currentScope, this.symbol, identifier);
      ++this.nextSym;
      return true;
    }
    return false;
  }

  _parseQualifiedIdentifier() {
    const $$ = this.table;
    this._expect($$.IDENTIFIER_TYPE, "identifier expected", false);
    let ident = this.symbol.text;
    this.symbol.link = this.currentScope.getIdentifierLink(ident);
    let ts = new OXRParser.TypeAndScope();
    ts.type = this.currentScope.getIdentifierType(ident);
    ts.scope = this.currentScope.getIdentifierScope(ident);
    ++this.nextSym;
    if (this.symbol == $$.PERIOD &&
        ts.type == OXRScope.IMPORTED_MODULE_ENTRY) {
      ++this.nextSym;
      this._expect($$.IDENTIFIER_TYPE, "identifier expected", false);
      let ident2 = this.symbol.text;
      this.symbol.link = ts.scope.getIdentifierLink(ident2);
      ts.type = ts.scope.getIdentifierType(ident2);
      ts.scope = ts.scope.getIdentifierScope(ident2);
      ++this.nextSym;
    }
    return ts;
  }

  _parseType(topLevel, linkPrefix, exported) {
    const $$ = this.table;
    if (this.sym == $$.IDENTIFIER_TYPE) {
      let ts = this._parseQualifiedIdentifier();
      if (ts.type != OXRScope.TYPE_ENTRY) {
        throw new Error("not a type or undefined"); // XXX
      }
      if (exported && ts.scope.publicScope == null) {
        throw new Error("exporting an allias of an unexported type"); // XXX
      }
      return ts.scope;
    } else if (this.symbol == $$.ARRAY) {
      ++this.nextSym;
      this._parseExpression();
      while (this.symbol == $$.COMMA) {
        ++this.nextSym;
        this._parseExpression();
      }
      this._expect($$.OF, "missing OF", true);
      let part = linkPrefix + ".ARRAY";
      let elemTypeScope = this._parseType(topLevel, part, false);
      let result = new OXRScope(null, linkPrefix + ".", this.currentScope);
      result.putIdentifier("[]", OXRScope.VARIABLE_ENTRY, elemTypeScope);
      if (exported) {
        let pubScope = new OXRScope(null, "@@", this.currentScope);
        result.publicScope = pubScope;
        let etpscope = elemTypeScope.publicScope;
        pubScope.putIdentifier("[]", OXRScope.VARIABLE_ENTRY, etpscope);
      }
      return result;
    } else if (this.symbol == $$.RECORD) {
      if (!topLevel || linkPrefix == null) {
        throw new Error("Anonymous record types are not supported"); // XXX
      }
      ++this.nextSym;
      let baseScope = null;
      if (this.symbol == $$.LPAREN) {
        ++this.nextSym;
        this._expect($$.IDENTIFIER_TYPE, "ident expected", false);
        let baseTypeScope = this._parseQualifiedIdentifier();
        if (baseTypeScope.type != OXRScope.TYPE_ENTRY) {
          throw new Error("type expected"); // XXX
        }
        baseScope = baseTypeScope.scope;
        this._expect($$.RPAREN, "no )", true);
      }
      let part = linkPrefix + ".";
      let resultScope = new OXRScope(baseScope, part, this.currentScope);
      resultScope.putIdentifier(".", OXRScope.VARIABLE_ENTRY, resultScope);
      if (exported) {
        let parent = baseScope && baseScope.publicScope;
        let pubScope = new OXRScope(
          parent, part, this.currentScope.publicScope
        );
        pubScope.putIdentifier(".", OXRScope.VARIABLE_ENTRY, pubScope);
        resultScope.publicScope = pubScope;
      }
      while (this.sym == $$.IDENTIFIER_TYPE) {
        let flds = [];
        while (this.sym == $$.IDENTIFIER_TYPE) {
          let s = this.symbol;
          ++this.nextSym;
          if (OXRParser.isAsterisk(this.symbol, this.table)) {
            let pubScope = resultScope.publicScope;
            if (pubScope == null || !exported) {
              throw new Error("remove asterisk"); // XXX
            }
            flds.push([ s, this.symbol ]);
            ++this.nextSym;
          } else {
            flds.push([ s ]);
          }
          if (this.symbol == $$.COMMA) {
            ++this.nextSym;
          } else if (this.symbol != $$.COLON) {
            throw new Error("comma expected"); // XXX
          }
        }
        this._expect($$.COLON, "colon expected", true);
        let part = linkPrefix + "." + flds[0][0].text;
        let wantExported = flds.some((x) => (x.length == 2));
        let typeScope = this._parseType(topLevel, part, wantExported);
        for (let fld of flds) {
          const { VARIABLE_ENTRY } = OXRScope;
          let identifier = fld[0].text;
          resultScope.putIdentifier(identifier, VARIABLE_ENTRY, typeScope);
          this.setDefinitionLink(resultScope, fld[0]);
          if (fld.length == 2) {
            let pubScope = resultScope.publicScope;
            let tpScope = typeScope.publicScope;
            pubScope.putIdentifier(identifier, VARIABLE_ENTRY, tpScope);
            this.setExportUsageLink(resultScope, fld[1], identifier);
          }
        }
        if (this.symbol == $$.SEMICOLON) {
          ++this.nextSym;
        } else if (this.symbol != $$.END) {
          throw new Error(" ; or END"); // XXX
        }
      }
      this._expect($$.END, "no END", true);
      return resultScope;
    } else if (this.symbol == $$.POINTER) {
      ++this.nextSym;
      this._expect($$.TO, "no TO", true);
      if (this.sym == $$.IDENTIFIER_TYPE) {
        let result = null;
        let ident = this.symbol.text;
        if (topLevel && !this.currentScope.isIdentifierDefined(ident)) {
          result = this.currentScope.makePointerScope(ident);
          this.symbol.link = result.getIdentifierLink("^").
            replace(/\.\^$/, "");
          if (exported) {
            let pub = this.currentScope.publicScope.makePointerScope(ident);
            result.publicScope = pub;
          }
        } else {
          let t = this.currentScope.getIdentifierType(ident);
          if (t == OXRScope.TYPE_ENTRY) {
            let s = this.currentScope.getIdentifierScope(ident);
            let part = ident + ".";
            result = new OXRScope(s, part, this.currentScope);
            result.putIdentifier("^", OXRScope.VARIABLE_ENTRY, s);
            if (s.publicScope != null) {
              let currentPub = this.currentScope.publicScope;
              result.publicScope = new OXRScope(
                s.publicScope, part, currentPub
              );
            }
          } else if (t == OXRScope.IMPORTED_MODULE_ENTRY) {
            throw new Error("external base type not implemented"); // XXX
          } else {
            throw new Error("no valid base type"); // XXX
          }
          this.symbol.link = this.currentScope.getIdentifierLink(ident);
        }
        ++this.nextSym;
        return result;
      } else {
        throw new Error("POINTER TO non-identifier not supported"); // XXX
      }
    } else if (this.symbol == $$.PROCEDURE) {
      if (!topLevel || linkPrefix == null) {
        throw new Error("Anonymous procedure types are not supported"); // XXX
      }
      ++this.nextSym;
      let oldScope = this.currentScope;
      let part = linkPrefix + ".PROCEDURE.";
      this.currentScope = new OXRScope(oldScope, part, oldScope);
      this._parseProcedureType(part);
      this.currentScope = oldScope;
      let result = new OXRScope(null, linkPrefix + "()", this.currentScope);
      let pscope = new OXRScope(null, linkPrefix + "()()", this.currentScope);
      result.putIdentifier("()", OXRScope.VARIABLE_ENTRY, pscope);
      if (exported) {
        let pubScope = new OXRScope(null, "@@", this.currentScope);
        let pscope = new OXRScope(null, "@@", this.currentScope);
        pubScope.putIdentifier("()", OXRScope.VARIABLE_ENTRY, pscope);
        result.publicScope = pubScope;
      }
      return result;
    } else {
      throw new Error("Illegal type"); // XXX
    }
  }

  _parseIdentifierList(identifiers) {
    const $$ = this.table;
    while (this.sym == $$.IDENTIFIER_TYPE) {
      let s = this.symbol;
      ++this.nextSym;
      if (OXRParser.isAsterisk(this.symbol, this.table)) {
        if (this.currentScope.publicScope == null) {
          throw new Error("remove asterisk"); // XXX
        }
        identifiers.push([ s, this.symbol ]);
        ++this.nextSym;
      } else {
        identifiers.push([ s ]);
      }
      if (this.symbol == $$.COMMA) {
        ++this.nextSym;
      } else if (this.symbol != $$.COLON) {
        throw new Error("comma?"); // XXX
      }
    }
    this._expect($$.COLON, ":?", true);
  }

  _parseSelector(ts) {
    const $$ = this.table;
    const { VARIABLE_ENTRY } = OXRScope;
    while (true) {
      if (this.symbol == $$.LBRAK) {
        if (ts.type != VARIABLE_ENTRY ||
            !ts.scope.isIdentifierDefined("[]")) {
          throw new Error("not an array"); // XXX
        }
        ts.scope = ts.scope.getIdentifierScope("[]");
        do {
          ++this.nextSym;
          this._parseExpression();
        } while (this.symbol == $$.COMMA);
        this._expect($$.RBRAK, "no ]", true);
      } else if (this.symbol == $$.PERIOD) {
        ++this.nextSym;
        this._expect($$.IDENTIFIER_TYPE, "ident?", false);
        this.symbol.link = ts.scope.getIdentifierLink(this.symbol.text);
        ts.scope = ts.scope.getIdentifierScope(this.symbol.text);
        ++this.nextSym;
      } else if (this.symbol == $$.ARROW) {
        ++this.nextSym;
        ts.scope = ts.scope.getIdentifierScope("^");
      } else if (this.symbol == $$.LPAREN && ts.type == VARIABLE_ENTRY &&
                 ts.scope.isIdentifierDefined(".")) {
        ++this.nextSym;
        this._expect($$.IDENTIFIER_TYPE, "not an identifier", false);
        let guard = this._parseQualifiedIdentifier();
        if (guard.type != OXRScope.TYPE_ENTRY) {
          throw new Error("guard type expected"); // XXX
        }
        ts.scope = guard.scope;
        this._expect($$.RPAREN, ") missing", true);
      } else {
        break;
      }
    }
  }

  _parseParameterList() {
    const $$ = this.table;
    ++this.nextSym;
    while (this.symbol != $$.RPAREN) {
      this._parseExpression();
      if (this.symbol == $$.COMMA) {
        ++this.nextSym;
      }
    }
    this._expect($$.RPAREN, ") missing", true);
  }

  _parseFactor() {
    const $$ = this.table;
    if (this.sym == $$.IDENTIFIER_TYPE) {
      let ts = this._parseQualifiedIdentifier();
      this._parseSelector(ts);
      if (this.symbol == $$.LPAREN) {
        this._parseParameterList();
      }
    } else if (this.symbol == $$.LPAREN) {
      ++this.nextSym;
      this._parseExpression();
      this._expect($$.RPAREN, "no )", true);
    } else if (this.symbol == $$.LBRACE) {
      ++this.nextSym;
      if (this.symbol != $$.RBRACE) {
        this._parseExpression();
        if (this.symbol == $$.UPTO) {
          ++this.nextSym;
          this._parseExpression();
        }
        while (!this.symbol.isOneOf($$.RBRACE, $$.RBRAK, $$.RPAREN)) {
          if (this.symbol == $$.COMMA) {
            ++this.nextSym;
          } else if (this.symbol != $$.RBRACE) {
            throw new Error("missing comma"); // XXX
          }
          this._parseExpression();
          if (this.symbol == $$.UPTO) {
            ++this.nextSym;
            this._parseExpression();
          }
        }
      }
      this._expect($$.RBRACE, "no }", true);
    } else if (this.symbol == $$.NOT) {
      ++this.nextSym;
      this._parseFactor();
    } else if (this.symbol.isOneOf($$.NIL, $$.FALSE, $$.TRUE) ||
               this.sym == $$.CONSTANT_TYPE) {
      ++this.nextSym;
    } else {
      throw new Error("Not a factor"); // XXX
    }
  }

  _parseExpression() {
    const $$ = this.table;
    while (true) {
      if (this.symbol.isOneOf($$.PLUS, $$.MINUS)) {
        ++this.nextSym;
      }
      this._parseFactor();
      if (!OXRParser.isAsterisk(this.symbol, $$) && !this.symbol.isOneOf(
            $$.AND, $$.MINUS, $$.PLUS, $$.RDIV, $$.DIV, $$.MOD, $$.OR, $$.EQL,
            $$.GEQ, $$.GTR, $$.LEQ, $$.LSS, $$.NEQ, $$.IN
          )) {
        break;
      }
      ++this.nextSym;
    }
    if (this.symbol == $$.IS) {
      ++this.nextSym;
      let ts = this._parseQualifiedIdentifier();
      if (ts.type != OXRScope.TYPE_ENTRY) {
        throw new Error("not a type"); // XXX
      }
    }
  }

  _isAsterisk(symbol) {
    return this.table.TIMES.isPrototypeOf(symbol);
  }

  _parseFormalType(linkPrefix) {
    const $$ = this.table;
    const { VARIABLE_ENTRY } = OXRScope;
    if (this.sym == $$.IDENTIFIER_TYPE) {
      let ts = this._parseQualifiedIdentifier();
      if (ts.type != OXRScope.TYPE_ENTRY) {
        throw new Error("not a type"); // XXX
      }
      return ts.scope;
    } else if (this.symbol == $$.ARRAY) {
      ++this.nextSym;
      this._expect($$.OF, "OF ?", true);
      let result = new OXRScope(null, linkPrefix + ".", this.currentScope);
      result.putIdentifier(
        "[]", VARIABLE_ENTRY, this._parseFormalType(linkPrefix + ".ARRAY")
      );
      return result;
    } else if (this.symbol == $$.PROCEDURE) {
      ++this.nextSym;
      let oldScope = this.currentScope;
      this.currentScope = new OXRScope(oldScope, linkPrefix + ".", oldScope);
      this._parseProcedureType(linkPrefix + ".PROCEDURE");
      this.currentScope = oldScope;
      let result = new OXRScope(null, "@@", null);
      result.putIdentifier(
        "()", VARIABLE_ENTRY, new OXRScope(null, "@@", null)
      );
      return result;
    } else {
      throw new Error("identifier expected"); // XXX
    }
  }

  _parseProcedureType(linkPrefix) {
    const $$ = this.table;
    const { VARIABLE_ENTRY } = OXRScope;
    if (this.symbol != $$.LPAREN) {
      return;
    }
    ++this.nextSym;
    if (this.symbol == $$.VAR) {
      ++this.nextSym;
    }
    while (this.sym == $$.IDENTIFIER_TYPE) {
      let idents = [];
      this._parseIdentifierList(idents);
      let typeScope = this._parseFormalType(linkPrefix);
      for (let ident of idents) {
        if (ident.length == 2) {
          throw new Error("Exported procedure parameter?"); // XXX
        }
        let { text } = ident[0];
        this.currentScope.putIdentifier(text, VARIABLE_ENTRY, typeScope);
        this.setDefinitionLink(this.currentScope, ident[0]);
      }
      if (this.symbol == $$.RPAREN) break;
      this._expect($$.SEMICOLON, "no ;", true);
      if (this.symbol == $$.VAR) {
        ++this.nextSym;
      }
    }
    this._expect($$.RPAREN, "no )", true);
    if (this.symbol == $$.COLON) {
      ++this.nextSym;
      this._expect($$.IDENTIFIER_TYPE, "type identifier expected", false);
      let ts = this._parseQualifiedIdentifier();
      if (ts.type != OXRScope.TYPE_ENTRY) {
        throw new Error("illegal function type"); // XXX
      }
    }
  }

  _parseStatementSequence() {
    const $$ = this.table;
    const { VARIABLE_ENTRY } = OXRScope;
    while (true) {
      if (this.sym == $$.IDENTIFIER_TYPE) {
        let ts = this._parseQualifiedIdentifier();
        this._parseSelector(ts);
        if (this.symbol == $$.BECOMES) {
          ++this.nextSym;
          this._parseExpression();
        } else if (this.symbol == $$.EQL) {
          throw new Error("should be :="); // XXX
        } else if (this.symbol == $$.LPAREN) {
          this._parseParameterList();
        }
      } else if (this.symbol == $$.IF) {
        ++this.nextSym;
        this._parseExpression();
        this._expect($$.THEN, "no THEN", true);
        this._parseStatementSequence();
        while (this.symbol == $$.ELSIF) {
          ++this.nextSym;
          this._parseExpression();
          this._expect($$.THEN, "no THEN", true);
          this._parseStatementSequence();
        }
        if (this.symbol == $$.ELSE) {
          ++this.nextSym;
          this._parseStatementSequence();
        }
        this._expect($$.END, "no END", true);
      } else if (this.symbol == $$.WHILE) {
        ++this.nextSym;
        this._parseExpression();
        this._expect($$.DO, "no DO", true);
        this._parseStatementSequence();
        while (this.symbol == $$.ELSIF) {
          ++this.nextSym;
          this._parseExpression();
          this._expect($$.DO, "no DO", true);
          this._parseStatementSequence();
        }
        this._expect($$.END, "no END", true);
      } else if (this.symbol == $$.REPEAT) {
        ++this.nextSym;
        this._parseStatementSequence();
        this._expect($$.UNTIL, "missing UNTIL", true);
        this._parseExpression();
      } else if (this.symbol == $$.FOR) {
        ++this.nextSym;
        this._expect($$.IDENTIFIER_TYPE, "identifier expected", false);
        this._parseQualifiedIdentifier();
        this._expect($$.BECOMES, ":= expected", true);
        this._parseExpression();
        this._expect($$.TO, "no TO", true);
        this._parseExpression();
        if(this.symbol == $$.BY) {
          ++this.nextSym;
          this._parseExpression();
        }
        this._expect($$.DO, "no DO", true);
        this._parseStatementSequence();
        this._expect($$.END, "no END", true);
      } else if (this.symbol == $$.CASE) {
        ++this.nextSym;
        this._expect($$.IDENTIFIER_TYPE, "ident expected", false);
        let ident = this.symbol.text;
        this.symbol.link = this.currentScope.getIdentifierLink(ident);
        if (this.currentScope.getIdentifierType(ident) != VARIABLE_ENTRY) {
          throw new Error("var expected"); // XXX
        }
        ++this.nextSym;
        this._expect($$.OF, "OF expected", true);
        while (this.sym == $$.IDENTIFIER_TYPE) {
          let newTypeTS = this._parseQualifiedIdentifier();
          if (newTypeTS.type != OXRScope.TYPE_ENTRY) {
            throw new Error("type expected"); // XXX
          }
          this._expect($$.COLON, ": expected", true);
          let oldScope = this.currentScope;
          let newScope = new OXRScope(oldScope, "", oldScope);
          newScope.putIdentifier(ident, VARIABLE_ENTRY, newTypeTS.scope);
          this.currentScope = newScope;
          this._parseStatementSequence();
          this.currentScope = oldScope;
          if (this.symbol == $$.END) {
            break;
          }
          this._expect($$.BAR, "no END", true); // XXX
        }
        this._expect($$.END, "no END", true);
      }
      if (this.symbol == $$.SEMICOLON) {
        ++this.nextSym;
      } else {
        break;
      }
    }
  }

  _parseDeclarations() {
    const $$ = this.table;
    const { TYPE_ENTRY } = OXRScope;
    const { VARIABLE_ENTRY } = OXRScope;
    if (this.symbol == $$.CONST) {
      ++this.nextSym;
      while (this.sym == $$.IDENTIFIER_TYPE) {
        let cnst = this.symbol.text;
        this.currentScope.putIdentifier(cnst, OXRScope.CONSTANT_ENTRY, null);
        this.setDefinitionLink(this.currentScope, this.symbol);
        ++this.nextSym;
        this._checkExport(cnst);
        this._expect($$.EQL, "= ?", true);
        this._parseExpression();
        this._expect($$.SEMICOLON, ";missing", true);
      }
    }
    if (this.symbol == $$.TYPE) {
      ++this.nextSym;
      while (this.sym == $$.IDENTIFIER_TYPE) {
        let symbol = this.symbol;
        let identifier = this.symbol.text;
        ++this.nextSym;
        let exportSymbol = null;
        if (OXRParser.isAsterisk(this.symbol, this.table)) {
          if (this.currentScope.publicScope == null) {
            throw new Error("remove asterisk"); // XXX
          }
          exportSymbol = this.symbol;
          ++this.nextSym;
        }
        this._expect($$.EQL, "=?", true);
        let typeScope = this._parseType(true, identifier, !!exportSymbol);
        this.currentScope.putIdentifier(identifier, TYPE_ENTRY, typeScope);
        if (exportSymbol != null) {
          let pubScope = this.currentScope.publicScope;
          let identPubScope = typeScope.publicScope;
          if (identPubScope == null) {
            throw new Error("INTERNAL: exported has no public scope"); // XXX
          }
          pubScope.putIdentifier(identifier, TYPE_ENTRY, identPubScope);
          identPubScope.publicScope = identPubScope;
        }
        this.setDefinitionLink(this.currentScope, symbol);
        this.setExportUsageLink(this.currentScope, exportSymbol, identifier);
        this._expect($$.SEMICOLON, "; missing", true);
      }
    }
    if (this.symbol == $$.VAR) {
      ++this.nextSym;
      while (this.sym == $$.IDENTIFIER_TYPE) {
        let vars = [];
        this._parseIdentifierList(vars);
        let { text } = vars[0][0];
        let wantExported = vars.some((x) => (x.length == 2));
        let typeScope = this._parseType(true, text, wantExported);
        for (let vrbl of vars) {
          let ident = vrbl[0].text;
          this.currentScope.putIdentifier(ident, VARIABLE_ENTRY, typeScope);
          this.setDefinitionLink(this.currentScope, vrbl[0]);
          if (vrbl.length == 2) {
            let pubScope = this.currentScope.publicScope;
            let typePubScope = typeScope.publicScope;
            pubScope.putIdentifier(ident, VARIABLE_ENTRY, typePubScope);
            this.setExportUsageLink(this.currentScope, vrbl[1], ident);
          }
        }
        this._expect($$.SEMICOLON, "; missing", true);
      }
    }
  }

  setExportUsageLink(scope, exportSymbol, identifier) {
    if (exportSymbol != null) {
      let link = scope.publicScope.getIdentifierLink(identifier);

      if (exportSymbol == this.table.TIMES) throw new Error("bad *"); // XXX
      Object.defineProperty(exportSymbol, "link", { // XXX hack
        writable: true,
        value: null
      });

      exportSymbol.link = link.replace(".html#", "-usage.html#");
    }
  }

  _parseProcedureDeclaration() {
    const $$ = this.table;
    ++this.nextSym;
    if (OXRParser.isAsterisk(this.symbol, this.table)) {
      ++this.nextSym;
    }
    this._expect($$.IDENTIFIER_TYPE, "identifier expected", false);
    let procid = this.symbol.text;
    this.currentScope.putIdentifier(procid, OXRScope.PROCEDURE_ENTRY, null);
    this.setDefinitionLink(this.currentScope, this.symbol);
    ++this.nextSym;
    this._checkExport(procid);
    let oldScope = this.currentScope;
    this.currentScope = new OXRScope(
      oldScope, procid + ".PROCEDURE.", oldScope
    );
    this._parseProcedureType(procid + ".PROCEDURE.");
    this._expect($$.SEMICOLON, "no ;", true);
    this._parseDeclarations();
    while (this.symbol == $$.PROCEDURE) {
      this._parseProcedureDeclaration();
      this._expect($$.SEMICOLON, "no ;", true);
    }
    if (this.symbol == $$.BEGIN) {
      ++this.nextSym;
      this._parseStatementSequence();
    }
    if (this.symbol == $$.RETURN) {
      ++this.nextSym;
      this._parseExpression();
    }
    this.currentScope = oldScope;
    this._expect($$.END, "no END", true);
    this._expect($$.IDENTIFIER_TYPE, "no proc id", false);
    if (this.symbol.text != procid) {
      throw new Error("no match"); // XXX
    }
    this.symbol.link = this.currentScope.getIdentifierLink(procid);
    ++this.nextSym;
  }

  parseModule() {
    const $$ = this.table;
    const { IMPORTED_MODULE_ENTRY } = OXRScope;
    this._expect($$.MODULE, "must start with MODULE", true);
    if (OXRParser.isAsterisk(this.symbol, this.table)) {
      ++this.nextSym;
    }
    this._expect($$.IDENTIFIER_TYPE, "identifier expected", false);
    let moduleName = this.symbol.text;
    this.symbol.link = "=MODULE";
    ++this.nextSym;
    this._expect($$.SEMICOLON, "no ;", true);
    if (this.symbol == $$.IMPORT) {
      ++this.nextSym;
      while (this.sym == $$.IDENTIFIER_TYPE) {
        let localName = this.symbol.text;
        let importedModule = localName;
        this.symbol.link = "=" + localName;
        ++this.nextSym;
        if (this.symbol == $$.BECOMES) {
          ++this.nextSym;
          this._expect($$.IDENTIFIER_TYPE, "id expected", false);
          importedModule = this.symbol.text;
          this.symbol.link = importedModule + ".html";
          ++this.nextSym;
        }
        if (!this.publicScopes.has(importedModule)) {
          throw new Error("Importing unknown module: " + importedModule)// XXX
        }
        let s = this.publicScopes.get(importedModule);
        this.currentScope.putIdentifier(localName, IMPORTED_MODULE_ENTRY, s);
        if (this.symbol != $$.SEMICOLON) {
          this._expect($$.COMMA, "comma missing", true);
        }
      }
      this._expect($$.SEMICOLON, "no ;", true);
    }
    let pubScope = new OXRScope(null, moduleName + ".html#", null);
    this.currentScope.publicScope = pubScope;
    this.publicScopes.set(moduleName, pubScope);
    this._parseDeclarations();
    while (this.symbol == $$.PROCEDURE) {
      this._parseProcedureDeclaration();
      this._expect($$.SEMICOLON, "no ;", true);
    }
    if (this.symbol == $$.BEGIN) {
      ++this.nextSym;
      this._parseStatementSequence();
    }
    this._expect($$.END, "no END", true);
    this._expect($$.IDENTIFIER_TYPE, "identifier missing", false);
    if (this.symbol.text != moduleName) {
      throw new Error("no match"); // XXX
    }
    this.symbol.link = "#MODULE";
    ++this.nextSym;
    this._expect($$.PERIOD, "period missing", false);
    return moduleName;
  }
}

OXRParser.TypeAndScope = class {
  constructor(type = null, scope = null) {
    this.type = type;
    this.scope = scope;
  }
}
//? </script>
//? <script>
/// export
class OXRScope {
  constructor(parent, prefixPart, prefixScope) {
    this.parent = parent;
    this.linkPrefix = getAntecedent(prefixScope) + prefixPart;

    function getAntecedent(scope) {
      if (scope == null) return "";
      return scope.linkPrefix;
    }

    this.publicScope = null;
    this.identifierTypes = new Map();
    this.identifierScopes = new Map();
    this.unresolvedPointerTypes = new Map();
  }

  putIdentifier(ident, type, scope) {
    if (this.identifierTypes.has(ident)) {
      throw new Error("Duplicate identifier " + ident); // XXX
    }
    this.identifierTypes.set(ident, type);
    if (scope != null) {
      this.identifierScopes.set(ident, scope);
    }
    if (type == OXRScope.TYPE_ENTRY) {
      let pointerScope = this.unresolvedPointerTypes.get(ident);
      if (pointerScope !== undefined) {
        pointerScope.parent = scope;
        pointerScope.identifierScopes.set("^", scope);
        this.unresolvedPointerTypes.delete(ident);
      }
    }
  }

  makePointerScope(pointerOf) {
    let pointerScope = new OXRScope(null, pointerOf + ".", this);
    pointerScope.putIdentifier("^", OXRScope.VARIABLE_ENTRY, pointerScope);
    if (this.identifierTypes.has(pointerOf)) {
      let identScope = this.getIdentifierScope(pointerOf);
      pointerScope.parent = identScope;
      pointerScope.identifierScopes.set("^", identScope);
    } else {
      this.unresolvedPointerTypes.set(pointerOf, pointerScope);
    }
    return pointerScope;
  }

  isIdentifierDefined(ident) {
    if (this.identifierTypes.has(ident)) return true;
    return this.parent && this.parent.isIdentifierDefined(ident);
  }

  getIdentifierType(ident) {
    if (this.identifierTypes.has(ident)) {
      return this.identifierTypes.get(ident);
    }
    if (this.parent) return this.parent.getIdentifierType(ident);
    throw new Error("No such element " + ident); // XXX
  }

  getIdentifierScope(ident) {
    if (this.identifierTypes.has(ident)) {
      return this.identifierScopes.get(ident) || null;
    }
    if (this.parent) return this.parent.getIdentifierScope(ident);
    throw new Error("No such element " + ident); // XXX
  }

  getIdentifierLink(ident) {
    const $doReallyGetIt = (ident) => {
      if (this.identifierTypes.has(ident)) return this.linkPrefix + ident;
      if (this.parent) return this.parent.getIdentifierLink(ident);
      throw new Error("No such element " + ident); // XXX
    }

    let link = $doReallyGetIt(ident);
    if (link.indexOf("@@") >= 0) {
      throw new Error("Invalid link: " + link); // XXX
    }
    return link;
  }
}

OXRScope.CONSTANT_ENTRY = 1;
OXRScope.VARIABLE_ENTRY = 2;
OXRScope.TYPE_ENTRY = 3;
OXRScope.IMPORTED_MODULE_ENTRY = 4;
OXRScope.PROCEDURE_ENTRY = 5;
//? </script>
//? <script>
/// import { OXRSymbol } from "./OXRSymbol.src";

/// export
class OXRScanner {
  static scan(text, meaningfulSymbols, allSymbols, table) {
    let s = new OXRScanner(text, table);

    const { COMMENT_TYPE } = table;
    const { LINEBREAK_TYPE } = table;
    const { WHITESPACE_TYPE } = table;

    allSymbols.push(...s.result);
    meaningfulSymbols.push(...(s.result.filter(
      (x) => (!x.hasTypeOneOf(COMMENT_TYPE, WHITESPACE_TYPE, LINEBREAK_TYPE))
    )));

    return s.rawStringsFound;
  }

  constructor(text, table = new OXRScanner.Table()) {
    this.text = text;
    this.nextPos = 0;

    this.keywords = new Map();
    this.singleSymbols = new Map();
    this.doubleSymbols = new Map();

    this.rawStringsFound = false;

    this._symbols = [];

    this.table = this.collate(table);
  }

  collate(table) {
    const { KEYWORD_TYPE } = table;

    function $setLinkNotAllowed() {
      throw new Error("link not allowed for symbol " + this); // XXX
    }

    const $sift = (symbol) => {
      if (symbol.type == KEYWORD_TYPE) {
        this.keywords.set(symbol.text, symbol);
      } else if (symbol.text.length > 1) {
        // assert(symbol.text.length == 2)
        this.doubleSymbols.set(symbol.text, symbol);
      } else {
        // assert(symbol.text.length == 1)
        this.singleSymbols.set(symbol.text, symbol);
      }
      Object.defineProperty(symbol, "link", {
        configurable: true,
        set: $setLinkNotAllowed
      });
    }

    $sift(table.ARRAY);
    $sift(table.BEGIN);
    $sift(table.BY);
    $sift(table.CASE);
    $sift(table.CONST);
    $sift(table.DIV);
    $sift(table.DO);
    $sift(table.ELSE);
    $sift(table.ELSIF);
    $sift(table.END);
    $sift(table.FALSE);
    $sift(table.FOR);
    $sift(table.IF);
    $sift(table.IMPORT);
    $sift(table.IN);
    $sift(table.IS);
    $sift(table.MOD);
    $sift(table.MODULE);
    $sift(table.NIL);
    $sift(table.OF);
    $sift(table.OR);
    $sift(table.POINTER);
    $sift(table.PROCEDURE);
    $sift(table.RECORD);
    $sift(table.REPEAT);
    $sift(table.RETURN);
    $sift(table.THEN);
    $sift(table.TO);
    $sift(table.TRUE);
    $sift(table.TYPE);
    $sift(table.UNTIL);
    $sift(table.VAR);
    $sift(table.WHILE);

    $sift(table.NEQ);
    $sift(table.AND);
    $sift(table.RPAREN);
    $sift(table.TIMES);
    $sift(table.PLUS);
    $sift(table.COMMA);
    $sift(table.MINUS);
    $sift(table.RDIV);
    $sift(table.SEMICOLON);
    $sift(table.EQL);
    $sift(table.LBRAK);
    $sift(table.RBRAK);
    $sift(table.ARROW);
    $sift(table.LBRACE);
    $sift(table.RBRACE);
    $sift(table.BAR);
    $sift(table.NOT);
    $sift(table.PERIOD);
    $sift(table.UPTO);
    $sift(table.COLON);
    $sift(table.BECOMES);
    $sift(table.GTR);
    $sift(table.GEQ);
    $sift(table.LSS);
    $sift(table.LEQ);

    return table;
  }

  get result() {
    if (!this._symbols.length) {
      this._start();
    }
    return this._symbols;
  }

  _start() {
    const { LINEBREAK_TYPE } = this.table;
    const { WHITESPACE_TYPE } = this.table;
    const { LPAREN } = this.table;
    while (this.nextPos < this.text.length) {
      let ch = this.next;
      if (ch == "\n") {
        this._symbols.push(new OXRSymbol(LINEBREAK_TYPE, "\n"));
        ++this.nextPos;
      } else if (ch <= " ") {
        let which = this.text.substring(this.nextPos, this.nextPos + 1);
        this._symbols.push(new OXRSymbol(WHITESPACE_TYPE, which));
        ++this.nextPos;
      } else if (ch >= "0" && ch <= "9") {
        this._symbols.push(this._scanNumber());
      } else if ((ch >= "A" && ch <= "Z") ||
                 (ch >= "a" && ch <= "z")) {
        this._symbols.push(this._scanIdentifier());
      } else if (ch == "\"" || ch == "$") {
        if (ch == "$") {
          this.rawStringsFound = true;
        }
        this._symbols.push(this._scanString());
      } else if (ch == "(") {
        ++this.nextPos;
        if (this.next == "*") {
          this._scanComment(this._symbols);
        } else {
          this._symbols.push(LPAREN);
        }
      } else if (this.singleSymbols.has(ch)) {
        ++this.nextPos;
        if (this.nextPos < this.text.length &&
            (ch == "." || ch == ":" || ch == ">" || ch == "<")) {
          let which = this.text.substring(this.nextPos - 1, this.nextPos + 1);
          let ds = this.doubleSymbols.get(which)
          if (ds !== undefined) {
            ++this.nextPos;
            this._symbols.push(ds);
          } else {
            this._symbols.push(this.singleSymbols.get(ch));
          }
        } else if (ch == this.table.TIMES.text) {
          this._symbols.push(Object.create(this.table.TIMES)); // XXX hack
        } else {
          this._symbols.push(this.singleSymbols.get(ch));
        }
      } else {
        throw new Error("invalid char " + ch); // XXX
      }
    }
  }

  get next() {
    return this.text.charAt(this.nextPos);
  }

  _scanNumber() {
    const { CONSTANT_TYPE } = this.table;
    let start = this.nextPos;
    while ((this.next >= "0" && this.next <= "9") ||
           (this.next >= "A" && this.next <= "F")) {
      ++this.nextPos;
    }
    let ch = this.next;
    if (ch == "H" || ch == "R" || ch == "X") {
      ++this.nextPos;
    } else if (ch == "." && !this.text.startsWith("..", this.nextPos)) {
      ++this.nextPos;
      while (this.next >= "0" && this.next <= "9") {
        ++this.nextPos;
      }
      if (this.next == "E" || this.next == "D") {
        ++this.nextPos;
        if (this.next == "+" || this.next == "-") {
          ++this.nextPos;
        }
        if (this.next < "0" || this.next > "9") {
          throw new Error("digit?"); // XXX
        }
        while (this.next >= "0" && this.next <= "9") {
          ++this.nextPos;
        }
      }
    }
    return this._makeSymbol(CONSTANT_TYPE, start);
  }

  _scanIdentifier() {
    const { IDENTIFIER_TYPE } = this.table;
    let start = this.nextPos;
    while (this.nextPos < this.text.length) {
      let ch = this.next;
      if ((ch >= "A" && ch <= "Z") ||
          (ch >= "a" && ch <= "z") ||
          (ch >= "0" && ch <= "9")) {
        ++this.nextPos;
      } else {
        break;
      }
    }
    let symbolText = this.text.substring(start, this.nextPos);
    let symbol = ((/[A-Z]{2,9}/).test(symbolText)) ?
      this.keywords.get(symbolText) :
      null;
    if (symbol == null) {
      return new OXRSymbol(IDENTIFIER_TYPE, symbolText);
    }
    return symbol;
  }

  _scanString() {
    const { CONSTANT_TYPE } = this.table;
    let start = this.nextPos;
    let end = this.text.indexOf(this.text.charAt(start), this.nextPos + 1);
    if (end == -1) {
      throw new Error("unterminated string"); // XXX
    }
    this.nextPos = end + 1;
    return this._makeSymbol(CONSTANT_TYPE, start);
  }

  _scanComment(result) {
    const { COMMENT_TYPE } = this.table;
    const { LINEBREAK_TYPE } = this.table;
    let start = this.nextPos - 1;
    this._skipComment();
    let txt = this.text.substring(start, this.nextPos);
    let pos = txt.indexOf("\n");
    while (pos != -1) {
      result.push(new OXRSymbol(COMMENT_TYPE, txt.substring(0, pos)));
      result.push(new OXRSymbol(LINEBREAK_TYPE, "\n"));
      txt = txt.substring(pos + 1);
      pos = txt.indexOf("\n");
    }
    result.push(new OXRSymbol(COMMENT_TYPE, txt));
  }

  _skipComment() {
    ++this.nextPos;
    do {
      while (this.next != "*") {
        if (this.next == "(") {
          ++this.nextPos;
          if (this.next == "*") {
            this._skipComment();
          }
        } else {
          ++this.nextPos;
        }
      }
      while (this.nextPos < this.text.length && this.next == "*") {
        ++this.nextPos;
      }
    } while (this.next != ")");
    ++this.nextPos;
  }

  _makeSymbol(type, start) {
    return new OXRSymbol(type, this.text.substring(start, this.nextPos));
  }
}

// The triple script dialect does not allow static initializers, nor does it
// have support for fat enums (i.e. enums with object-like features).  For
// this reason, the `OXRScanner` implementation and incidental changes to
// `OXRSymbol`, etc. are what most differ from the Java-based OberonXref,
// despite our goal of making a straightforward port of the original...

OXRScanner.Table = class {
  constructor() {
    const $$ = OXRSymbol.SymbolType;

    // NB: We can distinguish linebreaks from other types of whitespace, but
    // they both belong to the whitespace category.
    this.LINEBREAK_TYPE = new $$(OXRSymbol.SymbolType.WHITESPACE);
    this.WHITESPACE_TYPE = new $$(OXRSymbol.SymbolType.WHITESPACE);

    this.COMMENT_TYPE = new $$(OXRSymbol.SymbolType.COMMENT);
    this.CONSTANT_TYPE = new $$(OXRSymbol.SymbolType.CONSTANT);
    this.IDENTIFIER_TYPE = new $$(OXRSymbol.SymbolType.IDENTIFIER);
    this.KEYWORD_TYPE = new $$(OXRSymbol.SymbolType.KEYWORD);
    this.OPERATOR_TYPE = new $$(OXRSymbol.SymbolType.OPERATOR);

    const $ = (...args) => (new OXRSymbol(...args));

    this.ARRAY = $(this.KEYWORD_TYPE, "ARRAY");
    this.BEGIN = $(this.KEYWORD_TYPE, "BEGIN");
    this.BY = $(this.KEYWORD_TYPE, "BY");
    this.CASE = $(this.KEYWORD_TYPE, "CASE");
    this.CONST = $(this.KEYWORD_TYPE, "CONST");
    this.DIV = $(this.KEYWORD_TYPE, "DIV");
    this.DO = $(this.KEYWORD_TYPE, "DO");
    this.ELSE = $(this.KEYWORD_TYPE, "ELSE");
    this.ELSIF = $(this.KEYWORD_TYPE, "ELSIF");
    this.END = $(this.KEYWORD_TYPE, "END");
    this.FALSE = $(this.KEYWORD_TYPE, "FALSE");
    this.FOR = $(this.KEYWORD_TYPE, "FOR");
    this.IF = $(this.KEYWORD_TYPE, "IF");
    this.IMPORT = $(this.KEYWORD_TYPE, "IMPORT");
    this.IN = $(this.KEYWORD_TYPE, "IN");
    this.IS = $(this.KEYWORD_TYPE, "IS");
    this.MOD = $(this.KEYWORD_TYPE, "MOD");
    this.MODULE = $(this.KEYWORD_TYPE, "MODULE");
    this.NIL = $(this.KEYWORD_TYPE, "NIL");
    this.OF = $(this.KEYWORD_TYPE, "OF");
    this.OR = $(this.KEYWORD_TYPE, "OR");
    this.POINTER = $(this.KEYWORD_TYPE, "POINTER");
    this.PROCEDURE = $(this.KEYWORD_TYPE, "PROCEDURE");
    this.RECORD = $(this.KEYWORD_TYPE, "RECORD");
    this.REPEAT = $(this.KEYWORD_TYPE, "REPEAT");
    this.RETURN = $(this.KEYWORD_TYPE, "RETURN");
    this.THEN = $(this.KEYWORD_TYPE, "THEN");
    this.TO = $(this.KEYWORD_TYPE, "TO");
    this.TRUE = $(this.KEYWORD_TYPE, "TRUE");
    this.TYPE = $(this.KEYWORD_TYPE, "TYPE");
    this.UNTIL = $(this.KEYWORD_TYPE, "UNTIL");
    this.VAR = $(this.KEYWORD_TYPE, "VAR");
    this.WHILE = $(this.KEYWORD_TYPE, "WHILE");

    this.AND = $(this.OPERATOR_TYPE, "&");
    this.ARROW = $(this.OPERATOR_TYPE, "^");
    this.BAR = $(this.OPERATOR_TYPE, "|");
    this.BECOMES = $(this.OPERATOR_TYPE, ":=");
    this.COLON = $(this.OPERATOR_TYPE, ":");
    this.COMMA = $(this.OPERATOR_TYPE, ",");
    this.EQL = $(this.OPERATOR_TYPE, "=");
    this.GEQ = $(this.OPERATOR_TYPE, ">=");
    this.GTR = $(this.OPERATOR_TYPE, ">");
    this.LBRACE = $(this.OPERATOR_TYPE, "{");
    this.LBRAK = $(this.OPERATOR_TYPE, "[");
    this.LEQ = $(this.OPERATOR_TYPE, "<=");
    this.LPAREN = $(this.OPERATOR_TYPE, "(");
    this.LSS = $(this.OPERATOR_TYPE, "<");
    this.MINUS = $(this.OPERATOR_TYPE, "-");
    this.NEQ = $(this.OPERATOR_TYPE, "#");
    this.NOT = $(this.OPERATOR_TYPE, "~");
    this.PERIOD = $(this.OPERATOR_TYPE, ".");
    this.PLUS = $(this.OPERATOR_TYPE, "+");
    this.RBRACE = $(this.OPERATOR_TYPE, "}");
    this.RBRAK = $(this.OPERATOR_TYPE, "]");
    this.RDIV = $(this.OPERATOR_TYPE, "/");
    this.RPAREN = $(this.OPERATOR_TYPE, ")");
    this.SEMICOLON = $(this.OPERATOR_TYPE, ";");
    this.TIMES = $(this.OPERATOR_TYPE, "*");
    this.UPTO = $(this.OPERATOR_TYPE, "..");
  }
}
//? </script>
//? <script>
/// export
class OXRSymbol {
  constructor(type, text) {
    this.type = type;
    this.text = text;
    this.link = null;

    string :typeof this.link
  }

  get css() {
    return this.type.css;
  }

  hasTypeOneOf(...types) {
    return types.some((x) => (x == this.type));
  }

  isOneOf(...symbols) {
    return symbols.some((x) => (x == this));
  }

  toString() {
    return JSON.stringify(this);
  }
}

OXRSymbol.SymbolType = class {
  constructor(category) {
    this.category = category;
    this.css = OXRSymbol.SymbolType.getCSSString(category);
  }

  static getCSSString(category) {
    if (category < 0) return null;

    function $pad(text, width = 3) {
      let padding = "";
      while (width --> text.length) padding += "0";
      return padding + text;
    }

    return "color: #" + $pad((category & 0x0FFF).toString(0x10)) + ";";
  }
}

OXRSymbol.SymbolType.KEYWORD = 0x1F0F;
OXRSymbol.SymbolType.CONSTANT = 0x2666;
OXRSymbol.SymbolType.COMMENT = 0x30A0;
OXRSymbol.SymbolType.IDENTIFIER = 0x400F;

OXRSymbol.SymbolType.OPERATOR = -1;
OXRSymbol.SymbolType.WHITESPACE = -2;
//? </script>
//? <script>
/// export ...
var credits =
` ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' '
The primary work is OberonXref.
Available under MIT License, unless otherwise noted.

NB: The tools used to build the primary work are distributed, alongside the
source code for the primary work, in the project directory under license
compatible with this use.  Nonetheless, these build tools are not considered a
part of the primary work, but instead separate works which remain subject to
the terms of their respective licenses.

(The preceding notes are informational, and reproducing them is not itself
intended to be a prerequisite for redistribution, although the inclusion of
some of the content below may be required in order to redistribute the primary
work in whole or in part.)

Authorship and contributions
============================

* Andrey Tupitsin
* Colby Russell
* Jean-loup Gailly
* Mark Adler
* Michael Schierl
* Vitaly Puzrin

Additional works involved
=========================

CRC-32 routines (derived from zlib / pako) available under zlib license

    Copyright (C) 1995-2013 Jean-loup Gailly and Mark Adler
    Copyright (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin

<https://zlib.net>
<https://github.com/nodeca/pako>

Licenses compatible for use in the primary work
===============================================

MIT License

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

* * *

The zlib license

This software is provided 'as-is', without any express or implied
warranty.  In no event will the authors be held liable for any damages
arising from the use of this software.

Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:

1. The origin of this software must not be misrepresented; you must not
   claim that you wrote the original software. If you use this software
   in a product, an acknowledgment in the product documentation would be
   appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be
   misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' `
//? </script>
//? <script>
// There are three system-level operations that our app requires:
//
// - read
// - list
// - log
//
// There's not much substance to this class, however, since all methods are
// meant to be implemented by a host-specific system backend.  The class
// exists mainly for documentation purposes.

/// export
class SystemA {
  /**
   * Entry point, where control is handed over from main.js.  The system
   * itself is expected to eventually hand over control to the program it's
   * servicing, after doing any optional host-specific initialization.
   */
  use(app) {
    throw new SystemA.UnimplementedError;
  }

  /**
   * Obtains the contents of the file at the given path.
   *
   * @param path: string
   *        The path of the file.
   * @param raw?: boolean
   *        Whether the file contents should be treated as raw bytes or as
   *        text.  Defaults to false.
   * @return
   *        Promise<Uint8Array|string>
   */
  read(path, raw = false) {
    throw new SystemA.UnimplementedError;
  }

  /**
   * Obtains the names of files and subdirectories of the directory at the
   * given path.  Subdirectories MUST be denoted by a trailing slash (e.g.
   * "foo/") by the system implementation, to be able to distinguish from
   * ordinary files.
   *
   * @param path: string
   *        The path of the directory.
   * @return
   *        Promise<string[]>
   */
  list(path) {
    throw new SystemA.UnimplementedError;
  }

  /**
   * Prints a message to the user (possibly made of multiple pieces).
   *
   * @param messages: string[]
   *        The pieces which should get concatenated to produce the final
   *        message.
   */
  log(...messageStrings) {
    throw new SystemA.UnimplementedError;
  }
}

SystemA.ShuntingError = class ShuntingError extends Error { };
SystemA.UnimplementedError = class UnimplementedError extends Error { };
//? </script>
//? <script>
/// import { BrowserUI } from "./BrowserUI.src";
/// import { FileCache } from "./FileCache.src";
/// import { OXRResources } from "./OXRResources.src";
/// import { SystemA } from "./SystemA.src";
/// import { WebkitFileIngester } from "./WebkitFileIngester.src";
/// import { ZodLib } from "./ZodLib.src";

/// export
class SystemB extends SystemA {
  constructor() {
    super();

    if (typeof(window) == "undefined") {
      throw new SystemA.ShuntingError("not a browser environment");
    }

    this.identity = window.document.body.innerHTML;

    this._document = window.document;

    this._directoryInput = null;
    this._fileSource = null;

    this._artifacts = new FileCache();

    this.onfinish = () => {
      this._createZIP(this._artifacts).then((data) => {
        this._saveFile("xref.zip", new Blob([ data ]));
      });
    }
  }

  use(app) {
    this._document.defaultView.onload = () => {
      this._ui = new BrowserUI(this, this._document);

      let $$ = this._document.createElement.bind(this._document);

      let fileInput = $$("input");
      fileInput.setAttribute("type", "file");
      fileInput.setAttribute("webkitdirectory", "true");
      fileInput.style.display = "none";
      this._directoryInput = this._document.head.appendChild(fileInput);

      this._directoryInput.onchange = (event) => {
        this._fileSource = WebkitFileIngester.cache(event.target.files);
        this._ui.acknowledgeFileSource();
        app.exec();
      }
    }
  }

  getArgs() {
    return [ "./", "./" ];
  }

  list(path) {
    path = FileCache.normalizePath(path);
    if (path && !path.endsWith("/")) path += "/";

    let kids = new Set();
    let all = this._fileSource.list();
    for (let i = 0, n = all.length; i < n; ++i) {
      if (!all[i].startsWith(path)) continue;
      let relative = all[i].substr(path.length);
      let idx = relative.indexOf("/");
      if (idx < 0) { // file
        var name = relative;
      } else { // subdirectory
        var name = relative.substr(0, idx + 1);
        // assert(name.endsWith("/"))
      }
      if (!kids.has(name)) {
        kids.add(name);
      }
    }

    return Promise.resolve(Array.from(kids.values()));
  }

  read(path) {
    if (this._fileSource) {
      let file = this._fileSource.recall(path);
      return WebkitFileIngester.readBlob(file).then((contents) => {
        if (!contents && path.startsWith(OXRResources.QUALIFIER)) {
          return OXRResources.get(path);
        }
        return Promise.resolve(contents);
      });
    }
    return Promise.reject(new Error("no file source")); // XXX
  }

  write(path, data) {
    this._artifacts.store(new Blob([ data ]), path);
    return Promise.resolve();
  }

  log(...args) {
    if (typeof(console) != "undefined") {
      return void(console.log(...args));
    }
    throw new Error("Cannot log " + String(...args));
  }

  _export(fileName) {
    this._saveFile(fileName, this._artifacts.recall(fileName));
  }

  _saveFile(name, blob) {
    let anchor = this._document.createElement("a");
    anchor.href = URL.createObjectURL(blob);
    anchor.download = name;
    this._document.head.appendChild(anchor).click();
    anchor.parentNode.removeChild(anchor);
  }

  _createZIP(cache, names = cache.list()) {
    let archive = ZodLib.createArchive();

    let pending = names.map((path) => {
      let blob = cache.recall(path);
      return WebkitFileIngester.readBlob(blob, true).then((buffer) => {
        archive.addFile(path, buffer);
      })
    });

    return Promise.all(pending).then(() =>
      Promise.resolve(archive.zip())
    );
  }

  // NB: internal use only (for UI; not part of the abstract system interface)
  requestFileSource() {
    this._directoryInput.click();
  }
}
//? </script>
//? <script>
/// export
class BrowserUI {
  constructor(system, document) {
    this._system = system;
    this._document = document;

    this._document.body.innerHTML = "";
    this._injectUI();
  }

  _injectUI() {
    let container = this._fixQuirks();

    let $$ = this._document.createElement.bind(this._document);

    let loadArea = container.appendChild($$("div"));
    loadArea.style.float = "right";

    let loadButton = $$("input");
    loadButton.type = "button";
    loadButton.value = "Open\u2026";
    this._loadButton = loadArea.appendChild(loadButton);

    this._loadButton.onclick = () => void(this._system.requestFileSource());

    let consolePanel = container.appendChild($$("div"));
  }

  _fixQuirks(title = "") {
    this._document.open();
    this._document.write(
      "<!DOCTYPE html><html><head><meta charset='utf-8'><title>" + title
    );
    this._document.close();
    return this._document.body;
  }

  acknowledgeFileSource() {
    this._loadButton.classList.remove("empty");
  }
}
//? </script>
//? <script>
/// export
class FileCache {
  constructor() {
    this._blobs = new Map();
  }

  static normalizePath(path) {
    if (path.startsWith("/")) return path.substr(("/").length);
    if (path.startsWith("./")) return path.substr(("./").length);
    return path;
  }

  store(blob, path) {
    path = FileCache.normalizePath(path);
    this._blobs.set(path, blob);
  }

  recall(path) {
    path = FileCache.normalizePath(path);
    return this._blobs.get(path);
  }

  list() {
    return Array.from(this._blobs.keys());
  }
}
//? </script>
//? <script>
// Provides fallback contents for the resources, so the triple script really
// can operate as a standalone utility--no need for users to lug around an
// additional `resources/` directory.  Hardcoded to reasonable defaults that
// match what's currently in the repo, but the user can override these by
// explicitly providing their own.  The fallback is meant to only get
// activated if reading from an invalid path.

/// export
class OXRResources {
  static get(path) {
    switch (path) {
      case (OXRResources.QUALIFIER + "BUILTINS.Mod.txt"): return (
        OXRResources.BUILTINS_MODULE.trim() + "\n"
      );
      case (OXRResources.QUALIFIER + "script.js"): return (
        OXRResources.SCRIPT_HELPER.trim()
      );
      case (OXRResources.QUALIFIER + "style.css"): return (
        OXRResources.STYLE_HELPER.trim()
      );
      case (OXRResources.QUALIFIER + "SYSTEM.Mod.txt"): return (
        OXRResources.SYSTEM_MODULE.trim() + "\n"
      );
    }
    return null;
  }
}

OXRResources.QUALIFIER = "resources/";

OXRResources.BUILTINS_MODULE = `
MODULE BUILTINS;  (*pseudo module declaring all the builtin types and procedures *)

  TYPE
    BOOLEAN* = RECORD (* the truth values TRUE and FALSE *) END;
    CHAR* = RECORD (* the characters of a standard character set *) END;
    INTEGER* = RECORD (* the integers *) END;
    REAL* = RECORD (* real numbers *) END;
    BYTE* = RECORD (* the integers between 0 and 255 *) END;
    SET* = RECORD (* the sets of integers between 0 and an implementation-dependent limit *) END;

    (* LONGINT is synonym to INTEGER, LONGREAL to REAL *)
    LONGINT* = RECORD (* INTEGER *) END;
    LONGREAL* = RECORD (* REAL *) END;

    (* pseudo types used by the builtin procedures *)
    NumericType = RECORD (* any numeric type *) END;
    ArrayType = ARRAY 1 OF NumericType;
    CharBooleanSet = RECORD (* one of CHAR, BOOLEAN, SET *) END;
    PointerType = RECORD (* pointer type *) END;

  PROCEDURE ABS*(x: NumericType): NumericType;
  BEGIN RETURN (* absolute value of *) x
  END ABS;

  PROCEDURE ODD*(x: INTEGER): BOOLEAN;
  BEGIN RETURN x MOD 2 = 1
  END ODD;

  PROCEDURE LEN*(v: ArrayType): INTEGER;
  BEGIN RETURN (* length of array *) v
  END LEN;

  PROCEDURE LSL*(x, n: INTEGER): INTEGER;
  BEGIN RETURN x * (* 2^ *) n
  END LSL;

  PROCEDURE ASR*(x, n: INTEGER): INTEGER;
  BEGIN RETURN x DIV (* 2^ *) n
  END ASR;

  PROCEDURE ROR*(x, n: INTEGER): INTEGER;
  BEGIN RETURN x (* rotated right by n bits *)
  END ROR;

  PROCEDURE FLOOR*(x: REAL): INTEGER;
  BEGIN RETURN x (* rounded down *)
  END FLOOR;

  PROCEDURE FLT*(x: INTEGER): REAL;
  BEGIN RETURN x
  END FLT;

  PROCEDURE ORD*(x: CharBooleanSet): INTEGER;
  BEGIN RETURN (* ordinal number of *) x
  END ORD;

  PROCEDURE CHR*(x: INTEGER): CHAR;
  BEGIN RETURN (* character with ordinal number *) x
  END CHR;

  PROCEDURE INC*(VAR v: INTEGER; (*OPTIONAL*) n: INTEGER);
  BEGIN v := v + n (* or 1 if not given *)
  END INC;

  PROCEDURE DEC*(VAR v: INTEGER; (*OPTIONAL*) n: INTEGER);
  BEGIN v := v - n (* or 1 if not given *)
  END DEC;

  PROCEDURE INCL*(VAR v: SET; x: INTEGER);
  BEGIN v := v + (* set of only *) x
  END INCL;

  PROCEDURE EXCL*(VAR v: SET; x: INTEGER);
  BEGIN v := v - (* set of only *) x
  END EXCL;

  PROCEDURE NEW*(VAR v: PointerType);
  BEGIN (* allocate pointer *)
  END NEW;

  PROCEDURE ASSERT*(VAR b: BOOLEAN);
  BEGIN IF ~b THEN (* abort *) END
  END ASSERT;

  PROCEDURE PACK*(VAR x: REAL; n: INTEGER);
  BEGIN (* pack x * 2 ^ n into x *)
  END PACK;

  PROCEDURE UNPK*(VAR x: REAL; VAR n: INTEGER);
  BEGIN (* unpack x into x * 2 ^ n so that 1.0 <= x < 2.0 *)
  END UNPK;

  (* UML, LED, ADC, SBC are not in language definition,
     but UML, ADC and SBC are not used by Project Oberon *)

  PROCEDURE LED*(VAR n: INTEGER);
  BEGIN (* display n on LEDs *)
  END LED;

END BUILTINS.
`;

OXRResources.SCRIPT_HELPER = `
if (!String.prototype.startsWith) {
  String.prototype.startsWith = function(searchString, position) {
    position = position || 0;
    return this.indexOf(searchString, position) === position;
  };
}

function unmarkSameLinks() {
	document.querySelectorAll("a.currusage, a.currdef").forEach(function(tag) {
		tag.classList.remove("currusage");
		tag.classList.remove("currdef");
	});
}

function markSameLinks() {
	unmarkSameLinks();
	var targetHref = this.href;
	document.querySelectorAll("a").forEach(function(tag) {
		if (tag.href == targetHref) {
			tag.classList.add(tag.name ? "currdef" : "currusage");
		}
	});
}

function undoCollapse(lineno) {
	var table = document.getElementsByTagName("table")[0];
	if (!table.classList.contains("collapseall"))
		return true;
	table.classList.remove("collapseall");
	document.getElementById("togglebuttons").classList.remove("collapseall");
	table.classList.add("showsource");
	document.querySelectorAll("tr.show").forEach(function(tag) {
		tag.classList.remove("show");
	});
	var controlSpan = document.getElementById("control");
	var origTag = controlSpan.firstChild;
	controlSpan.removeChild(origTag);
	controlSpan.parentNode.insertBefore(origTag, controlSpan);
	controlSpan.parentNode.removeChild(controlSpan);
	if (lineno)
		window.location.href="#L_"+lineno;
}

function uncollapseRow(node) {
	var row = node;
	while (row.nodeName != "TR" && row.nodeName != "BODY") {
		row = row.parentNode;
	}
	row.classList.add("show");
}

function collapseToReferences() {
	var table = document.getElementsByTagName("table")[0];
	if (!table.classList.contains("showsource"))
		return true;
	table.classList.remove("showsource");
	table.classList.add("collapseall");
	document.getElementById("togglebuttons").classList.add("collapseall");
	uncollapseRow(this);
	var targetHref = this.href;
	document.querySelectorAll("a").forEach(function(tag) {
		if (tag.href == targetHref) {
			uncollapseRow(tag);
		}
	});
	var controlSpan = document.createElement("span");
	var extraSpan = document.createElement("span");
	document.querySelectorAll("tr.show th a").forEach(function(tag) {
		extraSpan.innerHTML += " <a href='javascript:undoCollapse(\\""+tag.dataset.l+"\\")'>"+tag.dataset.l+"</a>";
	});
	extraSpan.innerHTML+=" <a href='javascript:undoCollapse()'>(Back)</a>";
	controlSpan.id="control"
	this.parentNode.insertBefore(controlSpan, this);
	this.parentNode.removeChild(this);
	controlSpan.appendChild(this);
	controlSpan.appendChild(extraSpan);
	return false;
}

function findLine(anchor) {
	var found = null;
	document.querySelectorAll("th a").forEach(function(tag) {
		if (tag.name == anchor)
			found = tag.parentNode.parentNode;
	});
	return found;
}

function updateLines() {
	document.querySelectorAll("tr.sel").forEach(function(tag) {
		tag.classList.remove("sel");
	});
	var hash = window.location.hash.substring(1);
	if (!hash.startsWith("L_") && !hash.startsWith("A_"))
		return;
	if (hash.indexOf("-") != -1) {
		var firstLine = findLine(hash.substring(0, hash.indexOf("-")));
		var lastLine = findLine(hash.substring(0, 2) + hash.substring(hash.indexOf("-")+1));
		if (firstLine != null && lastLine != null && firstLine.compareDocumentPosition(lastLine) & Node.DOCUMENT_POSITION_FOLLOWING) {
			firstLine.classList.add("sel");
			document.querySelectorAll("tr").forEach(function(tag) {
				if (tag.className == lastLine.className) {
					if (firstLine.compareDocumentPosition(tag) & Node.DOCUMENT_POSITION_FOLLOWING) {
						if (tag.compareDocumentPosition(lastLine) & Node.DOCUMENT_POSITION_FOLLOWING) {
							tag.classList.add("sel");
						}
					}
				}
			});
			lastLine.classList.add("sel");
		}
	} else {
		var line = findLine(hash);
		if (line != null)
			line.classList.add("sel");
	}
}

function toggleasm(elem) {
	var table = document.getElementsByTagName("table")[0];
	table.classList.remove("showsource");
	table.classList.remove("showassembly");
	table.classList.remove("showboth");
	table.classList.add(elem.value);
}

window.onhashchange = function() {
	if (window.location.hash.startsWith("#L_") || window.location.hash.startsWith("#A_"))
		updateLines();
};

window.onload = function() {
	if (document.getElementsByTagName("table")[0].classList.contains("assemblypresent")) {
		document.getElementById("togglebuttons").innerHTML='<label><input type="radio" checked="checked" name="asm" value="showsource" onclick="toggleasm(this)"> Source</label> <label><input id="asmradio" type="radio" name="asm" value="showassembly" onclick="toggleasm(this)"> Assembly</label> <label><input id="bothradio" type="radio" name="asm" value="showboth" onclick="toggleasm(this)"> Both</label>';
	}
	if (window.location.hash.startsWith("#L_"))
		updateLines();
	if (window.location.hash.startsWith("#A_")) {
		document.getElementById("asmradio").checked=true;
		toggleasm(document.getElementById("asmradio"));
		updateLines();	
	}
	if (window.location.hash == "#both") {
		document.getElementById("bothradio").checked=true;
		toggleasm(document.getElementById("bothradio"));
	}
	document.querySelectorAll("a").forEach(function(tag) {
		if (tag.parentNode.tagName == "TH") {
			tag.onclick = function() {
				setTimeout(updateLines, 1);
			};
		} else if (tag.name) {
			tag.onclick = collapseToReferences;
		}
		tag.onmouseover = markSameLinks;
		tag.onmouseout = unmarkSameLinks;
	});
};
`;

OXRResources.STYLE_HELPER = `
body { font-family: Verdana, Arial, sans-serif; }

table.sourcecode {border: 1px solid black; width: 100%; border-collapse: collapse; }
table.sourcecode tr.al {color: white; background-color: black;}
table.sourcecode tr.sl {color: black; background-color: white;}
table.sourcecode tr.sel {background-color: yellow; }
table.sourcecode tr.al.sel {background-color: blue; }
table.sourcecode th {border-right: 1px solid grey; font-weight: normal; white-space: pre;}
table.sourcecode td {white-space: pre; font-family: Courier New, monospaced;}

table.sourcecode.showsource tr.al {display: none}
table.sourcecode.showsource tr.sl td sub {display: none}
table.sourcecode.showassembly tr.sl {display: none}
table.sourcecode.showassembly tr.al td sup {display: none}
table.sourcecode.collapseall tr.sl {display:none}
table.sourcecode.collapseall tr.al {display:none}
table.sourcecode.collapseall tr.sl td sub {display: none}
table.sourcecode.collapseall tr.sl.show {display:table-row;}

table.sourcecode a {color: inherit; outline: none; }

table.sourcecode tr.sl th a { display: block; width: 100%; cursor: pointer; user-select: none; text-align: right; text-decoration: none; 
		font-weight: normal; }
table.sourcecode tr.sl th a::before { content: attr(data-l); margin-right: 5px; }

table.sourcecode td sub {background-color: black; color:white; border-radius: 0px 0px 50% 50%; display:inline-block;}
table.sourcecode td sub a { color: white; display: block; padding: 1px 5px 2px 5px; width: 100%; text-decoration: none;} 
table.sourcecode td sub s {display: block; width: 100%; height: 5px;}
table.sourcecode td sub s u {display: inline-block; width: 50%; background-color: white; border-radius: 0px 0px 100% 0px; height: 5px; vertical-align: top;}
table.sourcecode td sub s b {display: inline-block; width: 50%; background-color: white; border-radius: 0px 0px 0px 100%; height: 5px; vertical-align: top;}

table.sourcecode tr.al td sup {display: inline-block; width: 1em; height: 1em; background-color: white; color: black; border-radius: 50%; text-align: center; }

table.sourcecode tr.al th a, table.sourcecode tr.al td sup a {text-decoration: none;}

a.currusage { background-color: #0f0;}
a.currdef {background-color: orange; }

span#control {border: 2px solid red; }

div#togglebuttons.collapseall { display: none; }
`;

OXRResources.SYSTEM_MODULE = `
MODULE SYSTEM;  (*pseudo module declaring all the SYSTEM procedures *)

  TYPE
    (* pseudo types used by the builtin procedures *)
    AnyType = RECORD (* any type *) END;
    TypeType = RECORD (* A type goes here, not a variable *) END;

  (* pseudo arrays representing the memory and the registers *)
  VAR mem, registers, specialregisters: ARRAY 0 OF INTEGER;

  PROCEDURE ADR*(VAR v: AnyType): INTEGER;
  BEGIN RETURN (* address of *) v
  END ADR;

  PROCEDURE SIZE*(VAR T: TypeType): INTEGER;
  BEGIN RETURN (* size of *) T
  END SIZE;

  PROCEDURE BIT*(a, n: INTEGER): BOOLEAN;
  BEGIN RETURN mem[a] = n (* th bit set*)
  END BIT;

  PROCEDURE GET*(a: INTEGER; VAR v: AnyType);
  BEGIN v := mem[a]
  END GET;

  PROCEDURE PUT*(a: INTEGER; x: AnyType);
  BEGIN mem[a] := x
  END PUT;

  PROCEDURE COPY*(src, dst, n: INTEGER);
  VAR i: INTEGER;
  BEGIN
    FOR i:= 0 TO n - 1 DO mem[dst + i] := mem[src + i] END
  END COPY;

  PROCEDURE VAL*(T: TypeType; n: AnyType): TypeType;
  BEGIN RETURN n (* identity converted to T *)
  END VAL;

  (* LDPSR, LDREG, REG, H, COND are not in language definition,
     but SYSTEM.COND is not used by Project Oberon *)

  PROCEDURE LDREG* (reg, value: INTEGER);
  BEGIN registers[reg] := value
  END LDREG;

  PROCEDURE LDPSR* (value: INTEGER);
  BEGIN (* enable / disable interrupts *)
  END LDPSR;

  PROCEDURE REG*(reg: INTEGER): INTEGER;
  BEGIN RETURN registers[reg]
  END REG;

  (* H(0) = remainder of last division; H(1) = processor cpuid *)
  PROCEDURE H*(reg: INTEGER): INTEGER;
  BEGIN RETURN specialregisters[reg]
  END H;

END SYSTEM.
`;
//? </script>
//? <script>
/// import { FileCache } from "./FileCache.src";

/// export
class WebkitFileIngester {
  static cache(fileList, cache = new FileCache()) {
    if (!fileList.length) return null;

    let $prefixOf = (path) => path.substr(0, path.indexOf("/", 1));
    let prefix = $prefixOf(fileList[0].webkitRelativePath);
    for (let i = 0; i < fileList.length; ++i) {
      // assert($prefixOf(fileList[i].webkitRelativePath) == prefix)
      let path = fileList[i].webkitRelativePath.substr(prefix.length);
      cache.store(fileList[i], path);
    }

    return cache;
  }

  static readBlob(blob, raw = false) {
    if (!blob) return Promise.resolve(null);
    if (typeof(FileReader) != "undefined") {
      let reader = new FileReader();
      return new Promise(function(resolve) {
        reader.addEventListener("loadend", resolve);
        if (raw) {
          reader.readAsArrayBuffer(blob);
        } else {
          reader.readAsText(blob);
        }
      }).then(function(event) {
        return event.target.result;
      });
    }
    throw new Error("FileReader API not implemented");
  }
}
//? </script>
//? <script>
/// import { credits } from "./credits.src";

// NB: This module should not be distributed alone as-is without taking care
// to include appropriate notices and license terms for routines derived from
// code with third-party authorship.
//
// Refer to ACKNOWLEDGEMENTS.txt (for trplkt; "CRC-32").

/// export
class ZodLib {
  addFile(name, contents) {
    this._fileBuffers.set(name, contents);
  }

  constructor(fileBuffers) {
    if (!(this instanceof ZodLib.Container)) {
      throw new Error("Not permitted; use ZodLib.createArchive");
    }
    this._fileBuffers = fileBuffers;
  }

  static createArchive() {
    return new ZodLib.Container(new Map);
  }

  zip() {
    // For info on the file format, refer to:
    // - <https://www.pkware.com/documents/APPNOTE/APPNOTE-6.2.0.txt>
    // - <https://www.pkware.com/documents/APPNOTE/APPNOTE-2.0.txt>

    const fileHeaderMinSize = 30;
    const directoryRecordMinSize = 46;
    const directoryTerminatorMinSize = 22;

    // Before we can allocate the output buffer, we'll have to compute some
    // things, including what size buffer is required.
    let filesSize = 0;
    let directorySize = 0;
    let fileNames = this._listFileNames();
    for (let i = 0, n = fileNames.length; i < n; ++i) {
      let name = fileNames[i];
      let size = this._fileBuffers.get(name).byteLength;
      filesSize += fileHeaderMinSize + name.length + size;
      directorySize += directoryRecordMinSize + name.length;
    }

    let totalSize = filesSize + directorySize + directoryTerminatorMinSize;
    let output = new ArrayBuffer(totalSize);

    const filesStartOffset = 0;
    const directoryStartOffset = 0 + filesSize;

    let filesWriter = new ZodLib.Writer(output, filesStartOffset);
    let directoryWriter = new ZodLib.Writer(output, directoryStartOffset);

    const fileHeaderSignature = 0x04034B50;
    const directoryHeaderSignature = 0x02014B50;
    const directoryTerminatorSignature = 0x06054B50;
    const zipVersion = 20;
    const flags = 0;

    let table = ZodLib.createCRC32Table();
    for (let i = 0, n = fileNames.length; i < n; ++i) {
      let name = fileNames[i];
      let buffer = this._fileBuffers.get(name);
      let crc32 = ZodLib.computeCRC32(buffer, 0, table);

      let time = 0; // TODO

      let headerOffset = filesWriter.offset;

      filesWriter.put4Bytes(fileHeaderSignature);
      filesWriter.put2Bytes(zipVersion);
      filesWriter.put2Bytes(flags);
      filesWriter.put2Bytes(ZodLib.STORE_METHOD);

      filesWriter.put4Bytes(time);

      filesWriter.put4Bytes(crc32);
      filesWriter.put4Bytes(buffer.byteLength);
      filesWriter.put4Bytes(buffer.byteLength);
      filesWriter.put2Bytes(name.length);

      filesWriter.put2Bytes(0); // extra size

      filesWriter.putStringBytes(name);

      filesWriter.putBufferBytes(buffer);

      directoryWriter.put4Bytes(directoryHeaderSignature);
      directoryWriter.put2Bytes(zipVersion);
      directoryWriter.put2Bytes(zipVersion);
      directoryWriter.put2Bytes(flags);
      directoryWriter.put2Bytes(ZodLib.STORE_METHOD);

      directoryWriter.put4Bytes(time);

      directoryWriter.put4Bytes(crc32);
      directoryWriter.put4Bytes(buffer.byteLength);
      directoryWriter.put4Bytes(buffer.byteLength);
      directoryWriter.put2Bytes(name.length);

      directoryWriter.put2Bytes(0); // extra size
      directoryWriter.put2Bytes(0); // comment size
      directoryWriter.put2Bytes(0); // disk number
      directoryWriter.put2Bytes(0); // internal attributes
      directoryWriter.put4Bytes(0); // external attributes

      directoryWriter.put4Bytes(headerOffset);

      directoryWriter.putStringBytes(name);
    }

    // assert(directoryWriter.offset - directoryStartOffset == directorySize)

    directoryWriter.put4Bytes(directoryTerminatorSignature);
    directoryWriter.put2Bytes(0); // current disk
    directoryWriter.put2Bytes(0); // directory disk
    directoryWriter.put2Bytes(fileNames.length);
    directoryWriter.put2Bytes(fileNames.length);
    directoryWriter.put4Bytes(directorySize);
    directoryWriter.put4Bytes(directoryStartOffset);

    directoryWriter.put2Bytes(0); // comment size

    return output;
  }

  _listFileNames() {
    return Array.from(this._fileBuffers.keys());
  }

  // CRC-32 routines (derived from zlib / pako; see zlib notices)

  static computeCRC32(buffer, crc = 0, table = ZodLib.createCRC32Table()) {
    crc ^= -1;

    let bytes = new Uint8Array(buffer);
    for (let i = 0, n = bytes.byteLength; i < n; i++) {
      crc = (crc >>> 8) ^ table[(crc ^ bytes[i]) & 0xFF];
    }

    return (crc ^ (-1)) >>> 0;
  }

  static createCRC32Table() {
    var c, table = [];

    for (var n = 0; n < 256; n++) {
      c = n;
      for (var k = 0; k < 8; k++) {
        c = ((c & 1) ? (0xEDB88320 ^ (c >>> 1)) : (c >>> 1));
      }
      table[n] = c;
    }

    return table;
  }
}

// NB: for internal use only
ZodLib.Container = class Container extends ZodLib { };

ZodLib.Writer = class Writer {
  constructor(buffer, offset) {
    this._data = new DataView(buffer);
    this.offset = offset;
  }

  put2Bytes(value) {
    this._data.setUint16(this.offset, value, true);
    this.offset += 2;
  }

  put4Bytes(value) {
    this._data.setUint32(this.offset, value, true);
    this.offset += 4;
  }

  putBufferBytes(buffer) {
    let srcBytes = new Uint8Array(buffer);
    let destBytes = new Uint8Array(this._data.buffer);
    destBytes.set(srcBytes, this.offset);
    this.offset += buffer.byteLength;
  }

  putStringBytes(string) {
    Writer.syncStringToBuffer(string, this._data.buffer, this.offset);
    this.offset += string.length;
  }

  static syncStringToBuffer(text, buffer, offset) {
    let bytes = new Uint8Array(buffer, offset);
    for (let i = 0, n = text.length; i < n; ++i) {
      let unit = text.codePointAt(i);
      if (unit != unit & 0x7F) throw new Error("not ASCII"); // TODO
      bytes[i] = unit;
    }
  }
}

ZodLib.STORE_METHOD = 0;
//? </script>
//? <script>
/// import { FileNodeFSAdapter } from "./FileNodeFSAdapter.src";
/// import { OXRResources } from "./OXRResources.src";
/// import { SystemA } from "./SystemA.src";

/// export
class SystemC extends SystemA {
  constructor() {
    super();

    if (typeof(process) == "undefined") {
      throw new SystemA.ShuntingError("not a NodeJS environment");
    }

    const nodeFS = process.mainModule.require("fs");
    const nodePath = process.mainModule.require("path");

    let [ engine, script, ...eargs ] = process.argv;
    this._args = eargs;

    this._files = new FileNodeFSAdapter(nodeFS, nodePath, "./");
  }

  use(app) {
    app.exec();
  }

  getArgs() {
    return this._args.slice();
  }

  read(path, raw) {
    return this._files.read(path, raw).then((contents) => {
      if (!contents && path.startsWith(OXRResources.QUALIFIER) && !raw) {
        return Promise.resolve(OXRResources.get(path));
      }
      return Promise.resolve(contents);
    });
  }

  write(path, data) {
    return this._files.write(path, data);
  }

  list(path) {
    return this._files.list(path);
  }

  log(...args) {
    if (typeof(console) != "undefined") {
      return void(console.log(...args));
    }
    throw new Error("Cannot log " + String(...args));
  }
}
//? </script>
//? <script>
/// export
class FileNodeFSAdapter {
  constructor(fs, path, workDir = ".") {
    this._nodeFS = fs;
    this._nodePath = path;
    this._workDir = workDir;
  }

  list(path) {
    if (!path.startsWith("/")) {
      path = this._nodePath.join(this._workDir, path);
    }
    return new Promise((resolve) => {
      this._nodeFS.readdir(path, (err, fileNames) => {
        if (err) return void(resolve(null));
        resolve(fileNames.map((name) => {
          let stats = this._nodeFS.statSync(path + name);
          if (stats.isDirectory()) return name + "/";
          return name;
        }));
      });
    });
  }

  read(path) {
    if (!path.startsWith("/")) {
      path = this._nodePath.join(this._workDir, path);
    }
    const options = { encoding: "utf8" };
    return new Promise((resolve, reject) => {
      void this._nodeFS.readFile(path, options, (err, contents) => {
        if (err) {
          if (err.code == "ENOENT") {
            resolve(null);
          } else {
            reject(err);
          }
        } else {
          resolve(contents);
        }
      });
    });
  }

  write(path, contents) {
    if (!path.startsWith("/")) {
      path = this._nodePath.join(this._workDir, path);
    }
    let parent = path.substr(0, path.lastIndexOf("/"));
    return new Promise((resolve, reject) => {
      try {
        if (parent) this._forceDirectory(parent);
      } catch (ex) {
        return void(reject(ex));
      }
      this._nodeFS.writeFile(path, contents, (err) => {
        if (err) {
          reject(err);
        } else {
          resolve();
        }
      });
    });
  }

  _forceDirectory(path) {
    let stats = this._stat(path);
    if (stats) {
      if (stats.isDirectory()) return;
      throw new Error("not a directory");
    }
    let parent = path.substr(0, path.lastIndexOf("/"));
    if (parent) this._forceDirectory(parent);
    this._nodeFS.mkdirSync(path);
  }

  _stat(path) {
    try {
      return this._nodeFS.statSync(path);
    } catch (ex) {
      return null;
    }
  }
}
//? </script>
//? <script>
/// import { OXRGenerator } from "./src/OXRGenerator.src";

/// import { SystemA } from "./src/SystemA.src";
/// import { SystemB } from "./src/SystemB.src";
/// import { SystemC } from "./src/SystemC.src";

// By abstracting our program to operate only against a well-defined system
// interface, we can provide multiple system backends.  This is what allows
// the program to run either in the browser or from a command-line shell in a
// terminal emulator--without the app itself caring about the details of the
// host environment.

void function main() {
  const { ShuntingError } = SystemA;

  if (!system) var system = create(SystemB);
  if (!system) var system = create(SystemC);

  function create($KindOfSystem) {
    try {
      return new $KindOfSystem;
    } catch (ex) {
      if (ex instanceof ShuntingError) {
        return null;
      }
      throw ex;
    }
  }

  if (!system) {
    throw new ShuntingError("unknown environment");
  }

  function $debug(err) {
    if (!("parser" in err)) return;

    const { COMMENT_TYPE } = err.parser.table;
    const { LINEBREAK_TYPE } = err.parser.table;
    const { WHITESPACE_TYPE } = err.parser.table;

    if ("allSyms" in err.parser) {
      let offsetAll = 0;
      let offsetMeaningful = 0;
      while (offsetAll < err.parser.allSyms.length &&
             offsetMeaningful < err.parser.nextSym) {
        let symbol = err.parser.allSyms[offsetAll];
        if (symbol.type.category != OXRSymbol.SymbolType.COMMENT &&
            symbol.type.category != OXRSymbol.SymbolType.WHITESPACE) {
          ++offsetMeaningful;
        }
        ++offsetAll;
      }

      let lineText = "";
      let lineNumber = 0;
      for (let i = offsetAll; i >= 0; --i) {
        if (err.parser.allSyms[i].text != "\n") {
          lineText = err.parser.allSyms[i].text + lineText;
        } else {
          while (i >= 0) {
            if (err.parser.allSyms[i].text == "\n") {
              ++lineNumber;
            }
            --i;
          }
        }
      }
      console.log("line", lineNumber + ":", lineText);
    }
    console.log(JSON.stringify(err.parser.program[err.parser.nextSym + 1]));
  }

  function $exec() {
    OXRGenerator.main(system, ...system.getArgs()).catch((err) => {
      let output = String(err);
      if ("stack" in err) {
        let details = String(err.stack);
        if (details.startsWith(output)) {
          output = details;
        } else {
          output += "\n" + details;
        }
      }

      if (typeof(__DEBUG__) != "undefined") $debug(err);

      console.log("\n");

      console.log(output);
    });
  }

  system.use({ exec: $exec });
} ()
//? </script>