@thi.ng/tangle 0.1.67 → 0.1.69

package/CHANGELOG.md

@@ -1,6 +1,6 @@
 # Change Log
 
-- **Last updated**: 2023-12-03T12:13:31Z
+- **Last updated**: 2023-12-18T13:41:20Z
 - **Generator**: [thi.ng/monopub](https://thi.ng/monopub)
 
 All notable changes to this project will be documented in this file.

package/README.md

@@ -322,7 +322,7 @@ For Node.js REPL:
 const tangle = await import("@thi.ng/tangle");
 ```
 
-Package sizes (brotli'd, pre-treeshake): ESM: 1.84 KB
+Package sizes (brotli'd, pre-treeshake): ESM: 1.83 KB
 
 ## Dependencies
 

package/api.js

@@ -1,14 +1,14 @@
 import { LogLevel } from "@thi.ng/logger";
 import { ConsoleLogger } from "@thi.ng/logger/console";
-export const BLOCK_FORMATS = {
-    ".md": {
-        prefix: "```",
-        suffix: "```",
-    },
-    ".org": {
-        prefix: "#+BEGIN_SRC ",
-        suffix: "#+END_SRC",
-    },
+const BLOCK_FORMATS = {
+  ".md": {
+    prefix: "```",
+    suffix: "```"
+  },
+  ".org": {
+    prefix: "#+BEGIN_SRC ",
+    suffix: "#+END_SRC"
+  }
 };
 const C = "//";
 const P = "#";
@@ -16,44 +16,50 @@ const L = "--";
 const S = ";;";
 const C89 = ["/*", "*/"];
 const HTML = ["<!--", "-->"];
