@asciidoctor/core 4.0.0-alpha.3 → 4.0.0-alpha.5

package/src/abstract_node.js

@@ -31,6 +31,7 @@ import {
   extname,
   prepareSourceString,
 } from './helpers.js'
+import { fetchUri } from './http_cache.js'
 
 // ── Node.js fs (lazy, optional) ───────────────────────────────────────────────
 // Loaded on first use in Node.js; silently absent in browser/WebWorker environments.
@@ -485,10 +486,7 @@ export class AbstractNode {
           (targetImage = this.normalizeWebPath(targetImage, imagesBase, false)))
       ) {
         return doc.hasAttribute('allow-uri-read')
-          ? this.generateDataUriFromUri(
-              targetImage,
-              doc.hasAttribute('cache-uri')
-            )
+          ? this.generateDataUriFromUri(targetImage)
           : targetImage
       }
       return this.generateDataUri(targetImage, assetDirKey)
@@ -541,10 +539,7 @@ export class AbstractNode {
         )
       : this.normalizeSystemPath(targetImage)
     if (isUriish(imagePath)) {
-      return await this.generateDataUriFromUri(
-        imagePath,
-        this.document.hasAttribute('cache-uri')
-      )
+      return await this.generateDataUriFromUri(imagePath)
     }
     if (await isReadable(imagePath)) {
       const data = await _fsp.readFile(imagePath)
@@ -564,12 +559,12 @@ export class AbstractNode {
    * imageUri, the caller must await the returned Promise.
    *
    * @param {string} imageUri - The URI from which to read the image data (http/https/ftp).
-   * @param {boolean} [cacheUri=false] - A Boolean to control caching (not yet supported in JS).
    * @returns {Promise<string>} a Promise resolving to a String data URI.
    */
-  async generateDataUriFromUri(imageUri, cacheUri = false) {
+  async generateDataUriFromUri(imageUri) {
     try {
-      const response = await fetch(imageUri)
+      const doc = this.document
+      const response = await fetchUri(imageUri, doc)
       if (response.ok) {
         const mimetype = (
           response.headers.get('content-type') || 'application/octet-stream'
@@ -740,7 +735,7 @@ export class AbstractNode {
     ) {
       if (doc.hasAttribute('allow-uri-read')) {
         try {
-          const response = await fetch(resolvedTarget)
+          const response = await fetchUri(resolvedTarget, doc)
           const text = await response.text()
           contents = opts.normalize ? prepareSourceString(text).join(LF) : text
         } catch {
@@ -765,7 +760,7 @@ export class AbstractNode {
       })
     }
 
-    if (contents && opts.warnIfEmpty && contents.length === 0) {
+    if (contents != null && opts.warnIfEmpty && contents.length === 0) {
       this.logger.warn(`contents of ${label} is empty: ${resolvedTarget}`)
     }
     return contents

package/src/browser.js

@@ -10,6 +10,7 @@ import {
   RevisionInfo,
 } from './document.js'
 import { Logger, LoggerManager, MemoryLogger, NullLogger } from './logging.js'
+import { HttpCache, MemoryHttpCache, HttpCacheManager } from './http_cache.js'
 import { SafeMode, ContentModel } from './constants.js'
 import { Timings } from './timings.js'
 import { AbstractNode } from './abstract_node.js'
@@ -28,9 +29,23 @@ import {
   BlockMacroProcessor,
   Extensions,
 } from './extensions.js'
+// Re-export DSL interface types for TypeScript consumers.
+/**
+ * @typedef {import('./extensions.js').ProcessorDslInterface} ProcessorDslInterface
+ * @typedef {import('./extensions.js').DocumentProcessorDslInterface} DocumentProcessorDslInterface
+ * @typedef {import('./extensions.js').SyntaxProcessorDslInterface} SyntaxProcessorDslInterface
+ * @typedef {import('./extensions.js').IncludeProcessorDslInterface} IncludeProcessorDslInterface
+ * @typedef {import('./extensions.js').DocinfoProcessorDslInterface} DocinfoProcessorDslInterface
+ * @typedef {import('./extensions.js').BlockProcessorDslInterface} BlockProcessorDslInterface
+ * @typedef {import('./extensions.js').MacroProcessorDslInterface} MacroProcessorDslInterface
+ * @typedef {import('./extensions.js').InlineMacroProcessorDslInterface} InlineMacroProcessorDslInterface
+ */
 import {
   Converter,
+  ConverterBase,
+  CustomFactory,
   DefaultFactory as DefaultConverterFactory,
+  deriveBackendTraits,
 } from './converter.js'
 import { Inline } from './inline.js'
 import { Block } from './block.js'
@@ -97,6 +112,9 @@ export {
   LoggerManager,
   MemoryLogger,
   NullLogger,
+  HttpCache,
+  MemoryHttpCache,
+  HttpCacheManager,
   SafeMode,
   ContentModel,
   Timings,
@@ -114,7 +132,10 @@ export {
   Extensions,
   Cursor,
   Converter as ConverterFactory,
+  ConverterBase,
+  CustomFactory as ConverterCustomFactory,
   DefaultConverterFactory,
+  deriveBackendTraits,
   DefaultSyntaxHighlighterFactory,
   Html5Converter,
   SyntaxHighlighter,

package/src/convert.js

@@ -11,7 +11,7 @@
 //   - Ruby File.write → async writeFile() via node:fs/promises.
 //   - Ruby Helpers.mkdir_p → mkdirP() from helpers.js.
 //   - Ruby Helpers.uriish? → isUriish() from helpers.js.
-//   - Ruby Stylesheets.instance.write_primary_stylesheet → not yet ported to JS; skipped.
+//   - Ruby Stylesheets.instance.write_primary_stylesheet → Stylesheets.instance.writePrimaryStylesheet() in stylesheets.js; returns false in browser environments.
 //   - Ruby doc.syntax_highlighter → doc.syntaxHighlighter.
 //   - Ruby syntax_hl.write_stylesheet? doc → syntaxHl.writeStylesheet(doc).
 //   - Ruby syntax_hl.write_stylesheet doc, dir → syntaxHl.writeStylesheetToDisk(doc, dir).
@@ -24,6 +24,7 @@
 import { load } from './load.js'
 import { isUriish, mkdirP } from './helpers.js'
 import { SafeMode, DEFAULT_STYLESHEET_KEYS } from './constants.js'
+import { Stylesheets } from './stylesheets.js'
 
 // ── convert ───────────────────────────────────────────────────────────────────
 
@@ -214,7 +215,7 @@ export async function convert(input, options = {}) {
       let copyAsciidoctorStylesheet = false
       let copyUserStylesheet = false
       const stylesheet = doc.getAttribute('stylesheet')
-      if (stylesheet) {
+      if (stylesheet != null) {
         if (DEFAULT_STYLESHEET_KEYS.has(stylesheet)) {
           copyAsciidoctorStylesheet = true
         } else if (!isUriish(stylesheet)) {
@@ -246,7 +247,13 @@ export async function convert(input, options = {}) {
         }
 
         if (copyAsciidoctorStylesheet) {
-          // NOTE Stylesheets.instance.write_primary_stylesheet is not yet ported to JS
+          if (
+            !(await Stylesheets.instance.writePrimaryStylesheet(stylesoutdir))
+          ) {
+            doc.logger.info(
+              'skipping default stylesheet copy: filesystem writes are not supported in this environment'
+            )
+          }
         } else if (copyUserStylesheet) {
           let stylesheetSrc = doc.getAttribute('copycss')
           if (stylesheetSrc === '' || stylesheetSrc === true) {

package/src/converter/html5.js

@@ -29,7 +29,7 @@ import {
   INLINE_MATH_DELIMITERS,
 } from '../constants.js'
 import { XmlSanitizeRx } from '../rx.js'
-import { extname, isUriish } from '../helpers.js'
+import { extname } from '../helpers.js'
 import { Stylesheets } from '../stylesheets.js'
 
 // ── Local regex constants ─────────────────────────────────────────────────────
@@ -1767,32 +1767,13 @@ Your browser does not support the video tag.
 
   // NOTE expose readSvgContents for Bespoke converter
   async readSvgContents(node, target) {
-    const imagesdir = node.document.getAttribute('imagesdir')
-    let resolvedPath
-    let svg
-    if (isUriish(target) || (imagesdir && isUriish(imagesdir))) {
-      svg = await node.readContents(target, {
-        start: imagesdir,
-        normalize: true,
-        warnOnFailure: true,
-        label: 'SVG',
-      })
-      resolvedPath = target
-    } else {
-      resolvedPath = node.normalizeSystemPath(target, imagesdir, null, {
-        targetName: 'image',
-      })
-      svg = await node.readAsset(resolvedPath, {
-        normalize: true,
-        warnOnFailure: true,
-        label: 'SVG',
-      })
-    }
-    if (svg == null) return null // file not found/readable; warning already emitted
-    if (!svg) {
-      node.logger.warn(`contents of SVG is empty: ${resolvedPath}`)
-      return null
-    }
+    let svg = await node.readContents(target, {
+      start: node.document.getAttribute('imagesdir'),
+      normalize: true,
+      label: 'SVG',
+      warnIfEmpty: true,
+    })
+    if (!svg) return null
     if (!svg.startsWith('<svg')) svg = svg.replace(SvgPreambleRx, '')
     // Fix incomplete SVG start tag (missing closing >) by inserting > before the first child element.
     // This handles cases like: <svg width="500"\n<circle .../> where the > is missing.

package/src/document.js

@@ -2091,11 +2091,10 @@ export class Document extends AbstractBlock {
 // ── Helpers ───────────────────────────────────────────────────────────────────
 
 function _expandPath(p) {
-  try {
-    return require('node:path').resolve(p)
-  } catch {
-    return p
-  }
+  const resolver = new PathResolver()
+  const posixed = p.replace(/\\/g, '/')
+  if (resolver.absolutePath(posixed)) return resolver.expandPath(posixed)
+  return resolver.expandPath(`${resolver.workingDir}/${posixed}`)
 }
 
 function _cwd() {

package/src/http_cache.js

@@ -0,0 +1,139 @@
+// HTTP cache system for URI fetching.
+//
+// Provides a pluggable caching layer for all HTTP(S) fetches performed during
+// document conversion (includes, images, readContents). Mirrors the behaviour
+// of Ruby's open-uri/cached mechanism activated by the `cache-uri` attribute.
+//
+// When `cache-uri` is set on the document:
+//   - If a cache has been registered via HttpCacheManager.setCache(), it is used.
+//   - Otherwise an ephemeral MemoryHttpCache is created for the duration of the
+//     conversion (keyed by Document instance via a WeakMap, GC'd with the doc).
+//
+// To implement a custom cache, extend HttpCache and override read(uri).
+
+/**
+ * Base HTTP cache class.
+ *
+ * The default implementation delegates directly to fetch() with no caching.
+ * Subclasses override read() to add caching behaviour.
+ */
+export class HttpCache {
+  /**
+   * Fetch content from a URI, optionally from a cache.
+   * @param {string} uri
+   * @returns {Promise<Response>}
+   */
+  async read(uri) {
+    return fetch(uri)
+  }
+}
+
+/**
+ * In-memory HTTP cache.
+ *
+ * Stores successful responses as ArrayBuffers keyed by URI. On a cache hit
+ * a synthetic Response is reconstructed from the stored data without touching
+ * the network. Non-OK responses (4xx, 5xx) are never cached.
+ *
+ * Safe as an ephemeral per-conversion cache or as a longer-lived process-level
+ * cache when registered via HttpCacheManager.setCache().
+ */
+export class MemoryHttpCache extends HttpCache {
+  /** @type {Map<string, {buffer: ArrayBuffer, status: number, statusText: string, headers: Record<string,string>}>} */
+  #cache = new Map()
+
+  async read(uri) {
+    const entry = this.#cache.get(uri)
+    if (entry) {
+      return new Response(entry.buffer.slice(0), {
+        status: entry.status,
+        statusText: entry.statusText,
+        headers: entry.headers,
+      })
+    }
+    const response = await fetch(uri)
+    if (response.ok) {
+      const buffer = await response.arrayBuffer()
+      const headers = Object.fromEntries(response.headers.entries())
+      this.#cache.set(uri, {
+        buffer,
+        status: response.status,
+        statusText: response.statusText,
+        headers,
+      })
+      return new Response(buffer.slice(0), {
+        status: response.status,
+        statusText: response.statusText,
+        headers,
+      })
+    }
+    return response
+  }
+}
+
+/** @type {WeakMap<object, MemoryHttpCache>} */
+const _ephemeralCaches = new WeakMap()
+
+/**
+ * Singleton manager for the HTTP cache.
+ *
+ * Register a process-level cache:
+ *   HttpCacheManager.setCache(new MemoryHttpCache())
+ *   HttpCacheManager.setCache(new MyFileSystemCache('./cache'))
+ *   HttpCacheManager.setCache(null)  // revert to default ephemeral behaviour
+ *
+ * When no cache is registered and `cache-uri` is set, an ephemeral
+ * MemoryHttpCache is created per Document instance.
+ */
+export const HttpCacheManager = {
+  /** @type {HttpCache|null} */
+  _cache: null,
+
+  /**
+   * Register a cache to use for all conversions.
+   * Pass null to unregister and revert to the ephemeral default.
+   * @param {HttpCache|null} cache
+   */
+  setCache(cache) {
+    this._cache = cache
+  },
+
+  /**
+   * Return the registered process-level cache, or null if none is registered.
+   * @returns {HttpCache|null}
+   */
+  getCache() {
+    return this._cache
+  },
+
+  /**
+   * Return the cache to use for a specific document conversion.
+   *
+   * Returns the registered cache if one exists; otherwise creates (or reuses)
+   * an ephemeral MemoryHttpCache scoped to the document's lifetime via a WeakMap.
+   * @param {object} doc - the current Document instance
+   * @returns {HttpCache}
+   */
+  getCacheForDocument(doc) {
+    if (this._cache) return this._cache
+    let cache = _ephemeralCaches.get(doc)
+    if (!cache) {
+      cache = new MemoryHttpCache()
+      _ephemeralCaches.set(doc, cache)
+    }
+    return cache
+  },
+}
+
+/**
+ * Fetch a URI, routing through the HTTP cache when `cache-uri` is set on the document.
+ * @param {string} uri
+ * @param {object} doc - the current Document instance
+ * @returns {Promise<Response>}
+ */
+export function fetchUri(uri, doc) {
+  if (doc.hasAttribute('cache-uri')) {
+    return HttpCacheManager.getCacheForDocument(doc).read(uri)
+  }
+  return fetch(uri)
+}

package/src/index.js

@@ -10,6 +10,7 @@ import {
   RevisionInfo,
 } from './document.js'
 import { Logger, LoggerManager, MemoryLogger, NullLogger } from './logging.js'
+import { HttpCache, MemoryHttpCache, HttpCacheManager } from './http_cache.js'
 import { SafeMode, ContentModel } from './constants.js'
 import { Timings } from './timings.js'
 import { AbstractNode } from './abstract_node.js'
@@ -123,6 +124,9 @@ export {
   LoggerManager,
   MemoryLogger,
   NullLogger,
+  HttpCache,
+  MemoryHttpCache,
+  HttpCacheManager,
   SafeMode,
   ContentModel,
   Timings,

package/src/path_resolver.js

@@ -123,14 +123,6 @@ export class PathResolver {
       : path
   }
 
-  /**
-   * @param {string} path
-   * @returns {string}
-   */
-  posixfy(path) {
-    return this.posixify(path)
-  }
-
   /**
    * Expand the path by resolving parent references (..) and removing self references (.).
    * @param {string} path
@@ -431,14 +423,27 @@ function _platformSeparator() {
  * @internal
  */
 function _expandPath(p) {
-  if (typeof process !== 'undefined') {
-    // Lazy import to avoid top-level await
-    try {
-      const path = require('node:path')
-      return path.resolve(p).replace(/\\/g, '/')
-    } catch {}
+  if (typeof process === 'undefined') return p
+  const cwd = process.cwd().replace(/\\/g, '/')
+  const full = `${cwd}/${p.replace(/\\/g, '/')}`
+  let root, rest
+  if (full.startsWith('//')) {
+    root = '//'
+    rest = full.slice(2)
+  } else if (full.startsWith('/')) {
+    root = '/'
+    rest = full.slice(1)
+  } else {
+    const slash = full.indexOf('/')
+    root = full.slice(0, slash + 1)
+    rest = full.slice(slash + 1)
+  }
+  const resolved = []
+  for (const seg of rest.split('/')) {
+    if (seg === '..') resolved.pop()
+    else if (seg && seg !== '.') resolved.push(seg)
   }
-  return p
+  return root + resolved.join('/')
 }
 
 /**

package/src/reader.js

@@ -42,6 +42,7 @@ import {
   isUriish,
 } from './helpers.js'
 import { LoggerManager, Logger } from './logging.js'
+import { fetchUri } from './http_cache.js'
 import { Compliance } from './compliance.js'
 import { resolveBrowserIncludePath } from './browser/reader.js'
 
@@ -1309,7 +1310,7 @@ export class PreprocessorReader extends Reader {
     if (targetType === 'uri') {
       let uriContent
       try {
-        const response = await fetch(incPath)
+        const response = await fetchUri(incPath, this._document)
         if (!response.ok)
           throw new Error(`HTTP ${response.status} ${response.statusText}`)
         uriContent = await response.text()

package/src/stylesheets.js

@@ -23,6 +23,21 @@ class StylesheetsClass {
   async embedPrimaryStylesheet() {
     return `<style>\n${defaultStylesheetData}\n</style>`
   }
+
+  async writePrimaryStylesheet(stylesoutdir) {
+    try {
+      const { writeFile } = await import('node:fs/promises')
+      const { join } = await import('node:path')
+      await writeFile(
+        join(stylesoutdir, StylesheetsClass.DEFAULT_STYLESHEET_NAME),
+        defaultStylesheetData,
+        'utf8'
+      )
+      return true
+    } catch {
+      return false
+    }
+  }
 }
 
 export const Stylesheets = {

package/types/abstract_node.d.ts

@@ -278,10 +278,9 @@ export abstract class AbstractNode {
      * imageUri, the caller must await the returned Promise.
      *
      * @param {string} imageUri - The URI from which to read the image data (http/https/ftp).
-     * @param {boolean} [cacheUri=false] - A Boolean to control caching (not yet supported in JS).
      * @returns {Promise<string>} a Promise resolving to a String data URI.
      */
-    generateDataUriFromUri(imageUri: string, cacheUri?: boolean): Promise<string>;
+    generateDataUriFromUri(imageUri: string): Promise<string>;
     /**
      * Normalize the asset file or directory to a concrete and rinsed path.
      *

package/types/http_cache.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Fetch a URI, routing through the HTTP cache when `cache-uri` is set on the document.
+ * @param {string} uri
+ * @param {object} doc - the current Document instance
+ * @returns {Promise<Response>}
+ */
+export function fetchUri(uri: string, doc: object): Promise<Response>;
+/**
+ * Base HTTP cache class.
+ *
+ * The default implementation delegates directly to fetch() with no caching.
+ * Subclasses override read() to add caching behaviour.
+ */
+export class HttpCache {
+    /**
+     * Fetch content from a URI, optionally from a cache.
+     * @param {string} uri
+     * @returns {Promise<Response>}
+     */
+    read(uri: string): Promise<Response>;
+}
+/**
+ * In-memory HTTP cache.
+ *
+ * Stores successful responses as ArrayBuffers keyed by URI. On a cache hit
+ * a synthetic Response is reconstructed from the stored data without touching
+ * the network. Non-OK responses (4xx, 5xx) are never cached.
+ *
+ * Safe as an ephemeral per-conversion cache or as a longer-lived process-level
+ * cache when registered via HttpCacheManager.setCache().
+ */
+export class MemoryHttpCache extends HttpCache {
+    read(uri: any): Promise<any>;
+    #private;
+}
+export namespace HttpCacheManager {
+    /** @type {HttpCache|null} */
+    let _cache: HttpCache | null;
+    /**
+     * Register a cache to use for all conversions.
+     * Pass null to unregister and revert to the ephemeral default.
+     * @param {HttpCache|null} cache
+     */
+    function setCache(cache: HttpCache | null): void;
+    /**
+     * Return the registered process-level cache, or null if none is registered.
+     * @returns {HttpCache|null}
+     */
+    function getCache(): HttpCache | null;
+    /**
+     * Return the cache to use for a specific document conversion.
+     *
+     * Returns the registered cache if one exists; otherwise creates (or reuses)
+     * an ephemeral MemoryHttpCache scoped to the document's lifetime via a WeakMap.
+     * @param {object} doc - the current Document instance
+     * @returns {HttpCache}
+     */
+    function getCacheForDocument(doc: object): HttpCache;
+}

package/types/index.d.cts

@@ -27,14 +27,14 @@ export function load(input: string | string[] | Buffer, options?: any): Promise<
  * @returns {Promise<Document>} - the parsed Document
  */
 export function loadFile(filename: string, options?: any): Promise<Document>;
-export type ProcessorDslInterface = import("./extensions.js").ProcessorDslInterface;
-export type DocumentProcessorDslInterface = import("./extensions.js").DocumentProcessorDslInterface;
-export type SyntaxProcessorDslInterface = import("./extensions.js").SyntaxProcessorDslInterface;
-export type IncludeProcessorDslInterface = import("./extensions.js").IncludeProcessorDslInterface;
-export type DocinfoProcessorDslInterface = import("./extensions.js").DocinfoProcessorDslInterface;
-export type BlockProcessorDslInterface = import("./extensions.js").BlockProcessorDslInterface;
-export type MacroProcessorDslInterface = import("./extensions.js").MacroProcessorDslInterface;
-export type InlineMacroProcessorDslInterface = import("./extensions.js").InlineMacroProcessorDslInterface;
+export type { ProcessorDslInterface } from './extensions.js';
+export type { DocumentProcessorDslInterface } from './extensions.js';
+export type { SyntaxProcessorDslInterface } from './extensions.js';
+export type { IncludeProcessorDslInterface } from './extensions.js';
+export type { DocinfoProcessorDslInterface } from './extensions.js';
+export type { BlockProcessorDslInterface } from './extensions.js';
+export type { MacroProcessorDslInterface } from './extensions.js';
+export type { InlineMacroProcessorDslInterface } from './extensions.js';
 import { Document } from './document.js';
 import { convert } from './convert.js';
 import { convertFile } from './convert.js';
@@ -56,6 +56,9 @@ import { SyntaxHighlighterBase } from './syntax_highlighter.js';
 import { LoggerManager } from './logging.js';
 import { MemoryLogger } from './logging.js';
 import { NullLogger } from './logging.js';
+import { HttpCache } from './http_cache.js';
+import { MemoryHttpCache } from './http_cache.js';
+import { HttpCacheManager } from './http_cache.js';
 import { SafeMode } from './constants.js';
 import { ContentModel } from './constants.js';
 import { Timings } from './timings.js';
@@ -80,4 +83,4 @@ import { deriveBackendTraits } from './converter.js';
 import { DefaultFactory as DefaultSyntaxHighlighterFactory } from './syntax_highlighter.js';
 import Html5Converter from './converter/html5.js';
 import { SyntaxHighlighter } from './syntax_highlighter.js';
-export { convert, convertFile, Document, DocumentTitle, Author, Footnote, ImageReference, RevisionInfo, Logger, AbstractNode, AbstractBlock, Inline, Block, List, ListItem, Section, Reader, SyntaxHighlighterBase, LoggerManager, MemoryLogger, NullLogger, SafeMode, ContentModel, Timings, Registry, Processor, ProcessorExtension, Preprocessor, TreeProcessor, Postprocessor, IncludeProcessor, DocinfoProcessor, BlockProcessor, InlineMacroProcessor, BlockMacroProcessor, Extensions, Cursor, Converter as ConverterFactory, ConverterBase, CustomFactory as ConverterCustomFactory, DefaultConverterFactory, deriveBackendTraits, DefaultSyntaxHighlighterFactory, Html5Converter, SyntaxHighlighter };
+export { convert, convertFile, Document, DocumentTitle, Author, Footnote, ImageReference, RevisionInfo, Logger, AbstractNode, AbstractBlock, Inline, Block, List, ListItem, Section, Reader, SyntaxHighlighterBase, LoggerManager, MemoryLogger, NullLogger, HttpCache, MemoryHttpCache, HttpCacheManager, SafeMode, ContentModel, Timings, Registry, Processor, ProcessorExtension, Preprocessor, TreeProcessor, Postprocessor, IncludeProcessor, DocinfoProcessor, BlockProcessor, InlineMacroProcessor, BlockMacroProcessor, Extensions, Cursor, Converter as ConverterFactory, ConverterBase, CustomFactory as ConverterCustomFactory, DefaultConverterFactory, deriveBackendTraits, DefaultSyntaxHighlighterFactory, Html5Converter, SyntaxHighlighter };

package/types/index.d.ts

@@ -26,14 +26,14 @@ export function load(input: string | string[] | Buffer, options?: any): Promise<
  * @returns {Promise<Document>} - the parsed Document
  */
 export function loadFile(filename: string, options?: any): Promise<Document>;
-export type ProcessorDslInterface = import("./extensions.js").ProcessorDslInterface;
-export type DocumentProcessorDslInterface = import("./extensions.js").DocumentProcessorDslInterface;
-export type SyntaxProcessorDslInterface = import("./extensions.js").SyntaxProcessorDslInterface;
-export type IncludeProcessorDslInterface = import("./extensions.js").IncludeProcessorDslInterface;
-export type DocinfoProcessorDslInterface = import("./extensions.js").DocinfoProcessorDslInterface;
-export type BlockProcessorDslInterface = import("./extensions.js").BlockProcessorDslInterface;
-export type MacroProcessorDslInterface = import("./extensions.js").MacroProcessorDslInterface;
-export type InlineMacroProcessorDslInterface = import("./extensions.js").InlineMacroProcessorDslInterface;
+export type { ProcessorDslInterface } from './extensions.js';
+export type { DocumentProcessorDslInterface } from './extensions.js';
+export type { SyntaxProcessorDslInterface } from './extensions.js';
+export type { IncludeProcessorDslInterface } from './extensions.js';
+export type { DocinfoProcessorDslInterface } from './extensions.js';
+export type { BlockProcessorDslInterface } from './extensions.js';
+export type { MacroProcessorDslInterface } from './extensions.js';
+export type { InlineMacroProcessorDslInterface } from './extensions.js';
 import { Document } from './document.js';
 import { convert } from './convert.js';
 import { convertFile } from './convert.js';
@@ -55,6 +55,9 @@ import { SyntaxHighlighterBase } from './syntax_highlighter.js';
 import { LoggerManager } from './logging.js';
 import { MemoryLogger } from './logging.js';
 import { NullLogger } from './logging.js';
+import { HttpCache } from './http_cache.js';
+import { MemoryHttpCache } from './http_cache.js';
+import { HttpCacheManager } from './http_cache.js';
 import { SafeMode } from './constants.js';
 import { ContentModel } from './constants.js';
 import { Timings } from './timings.js';
@@ -79,4 +82,4 @@ import { deriveBackendTraits } from './converter.js';
 import { DefaultFactory as DefaultSyntaxHighlighterFactory } from './syntax_highlighter.js';
 import Html5Converter from './converter/html5.js';
 import { SyntaxHighlighter } from './syntax_highlighter.js';
-export { convert, convertFile, Document, DocumentTitle, Author, Footnote, ImageReference, RevisionInfo, Logger, AbstractNode, AbstractBlock, Inline, Block, List, ListItem, Section, Reader, SyntaxHighlighterBase, LoggerManager, MemoryLogger, NullLogger, SafeMode, ContentModel, Timings, Registry, Processor, ProcessorExtension, Preprocessor, TreeProcessor, Postprocessor, IncludeProcessor, DocinfoProcessor, BlockProcessor, InlineMacroProcessor, BlockMacroProcessor, Extensions, Cursor, Converter as ConverterFactory, ConverterBase, CustomFactory as ConverterCustomFactory, DefaultConverterFactory, deriveBackendTraits, DefaultSyntaxHighlighterFactory, Html5Converter, SyntaxHighlighter };
+export { convert, convertFile, Document, DocumentTitle, Author, Footnote, ImageReference, RevisionInfo, Logger, AbstractNode, AbstractBlock, Inline, Block, List, ListItem, Section, Reader, SyntaxHighlighterBase, LoggerManager, MemoryLogger, NullLogger, HttpCache, MemoryHttpCache, HttpCacheManager, SafeMode, ContentModel, Timings, Registry, Processor, ProcessorExtension, Preprocessor, TreeProcessor, Postprocessor, IncludeProcessor, DocinfoProcessor, BlockProcessor, InlineMacroProcessor, BlockMacroProcessor, Extensions, Cursor, Converter as ConverterFactory, ConverterBase, CustomFactory as ConverterCustomFactory, DefaultConverterFactory, deriveBackendTraits, DefaultSyntaxHighlighterFactory, Html5Converter, SyntaxHighlighter };

package/types/path_resolver.d.ts

@@ -54,11 +54,6 @@ export class PathResolver {
      * @returns {string} The posixified path.
      */
     posixify(path: string): string;
-    /**
-     * @param {string} path
-     * @returns {string}
-     */
-    posixfy(path: string): string;
     /**
      * Expand the path by resolving parent references (..) and removing self references (.).
      * @param {string} path

package/types/stylesheets.d.ts

@@ -6,5 +6,6 @@ declare class StylesheetsClass {
     get primaryStylesheetName(): string;
     primaryStylesheetData(): Promise<string>;
     embedPrimaryStylesheet(): Promise<string>;
+    writePrimaryStylesheet(stylesoutdir: any): Promise<boolean>;
 }
 export {};

package/types/table.d.ts

@@ -113,7 +113,7 @@ declare class Cell extends AbstractBlock<string | string[]> {
         imageUri(targetImage: string, assetDirKey?: string): Promise<string>;
         mediaUri(target: string, assetDirKey?: string): string;
         generateDataUri(targetImage: string, assetDirKey?: string | null): Promise<string>;
-        generateDataUriFromUri(imageUri: string, cacheUri?: boolean): Promise<string>;
+        generateDataUriFromUri(imageUri: string): Promise<string>;
         normalizeAssetPath(assetRef: string, assetName?: string, autocorrect?: boolean): string;
         normalizeSystemPath(target: string, start?: string | null, jail?: string | null, opts?: any): string;
         normalizeWebPath(target: string, start?: string | null, preserveUriTarget?: boolean): string;