markdown-magic 4.8.0 → 4.10.0

package/src/index.js

@@ -344,22 +344,24 @@ async function markdownMagic(globOrOpts = {}, options = {}) {
       name: file,
       id: file,
       srcPath: file,
-      blocks: foundBlocks.blocks
+      blocks: foundBlocks.blocks,
+      parsedBlocks: foundBlocks
     }
   })
 
   const blocks = blocksByPath.map((item) => {
     const dir = path.dirname(item.srcPath)
-    item.dependencies = []
+    const dependencySet = new Set()
     item.blocks.forEach((block) => {
       if (block.options && block.options.src) {
         const resolvedPath = path.resolve(dir, block.options.src)
         // if (resolvedPath.match(/\.md$/)) {
           // console.log('resolvedPath', resolvedPath)
-          item.dependencies = item.dependencies.concat(resolvedPath)
+          dependencySet.add(resolvedPath)
         //}
       }
     })
+    item.dependencies = Array.from(dependencySet)
     return item
   })
 
@@ -381,23 +383,23 @@ async function markdownMagic(globOrOpts = {}, options = {}) {
   /** */
 
   // Convert items into a format suitable for toposort
-  const graph = blocks
-    .filter((item) => item.blocks && item.blocks.length)
-    .map((item) => {
-      return [ item.id, ...item.dependencies ]
-    })
+  const { itemsWithBlocks, itemIds, graph } = createDependencyGraph(blocks)
   // console.log('graph', graph)
   // Perform the topological sort and reverse for execution order
-  const sortedIds = toposort(graph).reverse();
+  const sortedIds = graph.length ? toposort.array(itemIds, graph).reverse() : itemIds
 
   // Reorder items based on sorted ids
-  const sortedItems = sortedIds.map(id => blocks.find(item => item.id === id)).filter(Boolean);
+  const itemById = new Map(itemsWithBlocks.map((item) => [item.id, item]))
+  const sortedItems = sortedIds.map((id) => itemById.get(id)).filter(Boolean)
 
   // topoSort(blocks)
   const orderedFiles = sortedItems.map((block) => block.id)
   // console.log('sortedItems', sortedItems)
   // console.log('orderedFiles', orderedFiles)
 
+  const fileContentByPath = new Map(files.map((file, i) => [file, fileContents[i]]))
+  const parsedBlocksByPath = new Map(blocksByPath.map((item) => [item.id, item.parsedBlocks]))
+
   const processedFiles = []
   await asyncForEach(orderedFiles, async (file) => {
     // logger('file', file)
@@ -424,6 +426,8 @@ async function markdownMagic(globOrOpts = {}, options = {}) {
     // logger('newPath', newPath)
     const result = await processFile({
       ...opts,
+      content: fileContentByPath.get(file),
+      parsedBlocks: parsedBlocksByPath.get(file),
       patterns,
       open,
       close,
@@ -787,6 +791,29 @@ function changedFiles(files) {
   return files.filter(({ isChanged }) => isChanged)
 }
 
+/**
+ * Create graph data for deterministic dependency ordering
+ * @param {Array<{id: string, blocks: Array<any>, dependencies?: Array<string>}>} blockItems
+ * @returns {{itemsWithBlocks: Array<any>, itemIds: Array<string>, graph: Array<[string, string]>}}
+ */
+function createDependencyGraph(blockItems = []) {
+  const itemsWithBlocks = blockItems.filter((item) => item.blocks && item.blocks.length)
+  const itemIds = itemsWithBlocks.map((item) => item.id)
+  const itemIdSet = new Set(itemIds)
+  const graph = itemsWithBlocks
+    .flatMap((item) => {
+      return (item.dependencies || [])
+        .filter((dependency) => itemIdSet.has(dependency))
+        .map((dependency) => [item.id, dependency])
+    })
+
+  return {
+    itemsWithBlocks,
+    itemIds,
+    graph
+  }
+}
+
 async function asyncForEach(array, callback) {
   for (let index = 0; index < array.length; index++) {
     await callback(array[index], index, array)
@@ -802,5 +829,8 @@ module.exports = {
   parseMarkdown,
   blockTransformer,
   processFile,
-  stringUtils
+  stringUtils,
+  __private: {
+    createDependencyGraph
+  }
 }

package/src/transforms/code/index.js

@@ -158,23 +158,29 @@ module.exports = async function CODE(api) {
 
   /* Check for Id */
   if (id) {
-    const lines = code.split("\n")
-    const startLineIndex = lines.findIndex(line => line.includes(`CODE_SECTION:${id}:START`));
-    const startLine = startLineIndex !== -1 ? startLineIndex : 0;
+    const lines = code.split('\n')
+    const startLineIndex = lines.findIndex((line) => line.includes(`CODE_SECTION:${id}:START`))
+    const endLineIndex = lines.findIndex((line) => line.includes(`CODE_SECTION:${id}:END`))
+
+    if (startLineIndex === -1 || endLineIndex === -1) {
+      throw new Error(`Missing ${id} code section from ${codeFilePath}`)
+    }
+
+    if (endLineIndex <= startLineIndex) {
+      throw new Error(`Invalid ${id} code section in ${codeFilePath}. End marker must be after start marker`)
+    }
 
-    const endLineIndex = lines.findIndex(line => line.includes(`CODE_SECTION:${id}:END`));
-    const endLine = endLineIndex !== -1 ? endLineIndex : lines.length - 1;
     // console.log('startLine', startLine)
     // console.log('endLine', endLine)
-    if (startLine === -1 && endLine === -1) {
-      throw new Error(`Missing ${id} code section from ${codeFilePath}`)
+    const selectedLines = lines.slice(startLineIndex + 1, endLineIndex)
+
+    if (!selectedLines.length) {
+      throw new Error(`Empty ${id} code section in ${codeFilePath}`)
     }
-  
-    const selectedLines = lines.slice(startLine + 1, endLine)
-  
-    const firstMatch = selectedLines[0] && selectedLines[0].match(/^(\s*)/);
-    const trimBy = firstMatch && firstMatch[1] ? firstMatch[1].length : 0;
-    const newValue = `${selectedLines.map(line => line.substring(trimBy).replace(/^\/\/ CODE_SECTION:INCLUDE /g, "")).join("\n")}`
+
+    const firstMatch = selectedLines[0] && selectedLines[0].match(/^(\s*)/)
+    const trimBy = firstMatch && firstMatch[1] ? firstMatch[1].length : 0
+    const newValue = `${selectedLines.map((line) => line.substring(trimBy).replace(/^\/\/ CODE_SECTION:INCLUDE /g, '')).join('\n')}`
     // console.log('newValue', newValue)
     code = newValue
   }

package/src/transforms/index.js

@@ -74,6 +74,11 @@ const transforms = {
    *
    * **Options:**
    * - `src`: The relative path to the file to pull in
+   * - `sections`: Comma-separated list or array of markdown section headings to include
+   * - `section`: Single markdown section heading to include
+   * - `headings`: Array of markdown heading levels to include, such as `headings={[2,3]}`
+   * - `removeLeadingH1`: Remove the first H1 from imported markdown
+   * - `shiftHeaders`: Shift imported markdown headings up or down by a number
    *
    * **Example:**
    * ```md
@@ -97,6 +102,12 @@ const transforms = {
    *
    * **Options:**
    * - `url`: The URL of the remote content to pull in
+   * - `src`: Alias for `url`
+   * - `sections`: Comma-separated list or array of markdown section headings to include
+   * - `section`: Single markdown section heading to include
+   * - `headings`: Array of markdown heading levels to include, such as `headings={[2,3]}`
+   * - `removeLeadingH1`: Remove the first H1 from imported markdown
+   * - `shiftHeaders`: Shift imported markdown headings up or down by a number
    *
    * **Example:**
    * ```md
@@ -208,4 +219,4 @@ const transforms = {
   install: install,
 }
 
-module.exports = transforms
+module.exports = transforms

package/src/utils/format-md.js

@@ -3,6 +3,17 @@ const { removeLeadingH1 } = require('@davidwells/md-utils/string-utils')
 
 function formatMd(content, options = {}) {
   let fileContents = content
+
+  /* automatically trim frontmatter if file is markdown */
+  if (options.trimFrontmatter !== false) {
+    const frontmatter = findFrontmatter(fileContents)
+    if (frontmatter && frontmatter.frontMatterRaw) {
+      fileContents = fileContents.replace(frontmatter.frontMatterRaw, '')
+    }
+  }
+
+  fileContents = selectMarkdownSections(fileContents, options)
+
   if (options.removeLeadingH1 || options.stripFirstH1) {
     fileContents = removeLeadingH1(fileContents)
   }
@@ -10,24 +21,166 @@ function formatMd(content, options = {}) {
   // Shift headers up or down by the specified number of levels if shiftHeaders is enabled and file is markdown
   if (options.shiftHeaders) {
     fileContents = fileContents.replace(/^(#{1,6})\s/gm, (match, hashes) => {
-      const currentLevel = hashes.length;
-      const shiftAmount = Number(options.shiftHeaders);
-      const newLevel = Math.max(1, Math.min(6, currentLevel + shiftAmount));
-      return '#'.repeat(newLevel) + ' ';
+      const currentLevel = hashes.length
+      const shiftAmount = Number(options.shiftHeaders)
+      const newLevel = Math.max(1, Math.min(6, currentLevel + shiftAmount))
+      return '#'.repeat(newLevel) + ' '
     })
   }
 
-  /* automatically trim frontmatter if file is markdown */
-  if (options.trimFrontmatter !== false) {
-    const frontmatter = findFrontmatter(fileContents)
-    if (frontmatter && frontmatter.frontMatterRaw) {
-      fileContents = fileContents.replace(frontmatter.frontMatterRaw, '')
+  return fileContents
+}
+
+function selectMarkdownSections(content, options = {}) {
+  const requestedSections = [
+    ...coerceListOption(options.section),
+    ...coerceListOption(options.sections)
+  ]
+  const requestedHeadings = [
+    ...coerceHeadingLevels(options.heading),
+    ...coerceHeadingLevels(options.headings)
+  ]
+
+  if (!requestedSections.length && !requestedHeadings.length) {
+    return content
+  }
+
+  const headings = parseMarkdownHeadings(content)
+  const sectionNames = requestedSections.map(normalizeHeadingText)
+  const ranges = []
+  const missingSections = new Set(sectionNames)
+
+  headings.forEach((heading) => {
+    if (sectionNames.includes(heading.normalizedText)) {
+      ranges.push({ start: heading.start, end: heading.end })
+      missingSections.delete(heading.normalizedText)
+    }
+
+    if (requestedHeadings.includes(heading.level)) {
+      ranges.push({ start: heading.start, end: heading.end })
     }
+  })
+
+  if (missingSections.size && !options.allowMissingSections) {
+    const missing = Array.from(missingSections).join(', ')
+    throw new Error(`Missing markdown section${missingSections.size > 1 ? 's' : ''}: ${missing}`)
   }
 
-  return fileContents
+  const mergedRanges = mergeRanges(ranges)
+  if (!mergedRanges.length) {
+    return ''
+  }
+
+  return mergedRanges.map((range) => content.slice(range.start, range.end).trim()).join('\n\n')
+}
+
+function parseMarkdownHeadings(content) {
+  const headings = []
+  const lineRegex = /.*(?:\r\n|\n|\r|$)/g
+  let match
+  let offset = 0
+  let fenceMarker = null
+
+  while ((match = lineRegex.exec(content)) !== null) {
+    const line = match[0]
+    if (!line) break
+
+    const lineText = line.replace(/\r?\n$|\r$/, '')
+    const fenceMatch = lineText.match(/^ {0,3}(`{3,}|~{3,})/)
+    if (fenceMarker) {
+      if (fenceMatch && fenceMatch[1][0] === fenceMarker[0] && fenceMatch[1].length >= fenceMarker.length) {
+        fenceMarker = null
+      }
+      offset += line.length
+      continue
+    }
+
+    if (fenceMatch) {
+      fenceMarker = fenceMatch[1]
+      offset += line.length
+      continue
+    }
+
+    const headingMatch = lineText.match(/^ {0,3}(#{1,6})(?:[ \t]+|$)(.*)$/)
+    if (headingMatch) {
+      const text = cleanHeadingText(headingMatch[2])
+      headings.push({
+        level: headingMatch[1].length,
+        text,
+        normalizedText: normalizeHeadingText(text),
+        start: offset,
+        end: content.length
+      })
+    }
+
+    offset += line.length
+  }
+
+  headings.forEach((heading, index) => {
+    const nextHeading = headings.slice(index + 1).find((candidate) => candidate.level <= heading.level)
+    heading.end = nextHeading ? nextHeading.start : content.length
+  })
+
+  return headings
+}
+
+function cleanHeadingText(text = '') {
+  return stripSimpleMarkdownLinks(text.replace(/[ \t]+#+[ \t]*$/, '').trim())
+}
+
+function normalizeHeadingText(text = '') {
+  return cleanHeadingText(String(text))
+    .replace(/[`*_~]/g, '')
+    .replace(/\s+/g, ' ')
+    .trim()
+    .toLowerCase()
+}
+
+function stripSimpleMarkdownLinks(text = '') {
+  return text.replace(/\[([^\]]+)\]\([^)]+\)/g, '$1')
+}
+
+function coerceListOption(value) {
+  if (typeof value === 'undefined' || value === null || value === false) {
+    return []
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => String(item).trim()).filter(Boolean)
+  }
+  return String(value)
+    .replace(/^\[|\]$/g, '')
+    .split(',')
+    .map((item) => item.trim())
+    .filter(Boolean)
+}
+
+function coerceHeadingLevels(value) {
+  return coerceListOption(value)
+    .map((item) => Number(item))
+    .filter((item) => Number.isInteger(item) && item >= 1 && item <= 6)
+}
+
+function mergeRanges(ranges) {
+  return ranges
+    .filter((range) => range && Number.isInteger(range.start) && Number.isInteger(range.end) && range.end > range.start)
+    .sort((a, b) => a.start - b.start || b.end - a.end)
+    .reduce((merged, range) => {
+      const previous = merged[merged.length - 1]
+      if (previous && range.start <= previous.end) {
+        previous.end = Math.max(previous.end, range.end)
+        return merged
+      }
+      merged.push({ start: range.start, end: range.end })
+      return merged
+    }, [])
 }
 
 module.exports = {
-  formatMd
-}
+  formatMd,
+  parseMarkdownHeadings,
+  selectMarkdownSections,
+  normalizeHeadingText,
+  coerceListOption,
+  coerceHeadingLevels,
+  mergeRanges
+}

package/src/utils/format-md.test.js

@@ -0,0 +1,175 @@
+const { test } = require('uvu')
+const assert = require('uvu/assert')
+const {
+  formatMd,
+  parseMarkdownHeadings,
+  normalizeHeadingText
+} = require('./format-md')
+
+const SAMPLE = `---
+title: Example
+---
+# Package Name
+
+Intro text.
+
+## Installation
+
+Install the package.
+
+### Browser
+
+Browser install notes.
+
+## Usage
+
+Use the package.
+
+### Node
+
+Node usage notes.
+
+## API ##
+
+API docs.
+
+\`\`\`md
+## Ignored Code Heading
+\`\`\`
+
+## [Contributing](#contributing)
+
+Contribution notes.
+`
+
+test('parseMarkdownHeadings finds ATX headings and ignores fenced code headings', () => {
+  const headings = parseMarkdownHeadings(SAMPLE)
+  assert.equal(
+    headings.map((heading) => heading.text),
+    ['Package Name', 'Installation', 'Browser', 'Usage', 'Node', 'API', 'Contributing']
+  )
+})
+
+test('normalizeHeadingText normalizes case, whitespace, closing hashes, and markdown links', () => {
+  assert.is(normalizeHeadingText(' Installation ## '), 'installation')
+  assert.is(normalizeHeadingText('[Contributing](#contributing)'), 'contributing')
+  assert.is(normalizeHeadingText('Quick   Start'), 'quick start')
+})
+
+test('formatMd sections selects named sections with nested child headings', () => {
+  const result = formatMd(SAMPLE, {
+    sections: 'Installation'
+  })
+
+  assert.ok(result.includes('## Installation'), 'includes requested section heading')
+  assert.ok(result.includes('### Browser'), 'includes nested child heading')
+  assert.not.ok(result.includes('## Usage'), 'excludes sibling section')
+  assert.not.ok(result.includes('Ignored Code Heading'), 'excludes unrelated fenced code heading')
+})
+
+test('formatMd sections accepts arrays and preserves source order', () => {
+  const result = formatMd(SAMPLE, {
+    sections: ['API', 'Installation']
+  })
+
+  assert.ok(result.indexOf('## Installation') < result.indexOf('## API'), 'uses source order')
+  assert.ok(result.includes('Install the package.'), 'includes first matched section')
+  assert.ok(result.includes('API docs.'), 'includes second matched section')
+  assert.not.ok(result.includes('## Usage'), 'excludes unselected middle section')
+})
+
+test('formatMd section shorthand works', () => {
+  const result = formatMd(SAMPLE, {
+    section: 'Usage'
+  })
+
+  assert.ok(result.includes('## Usage'), 'includes shorthand section')
+  assert.ok(result.includes('### Node'), 'includes shorthand section children')
+  assert.not.ok(result.includes('## Installation'), 'excludes previous sibling')
+})
+
+test('formatMd combines section and sections options', () => {
+  const result = formatMd(SAMPLE, {
+    section: 'Installation',
+    sections: 'API'
+  })
+
+  assert.ok(result.includes('## Installation'), 'includes section shorthand')
+  assert.ok(result.includes('## API'), 'includes sections option')
+  assert.not.ok(result.includes('## Usage'), 'excludes unselected section')
+})
+
+test('formatMd headings selects sections by heading level', () => {
+  const result = formatMd(SAMPLE, {
+    headings: [3]
+  })
+
+  assert.ok(result.includes('### Browser'), 'includes first h3 section')
+  assert.ok(result.includes('### Node'), 'includes second h3 section')
+  assert.not.ok(result.includes('## Installation'), 'excludes h2 parent')
+  assert.not.ok(result.includes('## API'), 'excludes h2 sibling')
+})
+
+test('formatMd headings accepts bracketed string values', () => {
+  const result = formatMd(SAMPLE, {
+    headings: '[3]'
+  })
+
+  assert.ok(result.includes('### Browser'), 'includes h3 from bracketed string')
+  assert.not.ok(result.includes('## Installation'), 'excludes h2 parent')
+})
+
+test('formatMd headings suppresses duplicate nested ranges', () => {
+  const result = formatMd(SAMPLE, {
+    headings: [2, 3]
+  })
+
+  assert.is(result.match(/### Browser/g).length, 1)
+  assert.is(result.match(/### Node/g).length, 1)
+  assert.ok(result.includes('## Installation'), 'includes h2 section')
+  assert.ok(result.includes('## Usage'), 'includes h2 sibling')
+})
+
+test('formatMd combines sections and headings as a deduped union', () => {
+  const result = formatMd(SAMPLE, {
+    sections: 'Usage',
+    headings: [3]
+  })
+
+  assert.ok(result.includes('### Browser'), 'includes h3 selected by level')
+  assert.ok(result.includes('## Usage'), 'includes named section')
+  assert.is(result.match(/### Node/g).length, 1)
+  assert.not.ok(result.includes('## API'), 'excludes unselected h2')
+})
+
+test('formatMd extracts before removeLeadingH1 and shiftHeaders', () => {
+  const result = formatMd(SAMPLE, {
+    sections: 'Installation',
+    removeLeadingH1: true,
+    shiftHeaders: 1
+  })
+
+  assert.ok(result.includes('### Installation'), 'shifts selected h2 after extraction')
+  assert.ok(result.includes('#### Browser'), 'shifts nested h3 after extraction')
+  assert.not.ok(result.includes('# Package Name'), 'does not include original leading h1')
+})
+
+test('formatMd throws when requested section is missing by default', () => {
+  assert.throws(() => {
+    formatMd(SAMPLE, {
+      sections: 'Missing'
+    })
+  }, /Missing markdown section: missing/)
+})
+
+test('formatMd can ignore missing requested sections', () => {
+  const result = formatMd(SAMPLE, {
+    sections: 'Missing,Usage',
+    allowMissingSections: true
+  })
+
+  assert.ok(result.includes('## Usage'), 'includes found section')
+  assert.not.ok(result.includes('## Installation'), 'excludes unrequested section')
+})
+
+test.run()

package/src/utils/remoteRequest.js

@@ -1,28 +1,52 @@
 const fetch = require('node-fetch')
 
 function formatUrl(url = '') {
-  return url.match(/^https?:\/\//) ? url : `https://${url}`
+  if (typeof url !== 'string') return ''
+  const trimmed = url.trim()
+  if (!trimmed) return ''
+  return trimmed.match(/^https?:\/\//) ? trimmed : `https://${trimmed}`
 }
 
 async function remoteRequest(url, settings = {}, srcPath) {
-  let body
   const finalUrl = formatUrl(url)
+  const fixText = srcPath ? `\nFix "${url}" value in ${srcPath}` : ''
+  if (!finalUrl) {
+    const msg = `Invalid URL "${url}"${fixText}`
+    if (settings.failOnMissingRemote) {
+      throw new Error(msg)
+    }
+    console.log(msg)
+    return
+  }
+
   // ignore demo url todo remove one day
   if (finalUrl === 'http://url-to-raw-md-file.md') {
     return
   }
+
+  let response
   try {
-    const res = await fetch(finalUrl)
-    body = await res.text()
+    response = await fetch(finalUrl)
   } catch (e) {
     console.log(`⚠️  WARNING: REMOTE URL "${finalUrl}" NOT FOUND`)
-    const msg = (e.message || '').split('\n')[0] + `\nFix "${url}" value in ${srcPath}`
+    const msg = (e.message || '').split('\n')[0] + fixText
     console.log(msg)
     if (settings.failOnMissingRemote) {
       throw new Error(msg)
     }
+    return
+  }
+
+  if (!response.ok) {
+    const msg = `Remote request failed with status ${response.status} (${response.statusText}) for "${finalUrl}"${fixText}`
+    console.log(`⚠️  WARNING: ${msg}`)
+    if (settings.failOnMissingRemote) {
+      throw new Error(msg)
+    }
+    return
   }
-  return body
+
+  return response.text()
 }
 
 module.exports = {

package/types/src/argparse/argparse.d.ts

@@ -1,33 +1,3 @@
-export function uxParse(_rawArgv?: any[], opts?: {}): {
-    leadingCommands: string[];
-    extraParse: {};
-    mriOptionsOriginal: mri.Argv<{
-        [x: string]: any;
-    }>;
-    globGroups: any[];
-    rawArgv?: undefined;
-    mriOptionsClean?: undefined;
-    mriDiff?: undefined;
-    yargsParsed?: undefined;
-    mergedOptions?: undefined;
-} | {
-    rawArgv: string;
-    leadingCommands: string[];
-    globGroups: any[];
-    extraParse: {};
-    mriOptionsOriginal: mri.Argv<{
-        [x: string]: any;
-    }>;
-    mriOptionsClean: {
-        [x: string]: any;
-    } & {
-        _: string[];
-    };
-    mriDiff: boolean;
-    yargsParsed: string;
-    mergedOptions: {
-        _: string[];
-    };
-};
-import mri = require("mri");
+export { dxParse };
+import { dxParse } from "@davidwells/dx-args";
 //# sourceMappingURL=argparse.d.ts.map

package/types/src/argparse/argparse.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"argparse.d.ts","sourceRoot":"","sources":["../../../src/argparse/argparse.js"],"names":[],"mappings":"AAoCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2QC"}
+{"version":3,"file":"argparse.d.ts","sourceRoot":"","sources":["../../../src/argparse/argparse.js"],"names":[],"mappings":""}

package/types/src/argparse/index.d.ts

@@ -1,3 +1,3 @@
-export { uxParse };
-import { uxParse } from "./argparse";
+export { dxParse };
+import { dxParse } from "./argparse";
 //# sourceMappingURL=index.d.ts.map

package/types/src/argparse/splitOutsideQuotes.d.ts

@@ -1,2 +1,3 @@
-export function splitOutsideQuotes(str: any): any[];
+export { splitOutsideQuotes };
+import { splitOutsideQuotes } from "@davidwells/dx-args";
 //# sourceMappingURL=splitOutsideQuotes.d.ts.map

package/types/src/argparse/splitOutsideQuotes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"splitOutsideQuotes.d.ts","sourceRoot":"","sources":["../../../src/argparse/splitOutsideQuotes.js"],"names":[],"mappings":"AAEA,oDAuEC"}
+{"version":3,"file":"splitOutsideQuotes.d.ts","sourceRoot":"","sources":["../../../src/argparse/splitOutsideQuotes.js"],"names":[],"mappings":""}

package/types/src/cli-run.d.ts

@@ -1,4 +1,6 @@
-import { getGlobGroupsFromArgs } from "./globparse";
-export function runCli(options: {}, rawArgv: any): Promise<import("./").MarkdownMagicResult>;
+import { getGlobGroupsFromArgs } from "@davidwells/dx-args/src/globparse";
+export function parseCliArgv(rawArgv?: any[]): any;
+export function normalizeCliOptions(parsed: any): any;
+export function runCli(options: {}, rawArgv: any, deps?: {}): Promise<any>;
 export { getGlobGroupsFromArgs };
 //# sourceMappingURL=cli-run.d.ts.map