-export const COMMENT_FORMATS = {
-    c: C89,
-    clj: S,
-    cljs: S,
-    cpp: C,
-    cs: C,
-    css: C89,
-    docker: "::",
-    elm: L,
-    erl: "%",
-    fs: "\\",
-    go: C,
-    h: C,
-    html: HTML,
-    java: C,
-    js: C,
-    jsonc: C,
-    lua: L,
-    md: HTML,
-    ml: ["(*", "*)"],
-    pde: C,
-    py: P,
-    rs: C,
-    scala: C,
-    scm: S,
-    sh: P,
-    sql: L,
-    swift: C,
-    tex: "%",
-    toml: P,
-    ts: C,
-    ttl: P,
-    wast: S,
-    xml: HTML,
-    yaml: P,
-    zig: C,
+const COMMENT_FORMATS = {
+  c: C89,
+  clj: S,
+  cljs: S,
+  cpp: C,
+  cs: C,
+  css: C89,
+  docker: "::",
+  elm: L,
+  erl: "%",
+  fs: "\\",
+  go: C,
+  h: C,
+  html: HTML,
+  java: C,
+  js: C,
+  jsonc: C,
+  lua: L,
+  md: HTML,
+  ml: ["(*", "*)"],
+  pde: C,
+  py: P,
+  rs: C,
+  scala: C,
+  scm: S,
+  sh: P,
+  sql: L,
+  swift: C,
+  tex: "%",
+  toml: P,
+  ts: C,
+  ttl: P,
+  wast: S,
+  xml: HTML,
+  yaml: P,
+  zig: C
 };
-export let LOGGER = new ConsoleLogger("tangle", LogLevel.INFO);
-export const setLogger = (logger) => {
-    LOGGER = logger;
+let LOGGER = new ConsoleLogger("tangle", LogLevel.INFO);
+const setLogger = (logger) => {
+  LOGGER = logger;
+};
+export {
+  BLOCK_FORMATS,
+  COMMENT_FORMATS,
+  LOGGER,
+  setLogger
 };

package/cli.js

@@ -1,64 +1,73 @@
-// thing:no-export
-import { ParseError, flag, parse, usage, } from "@thi.ng/args";
+import {
+  ParseError,
+  flag,
+  parse,
+  usage
+} from "@thi.ng/args";
 import { readJSON, writeText } from "@thi.ng/file-io";
 import { ConsoleLogger } from "@thi.ng/logger";
 import { resolve } from "path";
 import { tangleFile } from "./tangle.js";
 const argOpts = {
-    noComments: flag({ default: false, desc: "don't generate comments" }),
-    debug: flag({ alias: "d", default: false, desc: "enable debug output" }),
-    dryRun: flag({
-        default: false,
-        desc: "enable dry run (don't overwrite files)",
-    }),
+  noComments: flag({ default: false, desc: "don't generate comments" }),
+  debug: flag({ alias: "d", default: false, desc: "enable debug output" }),
+  dryRun: flag({
+    default: false,
+    desc: "enable dry run (don't overwrite files)"
+  })
 };
-export const INSTALL_DIR = resolve(`${process.argv[2]}/..`);
-export const PKG = readJSON(`${INSTALL_DIR}/package.json`);
-export const APP_NAME = PKG.name.split("/")[1];
-export const HEADER = `
- █ █   █           │
-██ █               │
- █ █ █ █   █ █ █ █ │ ${PKG.name} ${PKG.version}
- █ █ █ █ █ █ █ █ █ │ Literate programming code block tangling
-                 █ │
-               █ █ │
+const INSTALL_DIR = resolve(`${process.argv[2]}/..`);
+const PKG = readJSON(`${INSTALL_DIR}/package.json`);
+const APP_NAME = PKG.name.split("/")[1];
+const HEADER = `
+ \u2588 \u2588   \u2588           \u2502
+\u2588\u2588 \u2588               \u2502
+ \u2588 \u2588 \u2588 \u2588   \u2588 \u2588 \u2588 \u2588 \u2502 ${PKG.name} ${PKG.version}
+ \u2588 \u2588 \u2588 \u2588 \u2588 \u2588 \u2588 \u2588 \u2588 \u2502 Literate programming code block tangling
+                 \u2588 \u2502
+               \u2588 \u2588 \u2502
 `;
 const usageOpts = {
-    lineWidth: process.stdout.columns,
-    prefix: `${HEADER}
+  lineWidth: process.stdout.columns,
+  prefix: `${HEADER}
 usage: ${APP_NAME} [OPTS] SOURCE-FILES(S) ...
        ${APP_NAME} --help
 
 `,
-    showGroupNames: true,
-    paramWidth: 20,
+  showGroupNames: true,
+  paramWidth: 20
 };
 const showUsage = () => {
-    process.stderr.write(usage(argOpts, usageOpts));
-    process.exit(1);
+  process.stderr.write(usage(argOpts, usageOpts));
+  process.exit(1);
 };
 try {
-    const result = parse(argOpts, process.argv, { start: 3, usageOpts });
-    if (!result)
-        process.exit(1);
-    const { result: opts, rest } = result;
-    if (!rest.length)
-        showUsage();
-    let ctx = {
-        logger: new ConsoleLogger("tangle", opts.debug ? "DEBUG" : "INFO"),
-        opts: {
-            comments: opts.noComments !== true,
-        },
-    };
-    for (let file of rest) {
-        ctx = tangleFile(file, ctx);
-    }
-    for (let out in ctx.outputs) {
-        writeText(out, ctx.outputs[out], ctx.logger, opts.dryRun);
-    }
-}
-catch (e) {
-    if (!(e instanceof ParseError))
-        process.stderr.write(e.message);
+  const result = parse(argOpts, process.argv, { start: 3, usageOpts });
+  if (!result)
     process.exit(1);
+  const { result: opts, rest } = result;
+  if (!rest.length)
+    showUsage();
+  let ctx = {
+    logger: new ConsoleLogger("tangle", opts.debug ? "DEBUG" : "INFO"),
+    opts: {
+      comments: opts.noComments !== true
+    }
+  };
+  for (let file of rest) {
+    ctx = tangleFile(file, ctx);
+  }
+  for (let out in ctx.outputs) {
+    writeText(out, ctx.outputs[out], ctx.logger, opts.dryRun);
+  }
+} catch (e) {
+  if (!(e instanceof ParseError))
+    process.stderr.write(e.message);
+  process.exit(1);
 }
+export {
+  APP_NAME,
+  HEADER,
+  INSTALL_DIR,
+  PKG
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thi.ng/tangle",
-  "version": "0.1.67",
+  "version": "0.1.69",
   "description": "Literate programming code block tangling / codegen utility, inspired by org-mode & noweb",
   "type": "module",
   "module": "./index.js",
@@ -25,7 +25,9 @@
   "author": "Karsten Schmidt (https://thi.ng)",
   "license": "Apache-2.0",
   "scripts": {
-    "build": "yarn clean && tsc --declaration",
+    "build": "yarn build:esbuild && yarn build:decl",
+    "build:decl": "tsc --declaration --emitDeclarationOnly",
+    "build:esbuild": "esbuild --format=esm --platform=neutral --target=es2022 --tsconfig=tsconfig.json --outdir=. src/**/*.ts",
     "clean": "rimraf --glob '*.js' '*.d.ts' '*.map' doc",
     "doc": "typedoc --excludePrivate --excludeInternal --out doc src/index.ts",
     "doc:ae": "mkdir -p .ae/doc .ae/temp && api-extractor run --local --verbose",
@@ -34,20 +36,21 @@
     "test": "testament test"
   },
   "dependencies": {
-    "@thi.ng/api": "^8.9.11",
-    "@thi.ng/args": "^2.2.45",
-    "@thi.ng/checks": "^3.4.11",
-    "@thi.ng/compare": "^2.2.7",
-    "@thi.ng/date": "^2.5.5",
-    "@thi.ng/errors": "^2.4.5",
-    "@thi.ng/file-io": "^1.0.4",
-    "@thi.ng/logger": "^2.0.1",
-    "@thi.ng/strings": "^3.7.2",
-    "@thi.ng/transducers": "^8.8.14"
+    "@thi.ng/api": "^8.9.13",
+    "@thi.ng/args": "^2.3.0",
+    "@thi.ng/checks": "^3.4.13",
+    "@thi.ng/compare": "^2.2.9",
+    "@thi.ng/date": "^2.5.7",
+    "@thi.ng/errors": "^2.4.7",
+    "@thi.ng/file-io": "^1.1.0",
+    "@thi.ng/logger": "^2.1.0",
+    "@thi.ng/strings": "^3.7.4",
+    "@thi.ng/transducers": "^8.8.16"
   },
   "devDependencies": {
     "@microsoft/api-extractor": "^7.38.3",
-    "@thi.ng/testament": "^0.4.4",
+    "@thi.ng/testament": "^0.4.6",
+    "esbuild": "^0.19.8",
     "rimraf": "^5.0.5",
     "tools": "^0.0.1",
     "typedoc": "^0.25.4",
@@ -69,7 +72,7 @@
     "setTimeout": false
   },
   "engines": {
-    "node": ">=14"
+    "node": ">=18"
   },
   "files": [
     "./*.js",
@@ -91,5 +94,5 @@
     "status": "alpha",
     "year": 2022
   },
-  "gitHead": "25f2ac8ff795a432a930119661b364d4d93b59a0\n"
+  "gitHead": "25a42a81fac8603a1e440a7aa8bc343276211ff4\n"
 }

package/tangle.js

@@ -7,210 +7,216 @@ import { readText } from "@thi.ng/file-io";
 import { split } from "@thi.ng/strings";
 import { assocObj, map, transduce } from "@thi.ng/transducers";
 import { extname, isAbsolute, resolve, sep } from "path";
-import { BLOCK_FORMATS, COMMENT_FORMATS, LOGGER, } from "./api.js";
-const UnknownBlockError = defError((err) => `can't include unknown block ID: ${err[0]} (via ${err[1]})`, () => "");
+import {
+  BLOCK_FORMATS,
+  COMMENT_FORMATS,
+  LOGGER
+} from "./api.js";
+const UnknownBlockError = defError(
+  (err) => `can't include unknown block ID: ${err[0]} (via ${err[1]})`,
+  () => ""
+);
 const extractBlocks = (src, { format, logger }) => {
-    let nextID = 0;
-    const blocks = {};
-    const re = new RegExp(`^${format.prefix.replace("+", "\\+")}(\\w+)\\s+(.+)$`, "gm");
-    let match;
-    while ((match = re.exec(src))) {
-        let { id, tangle, noweb, publish } = parseBlockHeader(match[2]);
-        !id && (id = `__block-${nextID++}`);
-        const matchStart = match.index;
-        const start = src.indexOf("\n", matchStart) + 1;
-        const end = src.indexOf(`\n${format.suffix}`, matchStart + 1);
-        logger.debug("codeblock", id, start, end, matchStart, src.substring(start, 8));
-        const body = src.substring(start, end);
-        blocks[id] = {
-            id,
-            lang: match[1],
-            tangle,
-            publish,
-            noweb,
-            start,
-            end,
-            matchStart,
-            matchEnd: end + format.suffix.length + 2,
-            body,
-        };
-    }
-    return blocks;
+  let nextID = 0;
+  const blocks = {};
+  const re = new RegExp(
+    `^${format.prefix.replace("+", "\\+")}(\\w+)\\s+(.+)$`,
+    "gm"
+  );
+  let match;
+  while (match = re.exec(src)) {
+    let { id, tangle, noweb, publish } = parseBlockHeader(match[2]);
+    !id && (id = `__block-${nextID++}`);
+    const matchStart = match.index;
+    const start = src.indexOf("\n", matchStart) + 1;
+    const end = src.indexOf(`
+${format.suffix}`, matchStart + 1);
+    logger.debug(
+      "codeblock",
+      id,
+      start,
+      end,
+      matchStart,
+      src.substring(start, 8)
+    );
+    const body = src.substring(start, end);
+    blocks[id] = {
+      id,
+      lang: match[1],
+      tangle,
+      publish,
+      noweb,
+      start,
+      end,
+      matchStart,
+      matchEnd: end + format.suffix.length + 2,
+      body
+    };
+  }
+  return blocks;
 };
 const resolveBlock = (block, ref, ctx) => {
-    if (block.resolved)
-        return;
-    if (block.noweb === "no") {
-        block.resolved = true;
-        return;
-    }
-    ctx.logger.debug("resolve", block.id);
-    const re = /<<(.+)>>/g;
-    let match;
-    let body = block.body;
-    while ((match = re.exec(body))) {
-        const paramIdx = match[1].indexOf(" ");
-        let [childID, params] = paramIdx > 0
-            ? [
-                match[1].substring(0, paramIdx),
-                JSON.parse(match[1].substring(paramIdx).trim()),
-            ]
-            : [match[1]];
-        let childBlock;
-        if (childID.indexOf("#") > 0) {
-            const [file, blockID] = childID.split("#");
-            childBlock = loadAndResolveBlocks(ctx.fs.resolve(ctx.fs.resolve(ref.path, ".."), file), ctx).blocks[blockID];
-            childID = blockID;
-        }
-        else {
-            childID = childID.replace("#", "");
-            childBlock = ref.blocks[childID];
-        }
-        if (!childBlock)
-            throw new UnknownBlockError([childID, block.id]);
-        resolveBlock(childBlock, ref, ctx);
-        const newBody = isPlainObject(params)
-            ? parametricBody(childBlock.body, params)
-            : childBlock.body;
-        block.body = block.body.replace(`<<${match[1]}>>`, newBody);
-        block.edited = true;
-    }
+  if (block.resolved)
+    return;
+  if (block.noweb === "no") {
     block.resolved = true;
-    block.body = block.body.replace(/\\</g, "<");
+    return;
+  }
+  ctx.logger.debug("resolve", block.id);
+  const re = /<<(.+)>>/g;
+  let match;
+  let body = block.body;
+  while (match = re.exec(body)) {
+    const paramIdx = match[1].indexOf(" ");
+    let [childID, params] = paramIdx > 0 ? [
+      match[1].substring(0, paramIdx),
+      JSON.parse(match[1].substring(paramIdx).trim())
+    ] : [match[1]];
+    let childBlock;
+    if (childID.indexOf("#") > 0) {
+      const [file, blockID] = childID.split("#");
+      childBlock = loadAndResolveBlocks(
+        ctx.fs.resolve(ctx.fs.resolve(ref.path, ".."), file),
+        ctx
+      ).blocks[blockID];
+      childID = blockID;
+    } else {
+      childID = childID.replace("#", "");
+      childBlock = ref.blocks[childID];
+    }
+    if (!childBlock)
+      throw new UnknownBlockError([childID, block.id]);
+    resolveBlock(childBlock, ref, ctx);
+    const newBody = isPlainObject(params) ? parametricBody(childBlock.body, params) : childBlock.body;
+    block.body = block.body.replace(`<<${match[1]}>>`, newBody);
+    block.edited = true;
+  }
+  block.resolved = true;
+  block.body = block.body.replace(/\\</g, "<");
 };
 const resolveBlocks = (ref, ctx) => {
-    for (let id in ref.blocks) {
-        resolveBlock(ref.blocks[id], ref, ctx);
-    }
-    return ref;
+  for (let id in ref.blocks) {
+    resolveBlock(ref.blocks[id], ref, ctx);
+  }
+  return ref;
 };
 const parseFileMeta = (src) => {
-    if (!src.startsWith("---\n"))
-        return {};
-    const res = {};
-    for (let line of split(src.substring(4))) {
-        if (line === "---")
-            break;
-        const [key, val] = line.split(/:\s+/g);
-        res[key.trim()] = val.trim();
-    }
-    return res;
+  if (!src.startsWith("---\n"))
+    return {};
+  const res = {};
+  for (let line of split(src.substring(4))) {
+    if (line === "---")
+      break;
+    const [key, val] = line.split(/:\s+/g);
+    res[key.trim()] = val.trim();
+  }
+  return res;
 };
-const parseBlockHeader = (header) => transduce(map((x) => x.split(":")), assocObj(), header.split(/\s+/));
-const parametricBody = (body, params) => body.replace(/\{\{(\w+)\}\}/g, (_, id) => params[id] != null ? params[id] : id);
+const parseBlockHeader = (header) => transduce(
+  map((x) => x.split(":")),
+  assocObj(),
+  header.split(/\s+/)
+);
+const parametricBody = (body, params) => body.replace(
+  /\{\{(\w+)\}\}/g,
+  (_, id) => params[id] != null ? params[id] : id
+);
 const commentForLang = (lang, body) => {
-    const syntax = COMMENT_FORMATS[lang];
-    return isString(syntax)
-        ? `${syntax} ${body}`
-        : `${syntax[0]} ${body} ${syntax[1]}`;
+  const syntax = COMMENT_FORMATS[lang];
+  return isString(syntax) ? `${syntax} ${body}` : `${syntax[0]} ${body} ${syntax[1]}`;
 };
 const loadAndResolveBlocks = (path, ctx) => {
-    path = ctx.fs.resolve(path);
-    if (!ctx.files[path]) {
-        const src = ctx.fs.read(path, ctx.logger);
-        const blocks = extractBlocks(src, ctx);
-        const ref = (ctx.files[path] = { path, src, blocks });
-        resolveBlocks(ref, ctx);
-    }
-    return ctx.files[path];
+  path = ctx.fs.resolve(path);
+  if (!ctx.files[path]) {
+    const src = ctx.fs.read(path, ctx.logger);
+    const blocks = extractBlocks(src, ctx);
+    const ref = ctx.files[path] = { path, src, blocks };
+    resolveBlocks(ref, ctx);
+  }
+  return ctx.files[path];
 };
-/**
- * Takes a file `path` and partial {@link TangleCtx}. Reads "file"
- * (implementation specific, could be from memory or other source) and then
- * performs all tangling steps on the document body, i.e. expanding &
- * transcluding code blocks, generating outputs for various target files etc.
- * Returns updated TangleCtx with all generated outputs stored under the
- * {@link TangleCtx.outputs} key.
- *
- * @param path
- * @param ctx
- */
-export const tangleFile = (path, ctx = {}) => {
-    const fmt = ctx.format || BLOCK_FORMATS[extname(path)];
-    !fmt && illegalArgs(`unsupported file type: ${extname(path)}`);
-    const $ctx = {
-        files: {},
-        outputs: {},
-        format: fmt,
-        logger: LOGGER,
-        fs: {
-            isAbsolute,
-            resolve,
-            read: readText,
-        },
-        ...ctx,
-        opts: {
-            comments: true,
-            ...ctx.opts,
-        },
-    };
-    const { path: $path, src, blocks } = loadAndResolveBlocks(path, $ctx);
-    const parentDir = $ctx.fs.resolve($path, "..");
-    const meta = parseFileMeta(src);
-    const sorted = Object.values(blocks).sort(compareByKey("start"));
-    let prev = 0;
-    let res = [];
-    for (let block of sorted) {
-        if (meta.publish) {
-            res.push(src.substring(prev, Math.max(prev, block.matchStart)));
-            if (block.publish !== "no") {
-                res.push(`${fmt.prefix}${block.lang}\n${block.body}\n${fmt.suffix}\n`);
-            }
-        }
-        if (block.tangle) {
-            const dest = $ctx.fs.isAbsolute(block.tangle)
-                ? block.tangle
-                : $ctx.fs.resolve(parentDir, `${meta.tangle || "."}${sep}${block.tangle}`);
-            let body = block.body;
-            if (!$ctx.outputs[dest]) {
-                if ($ctx.opts.comments && COMMENT_FORMATS[block.lang]) {
-                    body = [
-                        commentForLang(block.lang, `Tangled @ ${FMT_ISO_SHORT()} - DO NOT EDIT!`),
-                        commentForLang(block.lang, `Source: ${$path}`),
-                        "",
-                        body,
-                    ].join("\n");
-                }
-                $ctx.outputs[dest] = body;
-            }
-            else {
-                $ctx.outputs[dest] += "\n\n" + body;
-            }
-        }
-        prev = block.matchEnd;
+const tangleFile = (path, ctx = {}) => {
+  const fmt = ctx.format || BLOCK_FORMATS[extname(path)];
+  !fmt && illegalArgs(`unsupported file type: ${extname(path)}`);
+  const $ctx = {
+    files: {},
+    outputs: {},
+    format: fmt,
+    logger: LOGGER,
+    fs: {
+      isAbsolute,
+      resolve,
+      read: readText
+    },
+    ...ctx,
+    opts: {
+      comments: true,
+      ...ctx.opts
     }
-    res.push(src.substring(prev));
+  };
+  const { path: $path, src, blocks } = loadAndResolveBlocks(path, $ctx);
+  const parentDir = $ctx.fs.resolve($path, "..");
+  const meta = parseFileMeta(src);
+  const sorted = Object.values(blocks).sort(compareByKey("start"));
+  let prev = 0;
+  let res = [];
+  for (let block of sorted) {
     if (meta.publish) {
-        const dest = $ctx.fs.resolve(parentDir, meta.publish);
-        $ctx.outputs[dest] = res.join("").trim();
+      res.push(src.substring(prev, Math.max(prev, block.matchStart)));
+      if (block.publish !== "no") {
+        res.push(
+          `${fmt.prefix}${block.lang}
+${block.body}
+${fmt.suffix}
+`
+        );
+      }
+    }
+    if (block.tangle) {
+      const dest = $ctx.fs.isAbsolute(block.tangle) ? block.tangle : $ctx.fs.resolve(
+        parentDir,
+        `${meta.tangle || "."}${sep}${block.tangle}`
+      );
+      let body = block.body;
+      if (!$ctx.outputs[dest]) {
+        if ($ctx.opts.comments && COMMENT_FORMATS[block.lang]) {
+          body = [
+            commentForLang(
+              block.lang,
+              `Tangled @ ${FMT_ISO_SHORT()} - DO NOT EDIT!`
+            ),
+            commentForLang(block.lang, `Source: ${$path}`),
+            "",
+            body
+          ].join("\n");
+        }
+        $ctx.outputs[dest] = body;
+      } else {
+        $ctx.outputs[dest] += "\n\n" + body;
+      }
     }
-    return $ctx;
+    prev = block.matchEnd;
+  }
+  res.push(src.substring(prev));
+  if (meta.publish) {
+    const dest = $ctx.fs.resolve(parentDir, meta.publish);
+    $ctx.outputs[dest] = res.join("").trim();
+  }
+  return $ctx;
 };
-/**
- * In-memory version of {@link tangleFile}. Take a file name and an object of
- * file names and their respective contents, then calls {@link tangleFile} with
- * a customized {@link TangleCtx} which resolves code block refs using given
- * virtual "file system" (of sorts).
- *
- * @remarks
- * Relative file reference paths are only supported if they refer to children or
- * siblings, i.e. `foo/bar.md` is okay, but `../foo/bar.md` is NOT supported.
- *
- * @param fileID
- * @param files
- * @param ctx
- */
-export const tangleString = (fileID, files, ctx = {}) => tangleFile(fileID, {
-    fs: {
-        isAbsolute: (path) => path[0] === "/" || path[0] === "\\",
-        resolve: (...path) => path[path.length - 1],
-        read: (path, logger) => {
-            logger.debug("reading file ref", path);
-            const body = files[path];
-            return body !== undefined
-                ? body
-                : illegalArgs(`missing file for ref: ${path}`);
-        },
-    },
-    ...ctx,
+const tangleString = (fileID, files, ctx = {}) => tangleFile(fileID, {
+  fs: {
+    isAbsolute: (path) => path[0] === "/" || path[0] === "\\",
+    resolve: (...path) => path[path.length - 1],
+    read: (path, logger) => {
+      logger.debug("reading file ref", path);
+      const body = files[path];
+      return body !== void 0 ? body : illegalArgs(`missing file for ref: ${path}`);
+    }
+  },
+  ...ctx
 });
+export {
+  tangleFile,
+  tangleString
+};