@znemz/cfn-include 2.1.23 → 2.1.24

package/lib/cfnclient.js

@@ -1,84 +0,0 @@
-import { CloudFormationClient, ValidateTemplateCommand } from '@aws-sdk/client-cloudformation';
-import { S3Client, PutObjectCommand, DeleteObjectCommand } from '@aws-sdk/client-s3';
-import { addProxyToClient } from 'aws-sdk-v3-proxy';
-
-import path from 'node:path';
-import crypto from 'node:crypto';
-
-const S3 = (opts = {}) => addProxyToClient(new S3Client(opts));
-const CloudFormation = (opts = {}) => addProxyToClient(new CloudFormationClient(opts));
-
-class Client {
-  constructor({ region = 'us-east-1', bucket, prefix }) {
-    this.client = CloudFormation({
-      region,
-    });
-    this.s3 = S3();
-    this.bucket = bucket;
-    this.prefix = prefix;
-    this.region = region;
-  }
-
-  digest(input) {
-    const hash = crypto.createHash('md5');
-    hash.update(input);
-    return hash.digest('hex');
-  }
-
-  async uploadTemplate(tpl, callback) {
-    const key = path.posix.join(this.prefix, `${this.digest(tpl)}.json`);
-    await this.s3.Send(
-      new PutObjectCommand({
-        Body: tpl,
-        Bucket: this.bucket,
-        Key: key,
-      }),
-    );
-
-    let res, err;
-    try {
-      res = await callback(key);
-    } catch (e) {
-      err = e;
-    }
-    await this.s3
-      .send(
-        new DeleteObjectCommand({
-          Bucket: this.bucket,
-          Key: key,
-        }),
-      )
-      .catch(() => {});
-    if (err) throw err;
-    return res;
-  }
-
-  async validateTemplate(tpl = '') {
-    const needsUpload = tpl.length > 51200;
-    if (needsUpload && !this.bucket) {
-      throw 'Cannot validate template larger than 50k without a bucket. Please provide a bucket name.';
-    }
-    if (needsUpload && tpl.length > 460800) {
-      throw 'Template exceeds maximum size of 450k';
-    }
-    if (needsUpload) {
-      return this.uploadTemplate(tpl, (key) =>
-        this.client
-          .send(
-            new ValidateTemplateCommand({
-              TemplateURL: `https://s3.${this.region}.amazonaws.com/${this.bucket}/${key}`,
-            }),
-          )
-          .promise(),
-      );
-    }
-
-    return this.client.send(
-      new ValidateTemplateCommand({
-        TemplateBody: tpl,
-      }),
-    );
-  }
-}
-
-export default Client;

package/lib/include/api.js

@@ -1,13 +0,0 @@
-// 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';
-
-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,16 +0,0 @@
-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 ridiculous https://github.com/jmespath/jmespath.js/issues/35
-const queryParsers = {
-  lodash: (obj, path) => _.get(obj, path) || '',
-  jmespath: jmespath.search,
-  default: jmespath.search,
-};
-
-queryParsers['default'] = queryParsers[process.env.CFN_INCLUDE_QUERY_PARSER] || queryParsers.default;
-
-export function getParser(type) {
-  return queryParsers[type] || queryParsers.default;
-}

package/lib/internals.js

