@znemz/cfn-include 2.1.21 → 2.1.23

package/bin/cli.js

@@ -1,23 +1,29 @@
 #!/usr/bin/env node
- 
-const exec = require('child_process').execSync;
-const path = require('path');
-const _ = require('lodash');
-const pathParse = require('path-parse');
 
-const include = require('../index');
-const yaml = require('../lib/yaml');
-const Client = require('../lib/cfnclient');
-const pkg = require('../package.json');
-const replaceEnv = require('../lib/replaceEnv');
+import { execSync } from 'node:child_process';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { readFileSync } from 'node:fs';
+import _ from 'lodash';
+// path.parse is native in Node.js - no need for path-parse package
+
+import include from '../index.js';
+import * as yaml from '../lib/yaml.js';
+import Client from '../lib/cfnclient.js';
+import replaceEnv from '../lib/replaceEnv.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// Read package.json using fs instead of import assertion
+const pkg = JSON.parse(readFileSync(path.join(__dirname, '../package.json'), 'utf8'));
 
 const { env } = process;
 
-(async () => {
-  const { default : yargs } = await import('yargs');
-  const { hideBin } = await import('yargs/helpers');
+const { default: yargs } = await import('yargs');
+const { hideBin } = await import('yargs/helpers');
 
-  const opts = yargs(hideBin(process.argv))
+const opts = yargs(hideBin(process.argv))
   .version(false)
   .command('$0 [path] [options]', pkg.description, (y) =>
     y.positional('path', {
@@ -60,9 +66,7 @@ const { env } = process;
       desc: 'bucket name required for templates larger than 50k',
     },
     context: {
-      desc:
-         
-        'template full path. only utilized for stdin when the template is piped to this script',
+      desc: 'template full path. only utilized for stdin when the template is piped to this script',
       required: false,
       string: true,
     },
@@ -79,13 +83,11 @@ const { env } = process;
     inject: {
       alias: 'i',
       string: true,
-       
       desc: `JSON string payload to use for template injection.`,
       coerce: (valStr) => JSON.parse(valStr),
     },
     doLog: {
       boolean: true,
-       
       desc: `console log out include options in recurse step`,
     },
     'ref-now-ignore-missing': {
@@ -111,14 +113,14 @@ const { env } = process;
 opts.enable = opts.enable.split(',');
 
 // Parse ref-now-ignores into an array
-const refNowIgnores = opts['ref-now-ignores'] ? opts['ref-now-ignores'].split(',').map(s => s.trim()) : [];
+const refNowIgnores = opts['ref-now-ignores'] ? opts['ref-now-ignores'].split(',').map((s) => s.trim()) : [];
 
 let promise;
 if (opts.path) {
   let location;
   const protocol = opts.path.match(/^\w+:\/\//);
   if (protocol) location = opts.path;
-  else if (pathParse(opts.path).root) location = `file://${opts.path}`;
+  else if (path.parse(opts.path).root) location = `file://${opts.path}`;
   else location = `file://${path.join(process.cwd(), opts.path)}`;
   promise = include({
     url: location,
@@ -142,9 +144,7 @@ if (opts.path) {
       process.exit(1);
     }
 
-    const location = opts.context
-      ? path.resolve(opts.context)
-      : path.join(process.cwd(), 'template.yml');
+    const location = opts.context ? path.resolve(opts.context) : path.join(process.cwd(), 'template.yml');
 
     template = opts.enable.includes('env') ? replaceEnv(template) : template;
 
@@ -166,13 +166,13 @@ promise
     if (opts.metadata) {
       let stdout;
       try {
-        stdout = exec('git log -n 1 --pretty=%H', {
+        stdout = execSync('git log -n 1 --pretty=%H', {
           stdio: [0, 'pipe', 'ignore'],
         })
           .toString()
           .trim();
       } catch {
-         
+        // ignore git errors
       }
       _.defaultsDeep(template, {
         Metadata: {
@@ -194,11 +194,7 @@ promise
     return template;
   })
   .then((template) => {
-    console.log(
-      opts.yaml
-        ? yaml.dump(template, opts)
-        : JSON.stringify(template, null, opts.minimize ? null : 2),
-    );
+    console.log(opts.yaml ? yaml.dump(template, opts) : JSON.stringify(template, null, opts.minimize ? null : 2));
   })
   .catch(function (err) {
     if (typeof err.toString === 'function') console.error(err.toString());
@@ -206,5 +202,3 @@ promise
     console.log(err.stack);
     process.exit(1);
   });
-
-})(); 

package/index.js

@@ -1,32 +1,32 @@
-const url = require('url');
-const path = require('path');
-const _ = require('lodash');
-const { glob } = require('glob');
-const Promise = require('bluebird');
-const sortObject = require('@znemz/sort-object');
-const { S3Client, GetObjectCommand } = require('@aws-sdk/client-s3');
-const { addProxyToClient } = require('aws-sdk-v3-proxy');
-
-const pathParse = require('path-parse');
-const deepMerge = require('deepmerge');
-const { isTaggableResource } = require('@znemz/cft-utils/src/resources/taggable');
-
-const request = require('./lib/request');
-const PromiseExt = require('./lib/promise');
+import url from 'node:url';
+import path from 'node:path';
+import _ from 'lodash';
+import { glob } from 'glob';
+import sortObject from '@znemz/sort-object';
+import { S3Client, GetObjectCommand } from '@aws-sdk/client-s3';
+import { addProxyToClient } from 'aws-sdk-v3-proxy';
+
+// path.parse is native in Node.js - no need for path-parse package
+import deepMerge from 'deepmerge';
+import { isTaggableResource } from '@znemz/cft-utils/src/resources/taggable.js';
+
+import request from './lib/request.js';
+import * as PromiseExt from './lib/promise.js';
 
 const S3 = (opts = {}) => addProxyToClient(new S3Client(opts), { throwOnNoProxy: false });
 
 const s3 = S3();
-const yaml = require('./lib/yaml');
-const { getParser } = require('./lib/include/query');
-const parseLocation = require('./lib/parselocation');
-const replaceEnv = require('./lib/replaceEnv');
-
-const { lowerCamelCase, upperCamelCase } = require('./lib/utils');
-const { isOurExplicitFunction } = require('./lib/schema');
-const { getAwsPseudoParameters, buildResourceArn } = require('./lib/internals');
-const { cachedReadFile } = require('./lib/cache');
-const { createChildScope } = require('./lib/scope');
+import * as yaml from './lib/yaml.js';
+import { getParser } from './lib/include/query.js';
+import parseLocation from './lib/parselocation.js';
+import replaceEnv from './lib/replaceEnv.js';
+
+import { lowerCamelCase, upperCamelCase } from './lib/utils.js';
+import { isOurExplicitFunction } from './lib/schema.js';
+import { getAwsPseudoParameters, buildResourceArn } from './lib/internals.js';
+import { cachedReadFile } from './lib/cache.js';
+import { createChildScope } from './lib/scope.js';
+import { promiseProps } from './lib/promise-utils.js';
 
 /**
  * @param  {object} options
@@ -53,7 +53,7 @@ const { createChildScope } = require('./lib/scope');
  *     doEval: opts.doEval, -- allow Fn::Eval to be used
  *   })
  */
-module.exports = async function (options) {
+export default async function (options) {
   let { template } = options;
   options.doEnv = getBoolEnvOpt(options.doEnv, 'CFN_INCLUDE_DO_ENV');
   options.doEval = getBoolEnvOpt(options.doEval, 'CFN_INCLUDE_DO_EVAL');
@@ -72,7 +72,7 @@ module.exports = async function (options) {
     rootTemplate: resolvedTemplate,
     ...options,
   });
-};
+}
 
 /**
  * @param  {object} base file options
@@ -310,9 +310,9 @@ async function recurse({ base, scope, cft, rootTemplate, caller, ...opts }) {
           delete cft['Fn::DeepMerge'];
           let mergedObj = {};
           if (json && json.length) {
-            json.forEach((j) => {
+            for (const j of json) {
               mergedObj = deepMerge(mergedObj, j);
-            });
+            }
           }
           return recurse({ base, scope, cft: _.defaults(cft, mergedObj), rootTemplate, caller: 'Fn::DeepMerge', ...opts });
         },
@@ -585,7 +585,7 @@ async function recurse({ base, scope, cft, rootTemplate, caller, ...opts }) {
       });
     }
 
-    return Promise.props(
+    return promiseProps(
       _.mapValues(cft, (template, key) => recurse({ base, scope, cft: template, key, rootTemplate, caller: 'recurse:isPlainObject:end', ...opts })),
     );
   }
@@ -616,15 +616,15 @@ function findAndReplace(scope, object) {
     }
   }
   if (Array.isArray(object)) {
-    object = object.map(_.bind(findAndReplace, this, scope));
+    object = object.map((item) => findAndReplace(scope, item));
   } else if (_.isPlainObject(object)) {
     object = _.mapKeys(object, function (value, key) {
       return findAndReplace(scope, key);
     });
-    Object.keys(object).forEach(function (key) {
-      if (key === 'Fn::Map') return;
+    for (const key of Object.keys(object)) {
+      if (key === 'Fn::Map') continue;
       object[key] = findAndReplace(scope, object[key]);
-    });
+    }
   }
   return object;
 }
@@ -743,7 +743,7 @@ async function fnInclude({ base, scope, cft, ...opts }) {
     body = cachedReadFile(absolute).then(procTemplate);
     absolute = `${location.protocol}://${absolute}`;
   } else if (location.protocol === 's3') {
-    const basedir = pathParse(base.path).dir;
+    const basedir = path.parse(base.path).dir;
     const bucket = location.relative ? base.host : location.host;
 
     let key = location.relative ? url.resolve(`${basedir}/`, location.raw) : location.path;
@@ -759,7 +759,7 @@ async function fnInclude({ base, scope, cft, ...opts }) {
       .then((res) => res.Body.toString())
       .then(procTemplate);
   } else if (location.protocol && location.protocol.match(/^https?$/)) {
-    const basepath = `${pathParse(base.path).dir}/`;
+    const basepath = `${path.parse(base.path).dir}/`;
 
     absolute = location.relative
       ? url.resolve(`${location.protocol}://${base.host}${basepath}`, location.raw)
@@ -883,13 +883,14 @@ async function handleIncludeBody({ scope, args, body, absolute }) {
 function JSONifyString(string) {
   const lines = [];
   const split = string.toString().split(/(\r?\n)/);
-  split.forEach(function (line, idx) {
+  for (let idx = 0; idx < split.length; idx++) {
+    const line = split[idx];
     if (idx % 2) {
       lines[(idx - 1) / 2] = lines[(idx - 1) / 2] + line;
     } else {
       lines.push(line);
     }
-  });
+  }
   return lines;
 }
 

package/lib/cache.js

@@ -2,7 +2,7 @@
  * File content cache to avoid redundant disk I/O.
  */
 
-const { readFile } = require('fs/promises');
+import { readFile } from 'node:fs/promises';
 
 // File content cache to avoid re-reading the same files
 const fileCache = new Map();
@@ -12,7 +12,7 @@ const fileCache = new Map();
  * @param {string} absolutePath - Absolute path to the file
  * @returns {Promise<string>} File content as a string
  */
-async function cachedReadFile(absolutePath) {
+export async function cachedReadFile(absolutePath) {
   if (fileCache.has(absolutePath)) {
     return fileCache.get(absolutePath);
   }
@@ -24,11 +24,6 @@ async function cachedReadFile(absolutePath) {
 /**
  * Clear the file cache (useful for testing)
  */
-function clearFileCache() {
+export function clearFileCache() {
   fileCache.clear();
 }
-
-module.exports = {
-  cachedReadFile,
-  clearFileCache,
-};

package/lib/cfnclient.js

@@ -1,12 +1,9 @@
-const {
-  CloudFormationClient,
-  ValidateTemplateCommand,
-} = require('@aws-sdk/client-cloudformation');
-const { S3Client, PutObjectCommand, DeleteObjectCommand } = require('@aws-sdk/client-s3');
-const { addProxyToClient } = require('aws-sdk-v3-proxy');
+import { CloudFormationClient, ValidateTemplateCommand } from '@aws-sdk/client-cloudformation';
+import { S3Client, PutObjectCommand, DeleteObjectCommand } from '@aws-sdk/client-s3';
+import { addProxyToClient } from 'aws-sdk-v3-proxy';
 
-const { posix: path } = require('path');
-const crypto = require('crypto');
+import path from 'node:path';
+import crypto from 'node:crypto';
 
 const S3 = (opts = {}) => addProxyToClient(new S3Client(opts));
 const CloudFormation = (opts = {}) => addProxyToClient(new CloudFormationClient(opts));
@@ -29,7 +26,7 @@ class Client {
   }
 
   async uploadTemplate(tpl, callback) {
-    const key = path.join(this.prefix, `${this.digest(tpl)}.json`);
+    const key = path.posix.join(this.prefix, `${this.digest(tpl)}.json`);
     await this.s3.Send(
       new PutObjectCommand({
         Body: tpl,
@@ -84,4 +81,4 @@ class Client {
   }
 }
 
-module.exports = Client;
+export default Client;

package/lib/include/api.js

@@ -1,9 +1,13 @@
-let AWS = require('aws-sdk-proxy'),
-  jmespath = require('jmespath');
+// NOTE: This module uses the legacy AWS SDK v2 via aws-sdk-proxy
+// It may be unused and could be removed or rewritten for SDK v3
+import AWS from 'aws-sdk-proxy';
+import jmespath from 'jmespath';
 
-module.exports = function (args) {
-  var service = new AWS[args.service](args.region ? { region: args.region } : null);
-  return service[args.action](args.parameters ? args.parameters : {}).promise().then(function (res) {
-    return args.query ? jmespath.search(res, args.query) : res;
-  });
+export default function (args) {
+  const service = new AWS[args.service](args.region ? { region: args.region } : null);
+  return service[args.action](args.parameters ? args.parameters : {})
+    .promise()
+    .then(function (res) {
+      return args.query ? jmespath.search(res, args.query) : res;
+    });
 }

package/lib/include/query.js

@@ -1,19 +1,16 @@
-const { get } = require("lodash");
-const { search } = require("jmespath");
+import _ from 'lodash';
+import jmespath from 'jmespath';
 
 // this exists cause in most cases lodash get is plenty sufficient
-// also this bug / error in jmespath is rediculous https://github.com/jmespath/jmespath.js/issues/35
+// also this bug / error in jmespath is ridiculous https://github.com/jmespath/jmespath.js/issues/35
 const queryParsers = {
-  lodash: (obj, path) => get(obj, path) || "",
-  jmespath: search,
-  default: search,
+  lodash: (obj, path) => _.get(obj, path) || '',
+  jmespath: jmespath.search,
+  default: jmespath.search,
 };
 
-queryParsers["default"] =
-  queryParsers[process.env.CFN_INCLUDE_QUERY_PARSER] || queryParsers.default;
+queryParsers['default'] = queryParsers[process.env.CFN_INCLUDE_QUERY_PARSER] || queryParsers.default;
 
-function getParser(type) {
+export function getParser(type) {
   return queryParsers[type] || queryParsers.default;
 }
-
-module.exports = { getParser };

package/lib/internals.js

@@ -168,7 +168,4 @@ function buildResourceArn(resourceType, properties = {}, pseudoParams = {}, opti
   return null;
 }
 
-module.exports = {
-  getAwsPseudoParameters,
-  buildResourceArn,
-};
+export { getAwsPseudoParameters, buildResourceArn };

package/lib/parselocation.js

@@ -1,17 +1,15 @@
-var { isUndefined } = require('lodash');
-
-module.exports = function parseLocation(location) {
-  if(!location) return {};
+export default function parseLocation(location) {
+  if (!location) return {};
   if (!location.match) {
     console.error('location.match is not a function', location);
   }
-  var parsed = location.match(/^(((\w+):)?\/\/)?(.*?)([\\\/](.*))?$/);
+  const parsed = location.match(/^(((\w+):)?\/\/)?(.*?)([\\\/](.*))?$/);
 
   return {
     protocol: parsed[3],
     host: parsed[4],
     path: parsed[5],
-    relative: isUndefined(parsed[1]),
+    relative: parsed[1] === undefined,
     raw: location,
   };
 }

package/lib/promise-utils.js

@@ -0,0 +1,46 @@
+/**
+ * Native Promise utilities to replace bluebird.
+ * These are drop-in replacements for the bluebird methods we use.
+ */
+
+/**
+ * Promise.props replacement - resolves an object of promises.
+ * @param {Object} obj - Object with promise values
+ * @returns {Promise<Object>} Object with resolved values
+ */
+async function promiseProps(obj) {
+  const keys = Object.keys(obj);
+  const values = await Promise.all(keys.map((key) => obj[key]));
+  const result = {};
+  for (let i = 0; i < keys.length; i++) {
+    result[keys[i]] = values[i];
+  }
+  return result;
+}
+
+/**
+ * Promise.try replacement - wraps a function to catch sync errors.
+ * @param {Function} fn - Function to execute
+ * @returns {Promise} Promise that resolves to fn result or rejects on error
+ */
+function promiseTry(fn) {
+  return new Promise((resolve, reject) => {
+    try {
+      resolve(fn());
+    } catch (err) {
+      reject(err);
+    }
+  });
+}
+
+/**
+ * Promise.map replacement - maps over array with concurrency.
+ * @param {Array} arr - Array to map over
+ * @param {Function} fn - Async function to apply
+ * @returns {Promise<Array>} Array of resolved values
+ */
+function promiseMap(arr, fn) {
+  return Promise.all(arr.map(fn));
+}
+
+export { promiseProps, promiseTry, promiseMap };

package/lib/promise.js

@@ -1,21 +1,18 @@
-const Promise = require('bluebird');
-const _ = require('lodash');
+import { promiseTry, promiseMap } from './promise-utils.js';
 
 /*
   Maps over objects or iterables just like lodash.
 */
 const mapWhatever = (promises, cb) =>
-  Promise.try(() =>
+  promiseTry(() =>
     Promise.resolve(promises).then((arrayOrObject) => {
-      if (_.isArray(arrayOrObject)) {
-        return Promise.map(arrayOrObject, cb);
+      if (Array.isArray(arrayOrObject)) {
+        return promiseMap(arrayOrObject, cb);
       }
       const size = Object.values(arrayOrObject).length;
-      return Promise.all(_.map(arrayOrObject, (value, key) => cb(value, key, size)));
+      const entries = Object.entries(arrayOrObject);
+      return Promise.all(entries.map(([key, value]) => cb(value, key, size)));
     }),
   );
 
-module.exports = {
-  mapWhatever,
-  mapX: mapWhatever,
-};
+export { mapWhatever, mapWhatever as mapX };

package/lib/replaceEnv.js

@@ -1,5 +1,5 @@
-const passThrough = (template) => template
-const replaceProcessEnv = (template) => replaceEnv(template, process.env, false)
+const passThrough = (template) => template;
+const replaceProcessEnv = (template) => replaceEnv(template, process.env, false);
 
 // Cache for compiled regex patterns to avoid re-creating them
 const regexCache = new Map();
@@ -29,39 +29,38 @@ function getVarRegex(key, withBraces) {
   return regexCache.get(cacheKey);
 }
 
-const replaceEnv = (template, inject = {}, doEnv) => {
+let processTemplate;
+
+function replaceEnv(template, inject = {}, doEnv) {
   processTemplate = doEnv ? replaceProcessEnv : passThrough;
 
-  if (!template || typeof template !== "string") {
-    // return template;
-    return processTemplate(template)
-  };
+  if (!template || typeof template !== 'string') {
+    return processTemplate(template);
+  }
 
   const keys = Object.keys(inject);
 
   for (let i = 0; i < keys.length; i++) {
     const key = keys[i];
-    let val = inject[key];
+    const val = inject[key];
 
     // Use cached regex patterns instead of creating new ones each time
     const bareRegex = getVarRegex(key, false);
     const bracedRegex = getVarRegex(key, true);
-    
+
     // Reset lastIndex for global regex reuse
     bareRegex.lastIndex = 0;
     bracedRegex.lastIndex = 0;
-    
-    template = template
-      .replace(bareRegex, val)
-      .replace(bracedRegex, val);
+
+    template = template.replace(bareRegex, val).replace(bracedRegex, val);
   }
 
-  // return template;
   return processTemplate(template);
 }
 
-const IsRegExVar = (str) =>  /\$\w+/.test(str) || /\$\{\w+\}/.test(str)
+const IsRegExVar = (str) => /\$\w+/.test(str) || /\$\{\w+\}/.test(str);
 
 replaceEnv.IsRegExVar = IsRegExVar; // hack to be backward compat
 
-module.exports = replaceEnv;
+export default replaceEnv;
+export { IsRegExVar };

package/lib/request.js

@@ -1,17 +1,22 @@
-var url = require('url'),
-  https = require('https'),
-  http = require('http');
+import { parse as urlParse } from 'node:url';
+import https from 'node:https';
+import http from 'node:http';
 
-module.exports = function(location) {
-  var parsed = url.parse(location),
-    proto = parsed.protocol === 'https:' ? https : http;
-  
-  return new Promise((resolve, reject) => proto.get(location, res => {
-    if (res.statusCode > 299) return reject(new Error('HTTP request failed with status code ' + res.statusCode));
-    var rawData = [];
-    res.setEncoding('utf8');
-    res.on('data', chunk => rawData.push(chunk));
-    res.on('end', () => resolve(rawData.join(''))); 
-  }).on('error', reject));
-  
-}
+export default function request(location) {
+  const parsed = urlParse(location);
+  const proto = parsed.protocol === 'https:' ? https : http;
+
+  return new Promise((resolve, reject) =>
+    proto
+      .get(location, (res) => {
+        if (res.statusCode > 299) {
+          return reject(new Error('HTTP request failed with status code ' + res.statusCode));
+        }
+        const rawData = [];
+        res.setEncoding('utf8');
+        res.on('data', (chunk) => rawData.push(chunk));
+        res.on('end', () => resolve(rawData.join('')));
+      })
+      .on('error', reject),
+  );
+}

package/lib/schema.js

@@ -1,7 +1,7 @@
-var yaml = require('js-yaml'),
-  _ = require('lodash');
+import yaml from 'js-yaml';
+import _ from 'lodash';
 
-var tags = [
+const tags = [
   { short: 'Include', full: 'Fn::Include', type: 'scalar' },
   { short: 'Include', full: 'Fn::Include', type: 'mapping' },
   { short: 'Stringify', full: 'Fn::Stringify', type: 'sequence' },
@@ -73,8 +73,8 @@ var tags = [
     kind: fn.type,
     construct: function (obj) {
       if (fn.dotSyntax && _.isString(obj)) {
-        var indexOfDot = obj.indexOf('.');
-        if (indexOfDot != -1) obj = [obj.substr(0, indexOfDot), obj.substr(indexOfDot + 1)];
+        const indexOfDot = obj.indexOf('.');
+        if (indexOfDot !== -1) obj = [obj.substr(0, indexOfDot), obj.substr(indexOfDot + 1)];
         else obj = [obj];
       }
       return _.fromPairs([[fn.full, obj]]);
@@ -106,12 +106,12 @@ const BANG_AMAZON_FUNCS = [
 
 const EXPLICIT_AMAZON_FUNCS = BANG_AMAZON_FUNCS.map((f) => `Fn::${f}`);
 
-module.exports = yaml.DEFAULT_SCHEMA.extend(tags);
-
-module.exports.EXPLICIT_AMAZON_FUNCS = EXPLICIT_AMAZON_FUNCS;
-module.exports.BANG_AMAZON_FUNCS = BANG_AMAZON_FUNCS;
+const yamlSchema = yaml.DEFAULT_SCHEMA.extend(tags);
 
 // Test the function key to make sure it's something
 // we should process.
-module.exports.isOurExplicitFunction = (testKeyForFunc) =>
-  /Fn::.*/.test(testKeyForFunc) && EXPLICIT_AMAZON_FUNCS.indexOf(testKeyForFunc) === -1;
+const isOurExplicitFunction = (testKeyForFunc) =>
+  /Fn::.*/.test(testKeyForFunc) && !EXPLICIT_AMAZON_FUNCS.includes(testKeyForFunc);
+
+export default yamlSchema;
+export { EXPLICIT_AMAZON_FUNCS, BANG_AMAZON_FUNCS, isOurExplicitFunction };

package/lib/scope.js

@@ -14,7 +14,7 @@
  * @param {Object} [additions={}] - Properties to add to the child scope
  * @returns {Object} A new child scope with prototype chain to parent
  */
-function createChildScope(parent, additions = {}) {
+export function createChildScope(parent, additions = {}) {
   const child = Object.create(parent);
   Object.assign(child, additions);
   return child;
@@ -30,7 +30,7 @@ function createChildScope(parent, additions = {}) {
  * @param {Object} scope - The scope to flatten
  * @returns {Object} A plain object with all inherited properties
  */
-function scopeToObject(scope) {
+export function scopeToObject(scope) {
   const result = {};
   for (const key in scope) {
     result[key] = scope[key];
@@ -45,14 +45,8 @@ function scopeToObject(scope) {
  * @param {Object} scope - The scope to iterate over
  * @param {Function} callback - Function to call with (value, key)
  */
-function forEachInScope(scope, callback) {
+export function forEachInScope(scope, callback) {
   for (const key in scope) {
     callback(scope[key], key);
   }
 }
-
-module.exports = {
-  createChildScope,
-  scopeToObject,
-  forEachInScope,
-};

package/lib/utils.js

@@ -1,11 +1,11 @@
-const assert = require('assert').strict;
+import assert from 'node:assert/strict';
 
 function upperCamelCase(str) {
   assert(typeof str === 'string', 'argument to upper/lowerCamelCase must be a string');
   return str
-      .split(/[\._-\s]+/)
-      .map((s) => s.charAt(0).toUpperCase() + s.slice(1).toLowerCase())
-      .join('');
+    .split(/[\._-\s]+/)
+    .map((s) => s.charAt(0).toUpperCase() + s.slice(1).toLowerCase())
+    .join('');
 }
 
 function lowerCamelCase(str) {
@@ -13,7 +13,4 @@ function lowerCamelCase(str) {
   return upper.charAt(0).toLowerCase() + upper.slice(1);
 }
 
-module.exports = {
-  lowerCamelCase,
-  upperCamelCase,
-};
+export { lowerCamelCase, upperCamelCase };

package/lib/yaml.js

@@ -1,22 +1,76 @@
-const minify = require('jsonminify');
-const yaml = require('js-yaml');
-const yamlSchema = require('./schema');
+import yaml from 'js-yaml';
+import yamlSchema from './schema.js';
 
-module.exports = {
-  load: (res) => {
-    let json;
-    try {
-      json = yaml.load(res, { schema: yamlSchema });
-    } catch (yamlErr) {
-      try {
-        json = JSON.parse(minify(res));
-      } catch (jsonErr) {
-        const err = new Error([yamlErr, jsonErr]);
-        err.name = 'SyntaxError';
-        throw err;
+/**
+ * Simple JSON minify - strips comments and whitespace.
+ * Handles JavaScript-style single-line (//) and multi-line comments.
+ * @param {string} json - JSON string potentially with comments
+ * @returns {string} Minified JSON without comments
+ */
+function jsonMinify(json) {
+  // Remove single-line comments (// ...)
+  // Remove multi-line comments (/* ... */)
+  // Be careful not to remove // or /* inside strings
+  let inString = false;
+  let escaped = false;
+  let result = '';
+  let i = 0;
+
+  while (i < json.length) {
+    const char = json[i];
+    const nextChar = json[i + 1];
+
+    if (inString) {
+      result += char;
+      if (escaped) {
+        escaped = false;
+      } else if (char === '\\') {
+        escaped = true;
+      } else if (char === '"') {
+        inString = false;
+      }
+      i++;
+    } else if (char === '"') {
+      inString = true;
+      result += char;
+      i++;
+    } else if (char === '/' && nextChar === '/') {
+      // Single-line comment - skip until newline
+      while (i < json.length && json[i] !== '\n') {
+        i++;
+      }
+    } else if (char === '/' && nextChar === '*') {
+      // Multi-line comment - skip until */
+      i += 2;
+      while (i < json.length - 1 && !(json[i] === '*' && json[i + 1] === '/')) {
+        i++;
       }
+      i += 2; // Skip */
+    } else {
+      result += char;
+      i++;
     }
-    return json;
-  },
-  dump: (obj, opts) => yaml.dump(obj, { sortKeys: true, ...opts }),
-};
+  }
+
+  return result;
+}
+
+export function load(res) {
+  let json;
+  try {
+    json = yaml.load(res, { schema: yamlSchema });
+  } catch (yamlErr) {
+    try {
+      json = JSON.parse(jsonMinify(res));
+    } catch (jsonErr) {
+      const err = new Error([yamlErr, jsonErr]);
+      err.name = 'SyntaxError';
+      throw err;
+    }
+  }
+  return json;
+}
+
+export function dump(obj, opts) {
+  return yaml.dump(obj, { sortKeys: true, ...opts });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@znemz/cfn-include",
-  "version": "2.1.21",
+  "version": "2.1.23",
   "description": "Preprocessor for CloudFormation templates with support for loops and flexible include statements",
   "keywords": [
     "aws",
@@ -21,6 +21,11 @@
     "name": "Nicholas McCready",
     "email": "nemtcan@gmail.com"
   },
+  "type": "module",
+  "exports": {
+    ".": "./index.js",
+    "./lib/*": "./lib/*"
+  },
   "bin": {
     "cfn-include": "bin/cli.js"
   },
@@ -48,14 +53,11 @@
     "@znemz/cft-utils": "0.1.33",
     "@znemz/sort-object": "^3.0.4",
     "aws-sdk-v3-proxy": "2.2.0",
-    "bluebird": "^3.7.2",
     "deepmerge": "^4.2.2",
     "glob": "^13.0.0",
     "jmespath": "^0.16.0",
     "js-yaml": "^4.1.1",
-    "jsonminify": "^0.4.1",
     "lodash": "^4.17.21",
-    "path-parse": "~1.0.7",
     "proxy-agent": "6.5.0",
     "yargs": "~18.0.0"
   },