@f3liz/rescript-autogen-openapi 0.1.0

package/lib/es6/src/Codegen.mjs

@@ -0,0 +1,423 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Config from "./types/Config.mjs";
+import * as Pipeline from "./core/Pipeline.mjs";
+import * as Text from "@std/text";
+import * as Belt_Array from "@rescript/runtime/lib/es6/Belt_Array.js";
+import * as FileSystem from "./core/FileSystem.mjs";
+import * as SpecDiffer from "./core/SpecDiffer.mjs";
+import * as SpecMerger from "./core/SpecMerger.mjs";
+import * as DocOverride from "./core/DocOverride.mjs";
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+import * as Stdlib_JsExn from "@rescript/runtime/lib/es6/Stdlib_JsExn.js";
+import * as OpenAPIParser from "./core/OpenAPIParser.mjs";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Stdlib_Result from "@rescript/runtime/lib/es6/Stdlib_Result.js";
+import * as ModuleGenerator from "./generators/ModuleGenerator.mjs";
+import * as SchemaRefResolver from "./core/SchemaRefResolver.mjs";
+import * as DiffReportGenerator from "./generators/DiffReportGenerator.mjs";
+import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
+import * as ThinWrapperGenerator from "./generators/ThinWrapperGenerator.mjs";
+import * as TypeScriptDtsGenerator from "./generators/TypeScriptDtsGenerator.mjs";
+import * as ComponentSchemaGenerator from "./generators/ComponentSchemaGenerator.mjs";
+import * as TypeScriptWrapperGenerator from "./generators/TypeScriptWrapperGenerator.mjs";
+
+function generateSingleSpecPure(spec, config) {
+  try {
+    let targets = Stdlib_Option.getOr(config.targets, Config.defaultTargets());
+    let allEndpoints = OpenAPIParser.getAllEndpoints(spec);
+    let includeTags = config.includeTags;
+    let endpoints = includeTags !== undefined ? OpenAPIParser.filterByTags(allEndpoints, includeTags, Stdlib_Option.getOr(config.excludeTags, [])) : allEndpoints;
+    let baseOutput = targets.rescriptApi ? Pipeline.combine([
+        ComponentSchemaGenerator.generate(spec, config.outputDir),
+        config.modulePerTag ? ModuleGenerator.generateTagModuleFiles(endpoints, config.outputDir, undefined, config.docOverrideDir) : ModuleGenerator.generateFlatModuleFile("API", endpoints, config.outputDir, config.docOverrideDir)
+      ]) : Pipeline.empty;
+    let wrapperOutput = targets.rescriptWrapper ? ThinWrapperGenerator.generateWrapper(spec, endpoints, undefined, config.outputDir, Text.toPascalCase(spec.info.title) + "Wrapper", "", undefined) : Pipeline.empty;
+    let dtsOutput = targets.typescriptDts ? TypeScriptDtsGenerator.generate(spec, endpoints, Stdlib_Option.getOr(config.dtsOutputDir, config.outputDir)) : Pipeline.empty;
+    let tsWrapperOutput = targets.typescriptWrapper ? TypeScriptWrapperGenerator.generate(endpoints, Stdlib_Option.getOr(config.wrapperOutputDir, config.outputDir), "../generated") : Pipeline.empty;
+    return {
+      TAG: "Ok",
+      _0: Pipeline.combine([
+        baseOutput,
+        wrapperOutput,
+        dtsOutput,
+        tsWrapperOutput
+      ])
+    };
+  } catch (raw_err) {
+    let err = Primitive_exceptions.internalToException(raw_err);
+    if (err.RE_EXN_ID === "JsExn") {
+      return {
+        TAG: "Error",
+        _0: {
+          TAG: "UnknownError",
+          message: Stdlib_Option.getOr(Stdlib_JsExn.message(err._1), "Unknown error"),
+          context: undefined
+        }
+      };
+    } else {
+      return {
+        TAG: "Error",
+        _0: {
+          TAG: "UnknownError",
+          message: "Unknown error",
+          context: undefined
+        }
+      };
+    }
+  }
+}
+
+async function generateSingleSpec(spec, config) {
+  let err = generateSingleSpecPure(spec, config);
+  if (err.TAG !== "Ok") {
+    return {
+      TAG: "Error",
+      _0: err._0
+    };
+  }
+  let output = err._0;
+  let errors = FileSystem.writeFiles(output.files);
+  if (errors.TAG !== "Ok") {
+    return {
+      TAG: "Error",
+      _0: {
+        TAG: "UnknownError",
+        message: `Failed to write files: ` + errors._0.join(", "),
+        context: undefined
+      }
+    };
+  }
+  let match = config.generateDocOverrides;
+  let overrideFiles;
+  if (match !== undefined) {
+    if (match) {
+      let allEndpoints = OpenAPIParser.getAllEndpoints(spec);
+      let includeTags = config.includeTags;
+      let endpoints = includeTags !== undefined ? OpenAPIParser.filterByTags(allEndpoints, includeTags, Stdlib_Option.getOr(config.excludeTags, [])) : allEndpoints;
+      let files = DocOverride.generateOverrideFiles(spec, endpoints, Stdlib_Option.getOr(config.docOverrideDir, "./docs"), spec.info.title, config.modulePerTag, undefined);
+      overrideFiles = Stdlib_Result.getOr(FileSystem.writeFiles(files), []);
+    } else {
+      overrideFiles = [];
+    }
+  } else {
+    overrideFiles = [];
+  }
+  return {
+    TAG: "Ok",
+    _0: {
+      generatedFiles: errors._0.concat(overrideFiles),
+      diff: undefined,
+      warnings: output.warnings
+    }
+  };
+}
+
+function processForkPure(baseSpec, baseEndpoints, fork, config) {
+  try {
+    let forkEndpoints = OpenAPIParser.getAllEndpoints(fork.spec);
+    let diff = SpecDiffer.generateDiff(baseSpec, fork.spec, baseEndpoints, forkEndpoints);
+    let diffReportFile = config.generateDiffReport ? ({
+        path: FileSystem.makePath(config.outputDir, fork.name + `-diff.md`),
+        content: DiffReportGenerator.generateMarkdownReport(diff, "base", fork.name)
+      }) : undefined;
+    let match = SpecMerger.mergeSpecs(baseSpec, fork.spec, baseEndpoints, forkEndpoints, config.strategy);
+    let sharedSpec = match[0];
+    let sharedEndpoints = OpenAPIParser.getAllEndpoints(sharedSpec);
+    let extensionEndpoints = OpenAPIParser.getAllEndpoints(match[1]);
+    let mergeReportFile_path = FileSystem.makePath(config.outputDir, fork.name + `-merge.md`);
+    let mergeReportFile_content = DiffReportGenerator.generateMergeReport(SpecMerger.getMergeStats(baseEndpoints, forkEndpoints, Stdlib_Option.flatMap(baseSpec.components, c => c.schemas), Stdlib_Option.flatMap(fork.spec.components, c => c.schemas)), "base", fork.name);
+    let mergeReportFile = {
+      path: mergeReportFile_path,
+      content: mergeReportFile_content
+    };
+    let match$1 = config.strategy;
+    let codeOutput;
+    if (match$1 === "Separate") {
+      codeOutput = Pipeline.fromFile({
+        path: FileSystem.makePath(config.outputDir, fork.name + `.res`),
+        content: ModuleGenerator.generateFlatModuleCode(Text.toPascalCase(fork.name), forkEndpoints, config.docOverrideDir)
+      });
+    } else {
+      let baseName = Stdlib_Option.getOrThrow(config.baseInstanceName, "baseInstanceName required");
+      let basePrefix = Stdlib_Option.getOr(config.baseModulePrefix, Text.toPascalCase(baseName));
+      codeOutput = ModuleGenerator.generateSeparatePerTagModules(baseName, basePrefix, fork.name, undefined, sharedEndpoints, extensionEndpoints, Stdlib_Option.flatMap(sharedSpec.components, c => c.schemas), Stdlib_Option.flatMap(fork.spec.components, c => c.schemas), config.outputDir, config.docOverrideDir);
+    }
+    let targets = Stdlib_Option.getOr(config.targets, {
+      rescriptApi: true,
+      rescriptWrapper: false,
+      typescriptDts: false,
+      typescriptWrapper: false
+    });
+    let match$2 = config.strategy;
+    let match$3;
+    match$3 = match$2 === "Separate" ? [
+        fork.spec,
+        forkEndpoints,
+        [],
+        ""
+      ] : [
+        sharedSpec,
+        sharedEndpoints,
+        extensionEndpoints,
+        Stdlib_Option.getOr(config.baseModulePrefix, Stdlib_Option.getOr(Stdlib_Option.map(config.baseInstanceName, prim => Text.toPascalCase(prim)), ""))
+      ];
+    let wExt = match$3[2];
+    let wShared = match$3[1];
+    let wSpec = match$3[0];
+    let wrapperOutput = targets.rescriptWrapper ? ThinWrapperGenerator.generateWrapper(wSpec, wShared, wExt, FileSystem.makePath(config.outputDir, fork.name), Text.toPascalCase(fork.name) + "Wrapper", Text.toPascalCase(fork.name), match$3[3]) : Pipeline.empty;
+    let allWEndpoints = wShared.concat(wExt);
+    let dtsOutput = targets.typescriptDts ? TypeScriptDtsGenerator.generate(wSpec, allWEndpoints, FileSystem.makePath(Stdlib_Option.getOr(config.dtsOutputDir, config.outputDir), fork.name)) : Pipeline.empty;
+    let tsWrapperOutput = targets.typescriptWrapper ? TypeScriptWrapperGenerator.generate(allWEndpoints, FileSystem.makePath(Stdlib_Option.getOr(config.wrapperOutputDir, config.outputDir), fork.name), `../../generated/` + fork.name) : Pipeline.empty;
+    let reports = Pipeline.fromFiles(Belt_Array.concatMany([
+      [mergeReportFile],
+      Stdlib_Option.getOr(Stdlib_Option.map(diffReportFile, f => [f]), [])
+    ]));
+    return {
+      TAG: "Ok",
+      _0: Pipeline.combine([
+        reports,
+        codeOutput,
+        wrapperOutput,
+        dtsOutput,
+        tsWrapperOutput
+      ])
+    };
+  } catch (raw_err) {
+    let err = Primitive_exceptions.internalToException(raw_err);
+    if (err.RE_EXN_ID === "JsExn") {
+      return {
+        TAG: "Error",
+        _0: {
+          TAG: "UnknownError",
+          message: Stdlib_Option.getOr(Stdlib_JsExn.message(err._1), "Unknown error"),
+          context: undefined
+        }
+      };
+    } else {
+      return {
+        TAG: "Error",
+        _0: {
+          TAG: "UnknownError",
+          message: "Unknown error",
+          context: undefined
+        }
+      };
+    }
+  }
+}
+
+function generateMultiSpecPure(baseSpec, forkSpecs, config) {
+  try {
+    let baseEndpoints = OpenAPIParser.getAllEndpoints(baseSpec);
+    let forkResults = forkSpecs.map(fork => processForkPure(baseSpec, baseEndpoints, fork, config));
+    let match = forkResults.find(Stdlib_Result.isError);
+    let exit = 0;
+    if (match !== undefined) {
+      if (match.TAG !== "Ok") {
+        return {
+          TAG: "Error",
+          _0: match._0
+        };
+      }
+      exit = 1;
+    } else {
+      exit = 1;
+    }
+    if (exit === 1) {
+      let outputs = Stdlib_Array.filterMap(forkResults, res => {
+        if (res.TAG === "Ok") {
+          return res._0;
+        }
+      });
+      let targets = Stdlib_Option.getOr(config.targets, Config.defaultTargets());
+      let baseName = Stdlib_Option.getOrThrow(config.baseInstanceName, "baseInstanceName required");
+      let basePrefix = Stdlib_Option.getOr(config.baseModulePrefix, Text.toPascalCase(baseName));
+      let baseOutputDir = FileSystem.makePath(config.outputDir, baseName);
+      let baseWrappers = Pipeline.combine([
+        targets.rescriptWrapper ? ThinWrapperGenerator.generateWrapper(baseSpec, baseEndpoints, undefined, baseOutputDir, basePrefix + "Wrapper", basePrefix, undefined) : Pipeline.empty,
+        targets.typescriptDts ? TypeScriptDtsGenerator.generate(baseSpec, baseEndpoints, FileSystem.makePath(Stdlib_Option.getOr(config.dtsOutputDir, config.outputDir), baseName)) : Pipeline.empty,
+        targets.typescriptWrapper ? TypeScriptWrapperGenerator.generate(baseEndpoints, FileSystem.makePath(Stdlib_Option.getOr(config.wrapperOutputDir, config.outputDir), baseName), `../../generated/` + baseName) : Pipeline.empty
+      ]);
+      return {
+        TAG: "Ok",
+        _0: Pipeline.combine(outputs.concat([baseWrappers]))
+      };
+    }
+  } catch (raw_err) {
+    let err = Primitive_exceptions.internalToException(raw_err);
+    if (err.RE_EXN_ID === "JsExn") {
+      return {
+        TAG: "Error",
+        _0: {
+          TAG: "UnknownError",
+          message: Stdlib_Option.getOr(Stdlib_JsExn.message(err._1), "Unknown error"),
+          context: undefined
+        }
+      };
+    } else {
+      return {
+        TAG: "Error",
+        _0: {
+          TAG: "UnknownError",
+          message: "Unknown error",
+          context: undefined
+        }
+      };
+    }
+  }
+}
+
+async function generateMultiSpec(baseSpec, forkSpecs, config) {
+  let err = generateMultiSpecPure(baseSpec, forkSpecs, config);
+  if (err.TAG !== "Ok") {
+    return {
+      TAG: "Error",
+      _0: err._0
+    };
+  }
+  let output = err._0;
+  return Stdlib_Result.mapError(Stdlib_Result.map(FileSystem.writeFiles(output.files), filePaths => ({
+    generatedFiles: filePaths,
+    diff: undefined,
+    warnings: output.warnings
+  })), errors => ({
+    TAG: "UnknownError",
+    message: `Failed to write files: ` + errors.join(", "),
+    context: undefined
+  }));
+}
+
+async function compareSpecs(baseSpec, forkSpec, baseNameOpt, forkNameOpt, outputPath) {
+  let baseName = baseNameOpt !== undefined ? baseNameOpt : "base";
+  let forkName = forkNameOpt !== undefined ? forkNameOpt : "fork";
+  let diff = SpecDiffer.generateDiff(baseSpec, forkSpec, OpenAPIParser.getAllEndpoints(baseSpec), OpenAPIParser.getAllEndpoints(forkSpec));
+  Stdlib_Option.forEach(outputPath, path => {
+    FileSystem.writeFile({
+      path: path,
+      content: DiffReportGenerator.generateMarkdownReport(diff, baseName, forkName)
+    });
+  });
+  return diff;
+}
+
+async function generate(config) {
+  let message = await SchemaRefResolver.resolve(config.specPath, undefined);
+  if (message.TAG !== "Ok") {
+    return {
+      TAG: "Error",
+      _0: {
+        TAG: "SpecResolutionError",
+        url: config.specPath,
+        message: message._0
+      }
+    };
+  }
+  let baseSpec = message._0;
+  let forkConfigs = config.forkSpecs;
+  if (forkConfigs === undefined) {
+    return await generateSingleSpec(baseSpec, config);
+  }
+  if (forkConfigs.length === 0) {
+    return await generateSingleSpec(baseSpec, config);
+  }
+  let forkResults = await Promise.all(forkConfigs.map(async f => Stdlib_Result.map(await SchemaRefResolver.resolve(f.specPath, undefined), spec => ({
+    name: f.name,
+    spec: spec
+  }))));
+  let match = forkResults.find(Stdlib_Result.isError);
+  if (match !== undefined && match.TAG !== "Ok") {
+    return {
+      TAG: "Error",
+      _0: {
+        TAG: "SpecResolutionError",
+        url: "",
+        message: match._0
+      }
+    };
+  }
+  return await generateMultiSpec(baseSpec, Stdlib_Array.filterMap(forkResults, res => {
+    if (res.TAG === "Ok") {
+      return res._0;
+    }
+  }), config);
+}
+
+function createDefaultConfig(url, outputDir) {
+  return {
+    specPath: url,
+    forkSpecs: undefined,
+    outputDir: outputDir,
+    strategy: "SharedBase",
+    modulePerTag: true,
+    includeTags: undefined,
+    excludeTags: undefined,
+    generateDiffReport: true,
+    breakingChangeHandling: "Warn",
+    generateDocOverrides: undefined,
+    docOverrideDir: undefined,
+    targets: undefined,
+    dtsOutputDir: undefined,
+    wrapperOutputDir: undefined,
+    baseInstanceName: undefined,
+    baseModulePrefix: undefined
+  };
+}
+
+async function generateFromUrl(url, outputDir, config) {
+  let init = Stdlib_Option.getOr(config, createDefaultConfig(url, outputDir));
+  return await generate({
+    specPath: url,
+    forkSpecs: init.forkSpecs,
+    outputDir: init.outputDir,
+    strategy: init.strategy,
+    modulePerTag: init.modulePerTag,
+    includeTags: init.includeTags,
+    excludeTags: init.excludeTags,
+    generateDiffReport: init.generateDiffReport,
+    breakingChangeHandling: init.breakingChangeHandling,
+    generateDocOverrides: init.generateDocOverrides,
+    docOverrideDir: init.docOverrideDir,
+    targets: init.targets,
+    dtsOutputDir: init.dtsOutputDir,
+    wrapperOutputDir: init.wrapperOutputDir,
+    baseInstanceName: init.baseInstanceName,
+    baseModulePrefix: init.baseModulePrefix
+  });
+}
+
+async function generateFromFile(filePath, outputDir, config) {
+  let init = Stdlib_Option.getOr(config, createDefaultConfig(filePath, outputDir));
+  return await generate({
+    specPath: filePath,
+    forkSpecs: init.forkSpecs,
+    outputDir: init.outputDir,
+    strategy: init.strategy,
+    modulePerTag: init.modulePerTag,
+    includeTags: init.includeTags,
+    excludeTags: init.excludeTags,
+    generateDiffReport: init.generateDiffReport,
+    breakingChangeHandling: init.breakingChangeHandling,
+    generateDocOverrides: init.generateDocOverrides,
+    docOverrideDir: init.docOverrideDir,
+    targets: init.targets,
+    dtsOutputDir: init.dtsOutputDir,
+    wrapperOutputDir: init.wrapperOutputDir,
+    baseInstanceName: init.baseInstanceName,
+    baseModulePrefix: init.baseModulePrefix
+  });
+}
+
+export {
+  generateSingleSpecPure,
+  generateSingleSpec,
+  processForkPure,
+  generateMultiSpecPure,
+  generateMultiSpec,
+  compareSpecs,
+  generate,
+  createDefaultConfig,
+  generateFromUrl,
+  generateFromFile,
+}
+/* @std/text Not a pure module */