@@ -1,171 +0,0 @@
-function getAwsPseudoParameters() {
-  return {
-    'AWS::AccountId': process.env.AWS_ACCOUNT_ID || process.env.AWS_ACCOUNT_NUM || '${AWS::AccountId}',
-    'AWS::Partition': process.env.AWS_PARTITION || 'aws',
-    'AWS::Region': process.env.AWS_REGION || '${AWS::Region}',
-    'AWS::StackId': process.env.AWS_STACK_ID || '${AWS::StackId}',
-    'AWS::StackName': process.env.AWS_STACK_NAME || '${AWS::StackName}',
-    'AWS::URLSuffix': process.env.AWS_URL_SUFFIX || 'amazonaws.com',
-    'AWS::NotificationARNs': process.env.AWS_NOTIFICATION_ARNS || '${AWS::NotificationARNs}',
-  };
-}
-
-/**
- * Build an ARN for a CloudFormation resource based on its Type and Properties
- * Supports both ARN construction and property name resolution
- * @param {string} resourceType - The CloudFormation resource type (e.g., 'AWS::IAM::ManagedPolicy')
- * @param {object} properties - The resource properties
- * @param {object} pseudoParams - AWS pseudo-parameters including AccountId, Region
- * @param {object} options - Optional configuration
- * @param {string} options.returnType - 'arn' (default) or 'name' to return the resource name/identifier
- * @returns {string|null} - The ARN, name, or null if not applicable
- */
-function buildResourceArn(resourceType, properties = {}, pseudoParams = {}, options = {}) {
-  const accountId = pseudoParams['AWS::AccountId'] || '${AWS::AccountId}';
-  const region = pseudoParams['AWS::Region'] || '${AWS::Region}';
-  const partition = pseudoParams['AWS::Partition'] || 'aws';
-  const returnType = options.returnType || 'arn';
-
-  // Handle AWS::IAM::ManagedPolicy
-  if (resourceType === 'AWS::IAM::ManagedPolicy') {
-    const { ManagedPolicyName, Path } = properties;
-    if (ManagedPolicyName) {
-      if (returnType === 'name') {
-        return ManagedPolicyName;
-      }
-      const path = Path || '/';
-      return `arn:${partition}:iam::${accountId}:policy${path}${ManagedPolicyName}`;
-    }
-  }
-
-  // Handle AWS::IAM::Role
-  if (resourceType === 'AWS::IAM::Role') {
-    const { RoleName, Path } = properties;
-    if (RoleName) {
-      if (returnType === 'name') {
-        return RoleName;
-      }
-      const path = Path || '/';
-      return `arn:${partition}:iam::${accountId}:role${path}${RoleName}`;
-    }
-  }
-
-  // Handle AWS::S3::Bucket
-  if (resourceType === 'AWS::S3::Bucket') {
-    const { BucketName } = properties;
-    if (BucketName) {
-      if (returnType === 'name') {
-        return BucketName;
-      }
-      return `arn:${partition}:s3:::${BucketName}`;
-    }
-  }
-
-  // Handle AWS::Lambda::Function
-  if (resourceType === 'AWS::Lambda::Function') {
-    const { FunctionName } = properties;
-    if (FunctionName) {
-      if (returnType === 'name') {
-        return FunctionName;
-      }
-      return `arn:${partition}:lambda:${region}:${accountId}:function:${FunctionName}`;
-    }
-  }
-
-  // Handle AWS::SQS::Queue
-  if (resourceType === 'AWS::SQS::Queue') {
-    const { QueueName } = properties;
-    if (QueueName) {
-      if (returnType === 'name') {
-        return QueueName;
-      }
-      return `arn:${partition}:sqs:${region}:${accountId}:${QueueName}`;
-    }
-  }
-
-  // Handle AWS::SNS::Topic
-  if (resourceType === 'AWS::SNS::Topic') {
-    const { TopicName } = properties;
-    if (TopicName) {
-      if (returnType === 'name') {
-        return TopicName;
-      }
-      return `arn:${partition}:sns:${region}:${accountId}:${TopicName}`;
-    }
-  }
-
-  // Handle AWS::DynamoDB::Table
-  if (resourceType === 'AWS::DynamoDB::Table') {
-    const { TableName } = properties;
-    if (TableName) {
-      if (returnType === 'name') {
-        return TableName;
-      }
-      return `arn:${partition}:dynamodb:${region}:${accountId}:table/${TableName}`;
-    }
-  }
-
-  // Handle AWS::RDS::DBInstance
-  if (resourceType === 'AWS::RDS::DBInstance') {
-    const { DBInstanceIdentifier } = properties;
-    if (DBInstanceIdentifier) {
-      if (returnType === 'name') {
-        return DBInstanceIdentifier;
-      }
-      return `arn:${partition}:rds:${region}:${accountId}:db:${DBInstanceIdentifier}`;
-    }
-  }
-
-  // Handle AWS::EC2::SecurityGroup
-  if (resourceType === 'AWS::EC2::SecurityGroup') {
-    const { GroupName } = properties;
-    if (GroupName) {
-      if (returnType === 'name') {
-        return GroupName;
-      }
-      // Security groups need to be referenced by ID in most cases, not ARN
-      // This returns the name for reference purposes
-      return GroupName;
-    }
-  }
-
-  // Handle AWS::IAM::InstanceProfile
-  if (resourceType === 'AWS::IAM::InstanceProfile') {
-    const { InstanceProfileName, Path } = properties;
-    if (InstanceProfileName) {
-      if (returnType === 'name') {
-        return InstanceProfileName;
-      }
-      const path = Path || '/';
-      return `arn:${partition}:iam::${accountId}:instance-profile${path}${InstanceProfileName}`;
-    }
-  }
-
-  // Handle AWS::KMS::Key
-  if (resourceType === 'AWS::KMS::Key') {
-    // KMS keys are referenced by KeyId or KeyArn in properties
-    const { KeyId } = properties;
-    if (KeyId) {
-      if (returnType === 'name') {
-        return KeyId;
-      }
-      return `arn:${partition}:kms:${region}:${accountId}:key/${KeyId}`;
-    }
-  }
-
-  // Handle AWS::SecretsManager::Secret
-  if (resourceType === 'AWS::SecretsManager::Secret') {
-    const { Name } = properties;
-    if (Name) {
-      if (returnType === 'name') {
-        return Name;
-      }
-      return `arn:${partition}:secretsmanager:${region}:${accountId}:secret:${Name}`;
-    }
-  }
-
-  // Add more resource types as needed
-  return null;
-}
-
-export { getAwsPseudoParameters, buildResourceArn };

