markdown-magic 4.8.0 → 4.9.0

package/src/argparse/argparse.test.js

@@ -2,9 +2,9 @@
 const { test } = require('uvu')
 const assert = require('uvu/assert')
 const { deepLog } = require('../utils/logs')
-const { uxParse } = require('./argparse')
+const { dxParse } = require('./argparse')
 
-const DEBUG = true
+const DEBUG = (process.argv.includes('--debug')) ? true : false
 const logger = DEBUG ? console.log : () => {}
 const deepLogger = DEBUG ? deepLog : () => {}
 
@@ -13,7 +13,7 @@ function logInput(rawArgs, result) {
   logger('Input:')
   logger(`CLI ${rawArgs.join(' ')}`)
   if (result) {
-    deepLog('result', result)
+    deepLogger('result', result)
   }
   logger('───────────────────────\n')
 }
@@ -23,47 +23,47 @@ function stringToArgs(str) {
 }
 
 test('Exports API', () => {
-  assert.equal(typeof uxParse, 'function', 'undefined val')
+  assert.equal(typeof dxParse, 'function', 'undefined val')
 })
 
 const cmd00 = stringToArgs('lol = true cool = false')
-test.only(`CLI ${cmd00.join(' ')}`, () => {
-  const result = uxParse(cmd00)
+test(`CLI ${cmd00.join(' ')}`, () => {
+  const result = dxParse(cmd00)
   logInput(cmd00, result)
   assert.equal(result.mergedOptions, { lol: true, cool: false })
 })
 
 const cmd000 = stringToArgs('--lol true --cool false')
 test(`CLI ${cmd000.join(' ')}`, () => {
-  const result = uxParse(cmd000)
+  const result = dxParse(cmd000)
   logInput(cmd000, result)
   assert.equal(result.mergedOptions, { lol: true, cool: false })
 })
 
 const cmd0000 = stringToArgs('-lol true -cool false')
 test(`CLI ${cmd0000.join(' ')}`, () => {
-  const result = uxParse(cmd0000)
+  const result = dxParse(cmd0000)
   logInput(cmd0000, result)
   assert.equal(result.mergedOptions, { lol: true, cool: false })
 })
 
 const cmd00000 = stringToArgs('-lol -cool ')
 test(`CLI ${cmd00000.join(' ')}`, () => {
-  const result = uxParse(cmd00000)
+  const result = dxParse(cmd00000)
   logInput(cmd00000, result)
   assert.equal(result.mergedOptions, { lol: true, cool: true })
 })
 
 const cmd000000 = stringToArgs('--stage prod --cool wild = yolo')
 test(`CLI ${cmd000000.join(' ')}`, () => {
-  const result = uxParse(cmd000000)
+  const result = dxParse(cmd000000)
   logInput(cmd000000, result)
   assert.equal(result.mergedOptions, { stage: 'prod', cool: true, wild: 'yolo' })
 })
 
 const cmd0 = stringToArgs('-f no word = { foo: bar }')
 test(`Handles single dash options, CLI ${cmd0.join(' ')}`, () => {
-  const result = uxParse(cmd0)
+  const result = dxParse(cmd0)
   logInput(cmd0, result)
   assert.equal(result.mergedOptions.f, 'no')
   assert.equal(result.mergedOptions.word, { foo: 'bar' })
@@ -72,23 +72,23 @@ test(`Handles single dash options, CLI ${cmd0.join(' ')}`, () => {
 
 const cmd1 = stringToArgs('-f -x -xyz ballin -u jimmy')
 test(`flags in a row "CLI ${cmd1.join(' ')}"`, () => {
-  const result = uxParse(cmd1)
-  deepLog('result', result)
+  const result = dxParse(cmd1)
+  deepLogger('result', result)
   assert.equal(result.mergedOptions.xyz, 'ballin')
   assert.equal(result.mergedOptions, { f: true, x: true, xyz: 'ballin', u: 'jimmy' })
 })
 
 const cmd2 = stringToArgs('-f -x -xyz ballin = yo -u jimmy')
 test(`flags in a row two "CLI ${cmd2.join(' ')}"`, () => {
-  const result = uxParse(cmd2)
-  deepLog('result', result)
+  const result = dxParse(cmd2)
+  deepLogger('result', result)
   assert.equal(result.mergedOptions.ballin, 'yo')
 })
 
 const cmd3 = stringToArgs('-f -x -xyz ballin = yo -u jimmy=timmy')
 test(`flags in a row two "CLI ${cmd3.join(' ')}"`, () => {
-  const result = uxParse(cmd3)
-  deepLog('result', result)
+  const result = dxParse(cmd3)
+  deepLogger('result', result)
   assert.equal(result.mergedOptions.jimmy, 'timmy')
 })
 
@@ -96,8 +96,8 @@ const cmd4 = stringToArgs(
   'whatever=[uno] -v=false nice -funky no -word { foo: bar } -w yo --what nice -f -x -xyz false -u jimmy --testx --file **.md --u word',
 )
 test(`Handles glob options "CLI ${cmd4.join(' ')}"`, () => {
-  const result = uxParse(cmd4)
-  deepLog('result', result)
+  const result = dxParse(cmd4, { accumulate: ['u'] })
+  deepLogger('result', result)
   assert.equal(result.mergedOptions, {
     whatever: ['uno'],
     v: false,
@@ -115,52 +115,135 @@ test(`Handles glob options "CLI ${cmd4.join(' ')}"`, () => {
   })
 })
 
+const filePatternArgs = stringToArgs('--file **/*.md')
+test(`Groups single --file glob pattern "CLI ${filePatternArgs.join(' ')}"`, () => {
+  const result = dxParse(filePatternArgs)
+  deepLogger('result', result)
+  assert.equal(result.globGroups, [
+    { key: 'file', rawKey: '--file', values: ['**/*.md'] }
+  ])
+  assert.equal(result.mergedOptions.file, '**/*.md')
+})
+
+const filesPatternArgs = stringToArgs('--files README.md docs/**/*.md --stage dev')
+test(`Groups multiple --files patterns and leaves other options "CLI ${filesPatternArgs.join(' ')}"`, () => {
+  const result = dxParse(filesPatternArgs)
+  deepLogger('result', result)
+  assert.equal(result.globGroups, [
+    { key: 'files', rawKey: '--files', values: ['README.md', 'docs/**/*.md'] }
+  ])
+  assert.equal(result.mergedOptions.stage, 'dev')
+})
+
+const bareFilePatternArgs = stringToArgs('README.md docs/**/*.md --stage dev')
+test(`Groups bare positional file patterns "CLI ${bareFilePatternArgs.join(' ')}"`, () => {
+  const result = dxParse(bareFilePatternArgs)
+  deepLogger('result', result)
+  assert.equal(result.globGroups, [
+    { key: '', rawKey: '', values: ['README.md', 'docs/**/*.md'] }
+  ])
+  assert.equal(result.leadingCommands, [])
+  assert.equal(result.mergedOptions.stage, 'dev')
+})
+
+const pathPatternArgs = stringToArgs('--path docs/**/*.md --stage dev')
+test(`Groups --path glob pattern "CLI ${pathPatternArgs.join(' ')}"`, () => {
+  const result = dxParse(pathPatternArgs)
+  deepLogger('result', result)
+  assert.equal(result.globGroups, [
+    { key: 'path', rawKey: '--path', values: ['docs/**/*.md'] }
+  ])
+  assert.equal(result.mergedOptions.stage, 'dev')
+})
+
+const singleDashConfigFileArgs = stringToArgs('-config md.config.js -stage dev')
+test(`Promotes consumed single-dash file-valued options "CLI ${singleDashConfigFileArgs.join(' ')}"`, () => {
+  const result = dxParse(singleDashConfigFileArgs)
+  deepLogger('result', result)
+  assert.equal(result.globGroups, [
+    { key: 'config', rawKey: '-config', values: ['md.config.js'] }
+  ])
+  assert.equal(result.mergedOptions, {
+    config: 'md.config.js',
+    stage: 'dev'
+  })
+})
+
+const shellExpandedFileArgs = [
+  'CONTRIBUTING.md',
+  'NOTES.md',
+  'README.md',
+  'large-table.md',
+  'foo',
+  'bar',
+  '=',
+  'false',
+  'lol={x:100}'
+]
+test(`Does not treat shell-expanded file matches as leading commands`, () => {
+  const result = dxParse(shellExpandedFileArgs)
+  deepLogger('result', result)
+  assert.equal(result.globGroups, [
+    {
+      key: '',
+      rawKey: '',
+      values: ['CONTRIBUTING.md', 'NOTES.md', 'README.md', 'large-table.md']
+    }
+  ])
+  assert.equal(result.leadingCommands, ['foo'])
+  assert.equal(result.mergedOptions, {
+    foo: true,
+    bar: false,
+    lol: { x: 100 }
+  })
+})
+
 const cmd5 = stringToArgs('--stage prod --cool wild=yolo')
 test(`CLI ${cmd5.join(' ')}"`, () => {
-  const result = uxParse(cmd5)
-  deepLog('result', result)
+  const result = dxParse(cmd5)
+  deepLogger('result', result)
   assert.equal(result.mergedOptions, { stage: 'prod', cool: true, wild: 'yolo' })
 })
 
 const cmd6 = stringToArgs('--stage prod --cool wild=yolo --stage dev')
-test.skip(`Takes last value for same flag "CLI ${cmd6.join(' ')}"`, () => {
-  const result = uxParse(cmd6)
-  deepLog('result', result)
+test(`Takes last value for same flag "CLI ${cmd6.join(' ')}"`, () => {
+  const result = dxParse(cmd6)
+  deepLogger('result', result)
   assert.equal(result.mergedOptions, { stage: 'dev', cool: true, wild: 'yolo' })
 })
 
 const cmd7 = stringToArgs('--stage prod --cool wild="yo lo" --stage dev --stage prod')
-test(`Combines duplicate values into a deduplicated array "CLI ${cmd7.join(' ')}"`, () => {
-  const result = uxParse(cmd7)
-  deepLog('result', result)
-  assert.equal(result.mergedOptions, { stage: ['prod', 'dev'], cool: true, wild: 'yo lo' })
+test(`Takes last value for duplicate long flags "CLI ${cmd7.join(' ')}"`, () => {
+  const result = dxParse(cmd7)
+  deepLogger('result', result)
+  assert.equal(result.mergedOptions, { stage: 'prod', cool: true, wild: 'yo lo' })
 })
 
 const cmd8 = stringToArgs('-stage prod -cool wild=yolo -stage dev')
-test(`Combines duplicate values into an array "CLI ${cmd8.join(' ')}"`, () => {
-  const result = uxParse(cmd8)
-  deepLog('result', result)
-  assert.equal(result.mergedOptions, { stage: ['prod', 'dev'], cool: true, wild: 'yolo' })
+test(`Takes last value for duplicate forgiving single-dash long flags "CLI ${cmd8.join(' ')}"`, () => {
+  const result = dxParse(cmd8)
+  deepLogger('result', result)
+  assert.equal(result.mergedOptions, { stage: 'dev', cool: true, wild: 'yolo' })
 })
 
 const cmd9 = stringToArgs('-stage prod -cool wild=-yolo -stage dev -stage prod')
 test(`Handles values with dashes "CLI ${cmd9.join(' ')}"`, () => {
-  const result = uxParse(cmd9)
-  deepLog('result', result)
-  assert.equal(result.mergedOptions, { stage: ['prod', 'dev'], cool: true, wild: '-yolo' })
+  const result = dxParse(cmd9)
+  deepLogger('result', result)
+  assert.equal(result.mergedOptions, { stage: 'prod', cool: true, wild: '-yolo' })
 })
 
 const cmd10 = stringToArgs('-stage prod -cool wild=--yolo -stage dev -stage prod -stage dev')
 test(`Handles values with dashes "CLI ${cmd10.join(' ')}"`, () => {
-  const result = uxParse(cmd10)
-  deepLog('result', result)
-  assert.equal(result.mergedOptions, { stage: ['prod', 'dev'], cool: true, wild: '--yolo' })
+  const result = dxParse(cmd10)
+  deepLogger('result', result)
+  assert.equal(result.mergedOptions, { stage: 'dev', cool: true, wild: '--yolo' })
 })
 
 const cmd11 = stringToArgs('-stage prod -cool wild="--yolo"')
 test(`Handles values with dashes "CLI ${cmd11.join(' ')}"`, () => {
-  const result = uxParse(cmd11)
-  deepLog('result', result)
+  const result = dxParse(cmd11)
+  deepLogger('result', result)
   assert.equal(result.mergedOptions, { stage: 'prod', cool: true, wild: '--yolo' })
 })
 
@@ -170,16 +253,16 @@ const cmd14 = stringToArgs('-stage prod -cool wild="yo=lo"')
 test(`Handles values with equals "CLI ${cmd12.join(' ')}"`, () => {
   const array = [cmd12, cmd13, cmd14]
   for (const cmd of array) {
-    const result = uxParse(cmd)
-    deepLog('result', result)
+    const result = dxParse(cmd)
+    deepLogger('result', result)
     assert.equal(result.mergedOptions, { stage: 'prod', cool: true, wild: 'yo=lo' })
   }
 })
 
 const cmd15 = stringToArgs('--param=userPoolId=us-west-1_fjsPJ6Q8J --param=userPoolClientId=19vdp5je9jsjkn488ddl4jvk19')
-test(`Handles array values "CLI ${cmd15.join(' ')}"`, () => {
-  const result = uxParse(cmd15)
-  deepLog('result', result)
+test(`Accumulates configured array values "CLI ${cmd15.join(' ')}"`, () => {
+  const result = dxParse(cmd15, { accumulate: ['param'] })
+  deepLogger('result', result)
   assert.equal(result.mergedOptions, {
     param: ['userPoolId=us-west-1_fjsPJ6Q8J', 'userPoolClientId=19vdp5je9jsjkn488ddl4jvk19'],
   })
@@ -187,8 +270,8 @@ test(`Handles array values "CLI ${cmd15.join(' ')}"`, () => {
 
 const cmd16 = stringToArgs('--param="userPoolId=us-west-1_fjsPJ6Q8J" --param="userPoolClientId=19vdp5je9jsjkn488ddl4jvk19"')
 test(`Strips surrounding quotes "CLI ${cmd16.join(' ')}"`, () => {
-  const result = uxParse(cmd16)
-  deepLog('result', result)
+  const result = dxParse(cmd16, { accumulate: ['param'] })
+  deepLogger('result', result)
   assert.equal(result.mergedOptions, {
     param: ['userPoolId=us-west-1_fjsPJ6Q8J', 'userPoolClientId=19vdp5je9jsjkn488ddl4jvk19'],
   })
@@ -196,8 +279,8 @@ test(`Strips surrounding quotes "CLI ${cmd16.join(' ')}"`, () => {
 
 const cmd17 = stringToArgs('--env.stage=prod --env.region=us-east-1')
 test(`Handles dotted properties "CLI ${cmd17.join(' ')}"`, () => {
-  const result = uxParse(cmd17)
-  deepLog('result', result)
+  const result = dxParse(cmd17)
+  deepLogger('result', result)
   assert.equal(result.mergedOptions, {
     'env.stage': 'prod',
     'env.region': 'us-east-1'
@@ -206,8 +289,8 @@ test(`Handles dotted properties "CLI ${cmd17.join(' ')}"`, () => {
 
 const cmd18 = stringToArgs('--array=[1,2,3] --items=["a","b","c"]')
 test(`Handles array syntax "CLI ${cmd18.join(' ')}"`, () => {
-  const result = uxParse(cmd18)
-  deepLog('result', result)
+  const result = dxParse(cmd18)
+  deepLogger('result', result)
   assert.equal(result.mergedOptions, {
     array: [1, 2, 3],
     items: ['a', 'b', 'c']
@@ -216,8 +299,8 @@ test(`Handles array syntax "CLI ${cmd18.join(' ')}"`, () => {
 
 const cmd19 = stringToArgs('--config.json={"foo": "bar", "baz": 123}')
 test(`Handles JSON objects "CLI ${cmd19.join(' ')}"`, () => {
-  const result = uxParse(cmd19)
-  deepLog('result', result)
+  const result = dxParse(cmd19)
+  deepLogger('result', result)
   assert.equal(result.mergedOptions, {
     'config.json': { foo: 'bar', baz: 123 }
   })
@@ -225,8 +308,8 @@ test(`Handles JSON objects "CLI ${cmd19.join(' ')}"`, () => {
 
 const cmd20 = stringToArgs('--empty --blank="" --null=null --undef=undefined')
 test(`Handles special values "CLI ${cmd20.join(' ')}"`, () => {
-  const result = uxParse(cmd20)
-  deepLog('result', result)
+  const result = dxParse(cmd20)
+  deepLogger('result', result)
   assert.equal(result.mergedOptions, {
     empty: true,
     blank: '',
@@ -238,20 +321,18 @@ test(`Handles special values "CLI ${cmd20.join(' ')}"`, () => {
 // @TODO invert no prefixes?
 const cmd21 = stringToArgs('--flag --no-flag --enable-feature --no-enable-feature')
 test(`Handles boolean flags with no- prefix "CLI ${cmd21.join(' ')}"`, () => {
-  const result = uxParse(cmd21)
-  deepLog('result', result)
+  const result = dxParse(cmd21)
+  deepLogger('result', result)
   assert.equal(result.mergedOptions, {
-    'no-flag': true,
-    flag: true,
-    'enable-feature': true,
-    'no-enable-feature': true
+    flag: false,
+    'enable-feature': false
   })
 })
 
 const cmd22 = stringToArgs(`--spaced-string="hello world" --quoted='single quotes'`)
 test(`Handles quoted strings with spaces "CLI ${cmd22.join(' ')}"`, () => {
-  const result = uxParse(cmd22)
-  deepLog('result', result)
+  const result = dxParse(cmd22)
+  deepLogger('result', result)
   assert.equal(result.mergedOptions, {
     'spaced-string': 'hello world',
     quoted: 'single quotes'
@@ -261,8 +342,8 @@ test(`Handles quoted strings with spaces "CLI ${cmd22.join(' ')}"`, () => {
 // This one is wrong iirc
 const cmd23 = stringToArgs('--numbers 1 2 3 --strings a b c')
 test.skip(`Handles space-separated values "CLI ${cmd23.join(' ')}"`, () => {
-  const result = uxParse(cmd23)
-  deepLog('result', result)
+  const result = dxParse(cmd23)
+  deepLogger('result', result)
   assert.equal(result.mergedOptions, {
     numbers: ['1', '2', '3'],
     strings: ['a', 'b', 'c']
@@ -270,9 +351,9 @@ test.skip(`Handles space-separated values "CLI ${cmd23.join(' ')}"`, () => {
 })
 
 const cmd24 = stringToArgs(`--key=value --key="other value" --key='third value'`)
-test(`Handles multiple values for same key with different quote styles "CLI ${cmd24.join(' ')}"`, () => {
-  const result = uxParse(cmd24)
-  deepLog('result', result)
+test(`Accumulates configured repeated key with different quote styles "CLI ${cmd24.join(' ')}"`, () => {
+  const result = dxParse(cmd24, { accumulate: ['key'] })
+  deepLogger('result', result)
   assert.equal(result.mergedOptions, {
     key: ['value', 'other value', 'third value']
   })
@@ -280,10 +361,12 @@ test(`Handles multiple values for same key with different quote styles "CLI ${cm
 
 const cmd25 = stringToArgs('-abc -xyz=123 -def="value" -ghi')
 test(`Handles single-letter flags in various formats "CLI ${cmd25.join(' ')}"`, () => {
-  const result = uxParse(cmd25, { 
-    stripSingleDashOptions: true 
+  const result = dxParse(cmd25, {
+    allowShortClusters: true,
+    shortFlags: ['a', 'b', 'c', 'g', 'h', 'i'],
+    stripSingleDashOptions: true
   })
-  deepLog('result', result)
+  deepLogger('result', result)
   assert.equal(result.mergedOptions, {
     a: true,
     b: true,
@@ -297,24 +380,19 @@ test(`Handles single-letter flags in various formats "CLI ${cmd25.join(' ')}"`,
 })
 
 const cmd26 = stringToArgs('--flag=true --flag=false --flag --no-flag')
-test(`Handles multiple boolean assignments "CLI ${cmd26.join(' ')}"`, () => {
-  const result = uxParse(cmd26)
-  deepLog('result', result)
+test(`Takes last value for multiple boolean assignments "CLI ${cmd26.join(' ')}"`, () => {
+  const result = dxParse(cmd26)
+  deepLogger('result', result)
   assert.equal(result.mergedOptions, {
-    flag: [
-      true,
-      false,
-      true,
-    ],
-    'no-flag': true
+    flag: false
   })
 })
 
 
 const cmd27 = stringToArgs('-l -a -h')
 test(`Short flags "CLI ${cmd27.join(' ')}"`, () => {
-  const result = uxParse(cmd27)
-  deepLog('result', result)
+  const result = dxParse(cmd27)
+  deepLogger('result', result)
   assert.equal(result.mergedOptions, {
     l: true,
     a: true,
@@ -324,8 +402,8 @@ test(`Short flags "CLI ${cmd27.join(' ')}"`, () => {
 
 const cmd28 = stringToArgs('-lah = yo')
 test(`flag clustering "CLI ${cmd28.join(' ')}"`, () => {
-  const result = uxParse(cmd28, true)
-  deepLog('result', result)
+  const result = dxParse(cmd28, true)
+  deepLogger('result', result)
   assert.equal(result.mergedOptions, {
     l: true,
     a: true,
@@ -336,8 +414,8 @@ test(`flag clustering "CLI ${cmd28.join(' ')}"`, () => {
 
 const cmd29 = stringToArgs('test.js --foo 1337 -B hello --mcgee')
 test(`Short flags "CLI ${cmd29.join(' ')}"`, () => {
-  const result = uxParse(cmd29)
-  deepLog('result', result)
+  const result = dxParse(cmd29)
+  deepLogger('result', result)
   assert.equal(result.mergedOptions, {
     foo: 1337,
     B: 'hello',
@@ -348,8 +426,8 @@ test(`Short flags "CLI ${cmd29.join(' ')}"`, () => {
 
 const cmd30 = stringToArgs('hey --foo=hi.hello?q=p hello')
 test(`basic string parsing (equals long-arg-with-equals) "CLI ${cmd30.join(' ')}"`, () => {
-  const result = uxParse(cmd30)
-  deepLog('result', result)
+  const result = dxParse(cmd30)
+  deepLogger('result', result)
   assert.equal(result.mergedOptions, {
     // possibleLeadingCommands: ['hey'],
     hey: true, // @TODO fix this do we want it?
@@ -360,8 +438,8 @@ test(`basic string parsing (equals long-arg-with-equals) "CLI ${cmd30.join(' ')}
 
 const cmd31 = stringToArgs('int=-5')
 test(`basic int parsing "CLI ${cmd31.join(' ')}"`, () => {
-  const result = uxParse(cmd31)
-  deepLog('result', result)
+  const result = dxParse(cmd31)
+  deepLogger('result', result)
   assert.equal(result.mergedOptions, {
     int: -5
   })

package/src/argparse/index.js

@@ -1,5 +1,5 @@
-const { uxParse } = require('./argparse')
+const { dxParse } = require('./argparse')
 
 module.exports = {
-  uxParse
+  dxParse,
 }

package/src/argparse/splitOutsideQuotes.js

@@ -1,78 +1,6 @@
 
+const { splitOutsideQuotes } = require('@davidwells/dx-args')
 
-function splitOutsideQuotes(str) {
-
-  str = str
-    .replace(/}(?=(?:(?:[^"]*(?:")){2})*[^"]*(?:")[^"]*$)/g, '∆')  // For } in double " quotes
-    .replace(/}(?=(?:(?:[^']*(?:')){2})*[^']*(?:')[^']*$)/g, '∆')  // For } in single ' quotes
-    .replace(/{(?=(?:(?:[^']*(?:')){2})*[^']*(?:')[^']*$)/g, '▽')  // For { in single ' quotes
-    .replace(/{(?=(?:(?:[^"]*(?:")){2})*[^"]*(?:")[^"]*$)/g, '▽')  // For { in double " quotes
-    .replace(/\[(?=(?:(?:[^']*(?:')){2})*[^']*(?:')[^']*$)/g, '▸') // For [ in single ' quotes
-    .replace(/\[(?=(?:(?:[^"]*(?:")){2})*[^"]*(?:")[^"]*$)/g, '▸') // For [ in double " quotes
-    .replace(/\](?=(?:(?:[^']*(?:')){2})*[^']*(?:')[^']*$)/g, '◂') // For ] in single ' quotes
-    .replace(/\](?=(?:(?:[^"]*(?:")){2})*[^"]*(?:")[^"]*$)/g, '◂') // For ] in double " quotes
-
-  let parts = []
-  let current = ''
-  let inQuotes = false
-  let quoteChar = ''
-  let braceCount = 0
-  let bracketCount = 0
-
-  for (let char of str) {
-    if ((char === '"' || char === "'") && !inQuotes) {
-      inQuotes = true
-      quoteChar = char
-      current += char
-    } else if (char === quoteChar && inQuotes) {
-      inQuotes = false
-      quoteChar = ''
-      current += char
-    } else if (char === '{') {
-      braceCount++
-      current += char
-    } else if (char === '}') {
-      braceCount--
-      current += char
-    } else if (char === '[') {
-      bracketCount++
-      current += char
-    } else if (char === ']') {
-      bracketCount--
-      current += char
-    } else if (char === ' ' && !inQuotes && !braceCount && !bracketCount) {
-      if (current) parts.push(current)
-      current = ''
-    } else {
-      current += char
-    }
-  }
-
-  if (current) parts.push(current)
-  return parts.map((x) => {
-    return x
-      .replace(/∆/g, '}')
-      .replace(/▽/g, '{')
-      .replace(/▸/g, '[')
-      .replace(/◂/g, ']')
-  })
-  /* combineEquals */
-  .reduce((acc, item, i) => {
-    if (item.startsWith('=')) {
-      acc[acc.length - 1] += item
-      return acc
-    }
-    
-    if (acc.length && acc[acc.length - 1].endsWith('=') && (acc[acc.length - 1].match(/=/g) || []).length === 1) {
-      acc[acc.length - 1] += item
-      return acc
-    }
-    
-    acc.push(item)
-    return acc
-  }, [])
+module.exports = {
+  splitOutsideQuotes,
 }
-
-module.exports = { 
-  splitOutsideQuotes
-}