package/lib/es6/src/Types.mjs

@@ -0,0 +1,20 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as CodegenError from "./types/CodegenError.mjs";
+
+let Warning_toString = CodegenError.Warning.toString;
+
+let Warning_print = CodegenError.Warning.print;
+
+let Warning = {
+  toString: Warning_toString,
+  print: Warning_print
+};
+
+let CodegenError$1;
+
+export {
+  CodegenError$1 as CodegenError,
+  Warning,
+}
+/* No side effect */

package/lib/es6/src/core/CodegenUtils.mjs

@@ -0,0 +1,186 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Text from "@std/text";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+
+function sanitizeIdentifier(str) {
+  return str.replaceAll("{", "").replaceAll("}", "").replaceAll("[", "").replaceAll("]", "").replaceAll(".", "_").replaceAll("-", "_").replaceAll("/", "_").replaceAll(" ", "_");
+}
+
+function generateTypeName(prefixOpt, path, suffix) {
+  let prefix = prefixOpt !== undefined ? prefixOpt : "";
+  let cleaned = sanitizeIdentifier(path.replaceAll("/", "_")).split("_").filter(part => part !== "").map(prim => Text.toPascalCase(prim)).join("");
+  return prefix + cleaned + suffix;
+}
+
+function generateOperationName(operationId, path, method) {
+  if (operationId !== undefined) {
+    return Text.toCamelCase(sanitizeIdentifier(operationId));
+  } else {
+    return method.toLowerCase() + path.split("/").filter(part => {
+      if (part !== "") {
+        return !part.startsWith("{");
+      } else {
+        return false;
+      }
+    }).map(prim => Text.toCamelCase(prim)).join("");
+  }
+}
+
+function escapeString(str) {
+  return str.replaceAll("\\", "\\\\").replaceAll("\"", "\\\"").replaceAll("\n", "\\n").replaceAll("\r", "\\r").replaceAll("\t", "\\t");
+}
+
+function generateFileHeader(description) {
+  return `// ` + description + `
+// Generated by @f3liz/rescript-autogen-openapi
+// DO NOT EDIT - This file is auto-generated
+
+`;
+}
+
+function indent(code, level) {
+  let spaces = "  ".repeat(level);
+  return code.split("\n").map(line => {
+    if (line.trim() === "") {
+      return "";
+    } else {
+      return spaces + line;
+    }
+  }).join("\n");
+}
+
+function trimMargin(text, marginPrefixOpt) {
+  let marginPrefix = marginPrefixOpt !== undefined ? marginPrefixOpt : "|";
+  return text.split("\n").map(line => {
+    let trimmed = line.trimStart();
+    if (trimmed.startsWith(marginPrefix)) {
+      return trimmed.slice(marginPrefix.length);
+    } else {
+      return line;
+    }
+  }).join("\n").trim();
+}
+
+let rescriptKeywords = [
+  "and",
+  "as",
+  "assert",
+  "async",
+  "await",
+  "catch",
+  "class",
+  "constraint",
+  "do",
+  "done",
+  "downto",
+  "else",
+  "end",
+  "exception",
+  "external",
+  "false",
+  "for",
+  "fun",
+  "function",
+  "functor",
+  "if",
+  "in",
+  "include",
+  "inherit",
+  "initializer",
+  "lazy",
+  "let",
+  "method",
+  "module",
+  "mutable",
+  "new",
+  "nonrec",
+  "object",
+  "of",
+  "open",
+  "or",
+  "private",
+  "rec",
+  "sig",
+  "struct",
+  "switch",
+  "then",
+  "to",
+  "true",
+  "try",
+  "type",
+  "val",
+  "virtual",
+  "when",
+  "while",
+  "with"
+];
+
+function escapeKeyword(name) {
+  if (rescriptKeywords.includes(name)) {
+    return name + "_";
+  } else {
+    return name;
+  }
+}
+
+function generateDocComment(summary, description, param) {
+  if (summary !== undefined) {
+    if (description !== undefined) {
+      return `// ` + summary + `\n// ` + description + `\n`;
+    } else {
+      return `// ` + summary + `\n`;
+    }
+  } else if (description !== undefined) {
+    return `// ` + description + `\n`;
+  } else {
+    return "";
+  }
+}
+
+function generateDocString(summary, description, param) {
+  let content = summary !== undefined ? (
+      description !== undefined ? (
+          summary === description ? summary : summary + "\n\n" + description
+        ) : summary
+    ) : (
+      description !== undefined ? description : undefined
+    );
+  return Stdlib_Option.getOr(Stdlib_Option.map(content, text => {
+    let lines = text.trim().split("\n").map(prim => prim.trim());
+    let len = lines.length;
+    if (len !== 1) {
+      if (len !== 0) {
+        return "/**\n" + lines.map(l => {
+          if (l === "") {
+            return " *";
+          } else {
+            return ` * ` + l;
+          }
+        }).join("\n") + "\n */\n";
+      } else {
+        return "";
+      }
+    }
+    let line = lines[0];
+    return `/** ` + line + ` */\n`;
+  }), "");
+}
+
+let fetchTypeSignature = "(~url: string, ~method_: string, ~body: option<JSON.t>) => Promise.t<JSON.t>";
+
+export {
+  sanitizeIdentifier,
+  generateTypeName,
+  generateOperationName,
+  escapeString,
+  generateFileHeader,
+  indent,
+  trimMargin,
+  rescriptKeywords,
+  escapeKeyword,
+  generateDocComment,
+  generateDocString,
+  fetchTypeSignature,
+}
+/* @std/text Not a pure module */