package/lib/parselocation.js

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

package/lib/promise-utils.js

@@ -1,46 +0,0 @@
-/**
- * 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,18 +0,0 @@
-import { promiseTry, promiseMap } from './promise-utils.js';
-
-/*
-  Maps over objects or iterables just like lodash.
-*/
-const mapWhatever = (promises, cb) =>
-  promiseTry(() =>
-    Promise.resolve(promises).then((arrayOrObject) => {
-      if (Array.isArray(arrayOrObject)) {
-        return promiseMap(arrayOrObject, cb);
-      }
-      const size = Object.values(arrayOrObject).length;
-      const entries = Object.entries(arrayOrObject);
-      return Promise.all(entries.map(([key, value]) => cb(value, key, size)));
-    }),
-  );
-
-export { mapWhatever, mapWhatever as mapX };

package/lib/replaceEnv.js

@@ -1,66 +0,0 @@
-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();
-
-/**
- * Escape special regex characters in a string
- * @param {string} str - String to escape
- * @returns {string} Escaped string safe for regex
- */
-function escapeRegExp(str) {
-  return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
-
-/**
- * Get a cached regex for variable substitution
- * @param {string} key - Variable name
- * @param {boolean} withBraces - Whether to match ${key} format (true) or $key format (false)
- * @returns {RegExp} Cached regex pattern
- */
-function getVarRegex(key, withBraces) {
-  const cacheKey = `${key}:${withBraces}`;
-  if (!regexCache.has(cacheKey)) {
-    const escaped = escapeRegExp(key);
-    const pattern = withBraces ? `\\$\\{${escaped}\\}` : `\\$${escaped}`;
-    regexCache.set(cacheKey, new RegExp(pattern, 'g'));
-  }
-  return regexCache.get(cacheKey);
-}
-
-let processTemplate;
-
-function replaceEnv(template, inject = {}, doEnv) {
-  processTemplate = doEnv ? replaceProcessEnv : passThrough;
-
-  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];
-    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);
-  }
-
-  return processTemplate(template);
-}
-
-const IsRegExVar = (str) => /\$\w+/.test(str) || /\$\{\w+\}/.test(str);
-
-replaceEnv.IsRegExVar = IsRegExVar; // hack to be backward compat
-
-export default replaceEnv;
-export { IsRegExVar };

package/lib/request.js

@@ -1,22 +0,0 @@
-import { parse as urlParse } from 'node:url';
-import https from 'node:https';
-import http from 'node:http';
-
-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,117 +0,0 @@
-import yaml from 'js-yaml';
-import _ from 'lodash';
-
-const tags = [
-  { short: 'Include', full: 'Fn::Include', type: 'scalar' },
-  { short: 'Include', full: 'Fn::Include', type: 'mapping' },
-  { short: 'Stringify', full: 'Fn::Stringify', type: 'sequence' },
-  { short: 'Stringify', full: 'Fn::Stringify', type: 'mapping' },
-  { short: 'Map', full: 'Fn::Map', type: 'sequence' },
-  { short: 'Length', full: 'Fn::Length', type: 'sequence' },
-  { short: 'Flatten', full: 'Fn::Flatten', type: 'sequence' },
-  { short: 'FlattenDeep', full: 'Fn::FlattenDeep', type: 'sequence' },
-  { short: 'Uniq', full: 'Fn::Uniq', type: 'sequence' },
-  { short: 'GetEnv', full: 'Fn::GetEnv', type: 'sequence' },
-  { short: 'GetEnv', full: 'Fn::GetEnv', type: 'scalar' },
-  { short: 'Merge', full: 'Fn::Merge', type: 'sequence' },
-  { short: 'Outputs', full: 'Fn::Outputs', type: 'mapping' },
-  { short: 'LowerCamelCase', full: 'Fn::LowerCamelCase', type: 'scalar' },
-  { short: 'UpperCamelCase', full: 'Fn::UpperCamelCase', type: 'scalar' },
-  { short: 'Sequence', full: 'Fn::Sequence', type: 'sequence' },
-  { short: 'DeepMerge', full: 'Fn::DeepMerge', type: 'sequence' },
-  { short: 'Compact', full: 'Fn::Compact', type: 'sequence' },
-  { short: 'Concat', full: 'Fn::Concat', type: 'sequence' },
-  { short: 'Sort', full: 'Fn::Sort', type: 'sequence' },
-  { short: 'SortedUniq', full: 'Fn::SortedUniq', type: 'sequence' },
-  { short: 'SortBy', full: 'Fn::SortBy', type: 'mapping' },
-  { short: 'SortObject', full: 'Fn::SortObject', type: 'mapping' },
-  { short: 'ObjectKeys', full: 'Fn::ObjectKeys', type: 'sequence' },
-  { short: 'ObjectValues', full: 'Fn::ObjectValues', type: 'sequence' },
-  { short: 'Filenames', full: 'Fn::Filenames', type: 'sequence' },
-  { short: 'Without', full: 'Fn::Without', type: 'sequence' },
-  { short: 'Omit', full: 'Fn::Omit', type: 'sequence' },
-  { short: 'Omit', full: 'Fn::Omit', type: 'mapping' },
-  { short: 'OmitEmpty', full: 'Fn::OmitEmpty', type: 'mapping' },
-  { short: 'Eval', full: 'Fn::Eval', type: 'sequence' },
-  { short: 'IfEval', full: 'Fn::IfEval', type: 'mapping' },
-  { short: 'JoinNow', full: 'Fn::JoinNow', type: 'scalar' },
-  { short: 'SubNow', full: 'Fn::SubNow', type: 'scalar' },
-  { short: 'SubNow', full: 'Fn::SubNow', type: 'sequence' },
-  { short: 'RefNow', full: 'Fn::RefNow', type: 'scalar' },
-  { short: 'ApplyTags', full: 'Fn::ApplyTags', type: 'mapping' },
-
-  // http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/intrinsic-function-reference.html
-  { short: 'Base64', full: 'Fn::Base64', type: 'scalar' },
-  { short: 'Base64', full: 'Fn::Base64', type: 'mapping' },
-  { short: 'FindInMap', full: 'Fn::FindInMap', type: 'sequence' },
-  { short: 'GetAtt', full: 'Fn::GetAtt', type: 'sequence' },
-  { short: 'GetAtt', full: 'Fn::GetAtt', type: 'scalar', dotSyntax: true },
-  { short: 'GetAZs', full: 'Fn::GetAZs', type: 'sequence' },
-  { short: 'GetAZs', full: 'Fn::GetAZs', type: 'scalar' },
-  { short: 'ImportValue', full: 'Fn::ImportValue', type: 'scalar' },
-  { short: 'ImportValue', full: 'Fn::ImportValue', type: 'mapping' },
-  { short: 'Join', full: 'Fn::Join', type: 'sequence' },
-  { short: 'Select', full: 'Fn::Select', type: 'sequence' },
-  { short: 'Sub', full: 'Fn::Sub', type: 'sequence' },
-  { short: 'Sub', full: 'Fn::Sub', type: 'mapping' },
-  { short: 'Sub', full: 'Fn::Sub', type: 'scalar' },
-  { short: 'Split', full: 'Fn::Split', type: 'sequence' },
-  { short: 'Ref', full: 'Ref', type: 'scalar' },
-  { short: 'Cidr', full: 'Fn::Cidr', type: 'sequence' },
-  { short: 'Cidr', full: 'Fn::Cidr', type: 'mapping' },
-  // http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/continuous-delivery-codepipeline-action-reference.html
-  { short: 'GetParam', full: 'Fn::GetParam', type: 'sequence' },
-  // http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/intrinsic-function-reference-conditions.html
-  { short: 'And', full: 'Fn::And', type: 'sequence' },
-  { short: 'Equals', full: 'Fn::Equals', type: 'sequence' },
-  { short: 'If', full: 'Fn::If', type: 'sequence' },
-  { short: 'Not', full: 'Fn::Not', type: 'sequence' },
-  { short: 'Or', full: 'Fn::Or', type: 'sequence' },
-  { short: 'Condition', full: 'Condition', type: 'scalar' },
-].map(function (fn) {
-  return new yaml.Type('!' + fn.short, {
-    kind: fn.type,
-    construct: function (obj) {
-      if (fn.dotSyntax && _.isString(obj)) {
-        const indexOfDot = obj.indexOf('.');
-        if (indexOfDot !== -1) obj = [obj.substr(0, indexOfDot), obj.substr(indexOfDot + 1)];
-        else obj = [obj];
-      }
-      return _.fromPairs([[fn.full, obj]]);
-    },
-  });
-});
-
-// build array of strings of all Amazon Intrinsic functions
-const BANG_AMAZON_FUNCS = [
-  'Base64',
-  'FindInMap',
-  'GetAtt',
-  'GetAZs',
-  'ImportValue',
-  'Join',
-  'Select',
-  'Split',
-  'Sub',
-  'Ref',
-  'Cidr',
-  'GetParam',
-  'And',
-  'Equals',
-  'If',
-  'Not',
-  'Or',
-  'Condition',
-];
-
-const EXPLICIT_AMAZON_FUNCS = BANG_AMAZON_FUNCS.map((f) => `Fn::${f}`);
-
-const yamlSchema = yaml.DEFAULT_SCHEMA.extend(tags);
-
-// Test the function key to make sure it's something
-// we should process.
-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

@@ -1,52 +0,0 @@
-/**
- * Scope helper functions for lazy prototype-chain based scope management.
- *
- * Instead of _.clone(scope) which copies O(n) properties each time,
- * we use Object.create(scope) which creates a child scope in O(1) time
- * that inherits from the parent via the prototype chain.
- */
-
-/**
- * Create a child scope that inherits from the parent.
- * Uses Object.create() for O(1) creation instead of cloning.
- *
- * @param {Object} parent - The parent scope to inherit from
- * @param {Object} [additions={}] - Properties to add to the child scope
- * @returns {Object} A new child scope with prototype chain to parent
- */
-export function createChildScope(parent, additions = {}) {
-  const child = Object.create(parent);
-  Object.assign(child, additions);
-  return child;
-}
-
-/**
- * Convert a prototype-chain scope to a plain object.
- * Uses for...in to walk the entire prototype chain.
- *
- * Useful when we need to pass scope to functions that don't
- * walk the prototype chain (e.g., Object.keys, _.forEach).
- *
- * @param {Object} scope - The scope to flatten
- * @returns {Object} A plain object with all inherited properties
- */
-export function scopeToObject(scope) {
-  const result = {};
-  for (const key in scope) {
-    result[key] = scope[key];
-  }
-  return result;
-}
-
-/**
- * Iterate over all properties in a scope, including inherited ones.
- * This is a replacement for _.forEach that walks the prototype chain.
- *
- * @param {Object} scope - The scope to iterate over
- * @param {Function} callback - Function to call with (value, key)
- */
-export function forEachInScope(scope, callback) {
-  for (const key in scope) {
-    callback(scope[key], key);
-  }
-}

package/lib/utils.js

@@ -1,16 +0,0 @@
-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('');
-}
-
-function lowerCamelCase(str) {
-  const upper = upperCamelCase(str);
-  return upper.charAt(0).toLowerCase() + upper.slice(1);
-}
-
-export { lowerCamelCase, upperCamelCase };