@farthershore/cli 0.3.10 → 0.3.12

package/node_modules/@pinojs/redact/README.md

@@ -1,350 +0,0 @@
-# @pinojs/redact
-
-> Smart object redaction for JavaScript applications - safe AND fast!
-
-Redact JS objects with the same API as [fast-redact](https://github.com/davidmarkclements/fast-redact), but uses innovative **selective cloning** instead of mutating the original. This provides immutability guarantees with **performance competitive** to fast-redact for real-world usage patterns.
-
-## Install
-
-```bash
-npm install @pinojs/redact
-```
-
-## Usage
-
-```js
-const slowRedact = require('@pinojs/redact')
-
-const redact = slowRedact({
-  paths: ['headers.cookie', 'headers.authorization', 'user.password']
-})
-
-const obj = {
-  headers: {
-    cookie: 'secret-session-token',
-    authorization: 'Bearer abc123',
-    'x-forwarded-for': '192.168.1.1'
-  },
-  user: {
-    name: 'john',
-    password: 'secret123'
-  }
-}
-
-console.log(redact(obj))
-// Output: {"headers":{"cookie":"[REDACTED]","authorization":"[REDACTED]","x-forwarded-for":"192.168.1.1"},"user":{"name":"john","password":"[REDACTED]"}}
-
-// Original object is completely unchanged:
-console.log(obj.headers.cookie) // 'secret-session-token'
-```
-
-## API
-
-### slowRedact(options) → Function
-
-Creates a redaction function with the specified options.
-
-#### Options
-
-- **paths** `string[]` (required): An array of strings describing the nested location of a key in an object
-- **censor** `any` (optional, default: `'[REDACTED]'`): The value to replace sensitive data with. Can be a static value or function.
-- **serialize** `Function|boolean` (optional, default: `JSON.stringify`): Serialization function. Set to `false` to return the redacted object.
-- **remove** `boolean` (optional, default: `false`): Remove redacted keys from serialized output
-- **strict** `boolean` (optional, default: `true`): Throw on non-object values or pass through primitives
-
-#### Path Syntax
-
-Supports the same path syntax as fast-redact:
-
-- **Dot notation**: `'user.name'`, `'headers.cookie'`
-- **Bracket notation**: `'user["password"]'`, `'headers["X-Forwarded-For"]'`
-- **Array indices**: `'users[0].password'`, `'items[1].secret'`
-- **Wildcards**:
-  - Terminal: `'users.*.password'` (redacts password for all users)
-  - Intermediate: `'*.password'` (redacts password at any level)
-  - Array wildcard: `'items.*'` (redacts all array elements)
-
-#### Examples
-
-**Custom censor value:**
-```js
-const redact = slowRedact({
-  paths: ['password'],
-  censor: '***HIDDEN***'
-})
-```
-
-**Dynamic censor function:**
-```js
-const redact = slowRedact({
-  paths: ['password'],
-  censor: (value, path) => `REDACTED:${path}`
-})
-```
-
-**Return object instead of JSON string:**
-```js
-const redact = slowRedact({
-  paths: ['secret'],
-  serialize: false
-})
-
-const result = redact({ secret: 'hidden', public: 'data' })
-console.log(result.secret) // '[REDACTED]'
-console.log(result.public) // 'data'
-
-// Restore original values
-const restored = result.restore()
-console.log(restored.secret) // 'hidden'
-```
-
-**Custom serialization:**
-```js
-const redact = slowRedact({
-  paths: ['password'],
-  serialize: obj => JSON.stringify(obj, null, 2)
-})
-```
-
-**Remove keys instead of redacting:**
-```js
-const redact = slowRedact({
-  paths: ['password', 'user.secret'],
-  remove: true
-})
-
-const obj = { username: 'john', password: 'secret123', user: { name: 'Jane', secret: 'hidden' } }
-console.log(redact(obj))
-// Output: {"username":"john","user":{"name":"Jane"}}
-// Note: 'password' and 'user.secret' are completely absent, not redacted
-```
-
-**Wildcard patterns:**
-```js
-// Redact all properties in secrets object
-const redact1 = slowRedact({ paths: ['secrets.*'] })
-
-// Redact password for any user
-const redact2 = slowRedact({ paths: ['users.*.password'] })
-
-// Redact all items in an array
-const redact3 = slowRedact({ paths: ['items.*'] })
-
-// Remove all secrets instead of redacting them
-const redact4 = slowRedact({ paths: ['secrets.*'], remove: true })
-```
-
-## Key Differences from fast-redact
-
-### Safety First
-- **No mutation**: Original objects are never modified
-- **Selective cloning**: Only clones paths that need redaction, shares references for everything else
-- **Restore capability**: Can restore original values when `serialize: false`
-
-### Feature Compatibility
-- **Remove option**: Full compatibility with fast-redact's `remove: true` option to completely omit keys from output
-- **All path patterns**: Supports same syntax including wildcards, bracket notation, and array indices
-- **Censor functions**: Dynamic censoring with path information passed as arrays
-- **Serialization**: Custom serializers and `serialize: false` mode
-
-### Smart Performance Approach
-- **Selective cloning**: Analyzes redaction paths and only clones necessary object branches
-- **Reference sharing**: Non-redacted properties maintain original object references
-- **Memory efficiency**: Dramatically reduced memory usage for large objects with minimal redaction
-- **Setup-time optimization**: Path analysis happens once during setup, not per redaction
-
-### When to Use @pinojs/redact
-- When immutability is critical
-- When you need to preserve original objects
-- When objects are shared across multiple contexts
-- In functional programming environments
-- When debugging and you need to compare before/after
-- **Large objects with selective redaction** (now performance-competitive!)
-- When memory efficiency with reference sharing is important
-
-### When to Use fast-redact
-- When absolute maximum performance is critical
-- In extremely high-throughput scenarios (>100,000 ops/sec)
-- When you control the object lifecycle and mutation is acceptable
-- Very small objects where setup overhead matters
-
-## Performance Benchmarks
-
-@pinojs/redact uses **selective cloning** that provides good performance while maintaining immutability guarantees:
-
-### Performance Results
-
-| Operation Type | @pinojs/redact | fast-redact | Performance Ratio |
-|---------------|-------------|-------------|-------------------|
-| **Small objects** | ~690ns | ~200ns | ~3.5x slower |
-| **Large objects (minimal redaction)** | **~18μs** | ~17μs | **~same performance** |
-| **Large objects (wildcards)** | **~48μs** | ~37μs | **~1.3x slower** |
-| **No redaction (large objects)** | **~18μs** | ~17μs | **~same performance** |
-
-### Performance Improvements
-
-@pinojs/redact is performance-competitive with fast-redact for large objects.
-
-1. **Selective cloning approach**: Only clones object paths that need redaction
-2. **Reference sharing**: Non-redacted properties share original object references
-3. **Setup-time optimization**: Path analysis happens once, not per redaction
-4. **Memory efficiency**: Dramatically reduced memory usage for typical use cases
-
-### Benchmark Details
-
-**Small Objects (~180 bytes)**:
-- @pinojs/redact: **690ns** per operation
-- fast-redact: **200ns** per operation
-- **Slight setup overhead for small objects**
-
-**Large Objects (~18KB, minimal redaction)**:
-- @pinojs/redact: **18μs** per operation
-- fast-redact: **17μs** per operation
-- Near-identical performance
-
-**Large Objects (~18KB, wildcard patterns)**:
-- @pinojs/redact: **48μs** per operation
-- fast-redact: **37μs** per operation
-- Competitive performance for complex patterns
-
-**Memory Considerations**:
-- @pinojs/redact: **Selective reference sharing** (much lower memory usage than before)
-- fast-redact: Mutates in-place (lowest memory usage)
-- Large objects with few redacted paths now share most references
-
-### When Performance Matters
-
-Choose **fast-redact** when:
-- Absolute maximum performance is critical (>100,000 ops/sec)
-- Working with very small objects frequently
-- Mutation is acceptable and controlled
-- Every microsecond counts
-
-Choose **@pinojs/redact** when:
-- Immutability is required (with competitive performance)
-- Objects are shared across contexts
-- Large objects with selective redaction
-- Memory efficiency through reference sharing is important
-- Safety and functionality are priorities
-- Most production applications (performance gap is minimal)
-
-Run benchmarks yourself:
-```bash
-npm run bench
-```
-
-## How Selective Cloning Works
-
-@pinojs/redact uses an innovative **selective cloning** approach that provides immutability guarantees while dramatically improving performance:
-
-### Traditional Approach (before optimization)
-```js
-// Old approach: Deep clone entire object, then redact
-const fullClone = deepClone(originalObject)  // Clone everything
-redact(fullClone, paths)                     // Then redact specific paths
-```
-
-### Selective Cloning Approach (current)
-```js
-// New approach: Analyze paths, clone only what's needed
-const pathStructure = buildPathStructure(paths)  // One-time setup
-const selectiveClone = cloneOnlyNeededPaths(obj, pathStructure)  // Smart cloning
-redact(selectiveClone, paths)  // Redact pre-identified paths
-```
-
-### Key Innovations
-
-1. **Path Analysis**: Pre-processes redaction paths into an efficient tree structure
-2. **Selective Cloning**: Only creates new objects for branches that contain redaction targets
-3. **Reference Sharing**: Non-redacted properties maintain exact same object references
-4. **Setup Optimization**: Path parsing happens once during redactor creation, not per redaction
-
-### Example: Reference Sharing in Action
-
-```js
-const largeConfig = {
-  database: { /* large config object */ },
-  api: { /* another large config */ },
-  secrets: { password: 'hidden', apiKey: 'secret' }
-}
-
-const redact = slowRedact({ paths: ['secrets.password'] })
-const result = redact(largeConfig)
-
-// Only secrets object is cloned, database and api share original references
-console.log(result.database === largeConfig.database)  // true - shared reference!
-console.log(result.api === largeConfig.api)            // true - shared reference!
-console.log(result.secrets === largeConfig.secrets)    // false - cloned for redaction
-```
-
-This approach provides **immutability where it matters** while **sharing references where it's safe**.
-
-## Remove Option
-
-The `remove: true` option provides full compatibility with fast-redact's key removal functionality:
-
-```js
-const redact = slowRedact({
-  paths: ['password', 'secrets.*', 'users.*.credentials'],
-  remove: true
-})
-
-const data = {
-  username: 'john',
-  password: 'secret123',
-  secrets: { apiKey: 'abc', token: 'xyz' },
-  users: [
-    { name: 'Alice', credentials: { password: 'pass1' } },
-    { name: 'Bob', credentials: { password: 'pass2' } }
-  ]
-}
-
-console.log(redact(data))
-// Output: {"username":"john","secrets":{},"users":[{"name":"Alice"},{"name":"Bob"}]}
-```
-
-### Remove vs Redact Behavior
-
-| Option | Behavior | Output Example |
-|--------|----------|----------------|
-| Default (redact) | Replaces values with censor | `{"password":"[REDACTED]"}` |
-| `remove: true` | Completely omits keys | `{}` |
-
-### Compatibility Notes
-
-- **Same output as fast-redact**: Identical JSON output when using `remove: true`
-- **Wildcard support**: Works with all wildcard patterns (`*`, `users.*`, `items.*.secret`)
-- **Array handling**: Array items are set to `undefined` (omitted in JSON output)
-- **Nested paths**: Supports deep removal (`users.*.credentials.password`)
-- **Serialize compatibility**: Only works with `JSON.stringify` serializer (like fast-redact)
-
-## Testing
-
-```bash
-# Run unit tests
-npm test
-
-# Run integration tests comparing with fast-redact
-npm run test:integration
-
-# Run all tests (unit + integration)
-npm run test:all
-
-# Run benchmarks
-npm run bench
-```
-
-### Test Coverage
-
-- **16 unit tests**: Core functionality and edge cases
-- **16 integration tests**: Output compatibility with fast-redact
-- **All major features**: Paths, wildcards, serialization, custom censors
-- **Performance benchmarks**: Direct comparison with fast-redact
-
-## License
-
-MIT
-
-## Contributing
-
-Pull requests welcome! Please ensure all tests pass and add tests for new features.

package/node_modules/@pinojs/redact/benchmarks/basic.js

@@ -1,184 +0,0 @@
-const { bench, group, run } = require('mitata')
-const slowRedact = require('../index.js')
-const fastRedact = require('fast-redact')
-
-// Test objects
-const smallObj = {
-  user: { name: 'john', password: 'secret123' },
-  headers: { cookie: 'session-token', authorization: 'Bearer abc123' }
-}
-
-const largeObj = {
-  users: [],
-  metadata: {
-    version: '1.0.0',
-    secret: 'app-secret-key',
-    database: {
-      host: 'localhost',
-      password: 'db-password'
-    }
-  }
-}
-
-// Populate users array with for loop instead of Array.from
-for (let i = 0; i < 100; i++) {
-  largeObj.users.push({
-    id: i,
-    name: `user${i}`,
-    email: `user${i}@example.com`,
-    password: `secret${i}`,
-    profile: {
-      age: 20 + (i % 50),
-      preferences: {
-        theme: 'dark',
-        notifications: true,
-        apiKey: `key-${i}-secret`
-      }
-    }
-  })
-}
-
-// Redaction configurations
-const basicSlowRedact = slowRedact({
-  paths: ['user.password', 'headers.cookie']
-})
-
-const basicFastRedact = fastRedact({
-  paths: ['user.password', 'headers.cookie']
-})
-
-const wildcardSlowRedact = slowRedact({
-  paths: ['users.*.password', 'users.*.profile.preferences.apiKey']
-})
-
-const wildcardFastRedact = fastRedact({
-  paths: ['users.*.password', 'users.*.profile.preferences.apiKey']
-})
-
-const deepSlowRedact = slowRedact({
-  paths: ['metadata.secret', 'metadata.database.password']
-})
-
-const deepFastRedact = fastRedact({
-  paths: ['metadata.secret', 'metadata.database.password']
-})
-
-group('Small Object Redaction - @pinojs/redact', () => {
-  bench('basic paths', () => {
-    basicSlowRedact(smallObj)
-  })
-
-  bench('serialize: false', () => {
-    const redact = slowRedact({
-      paths: ['user.password'],
-      serialize: false
-    })
-    redact(smallObj)
-  })
-
-  bench('custom censor function', () => {
-    const redact = slowRedact({
-      paths: ['user.password'],
-      censor: (value, path) => `HIDDEN:${path}`
-    })
-    redact(smallObj)
-  })
-})
-
-group('Small Object Redaction - fast-redact', () => {
-  bench('basic paths', () => {
-    basicFastRedact(smallObj)
-  })
-
-  bench('serialize: false', () => {
-    const redact = fastRedact({
-      paths: ['user.password'],
-      serialize: false
-    })
-    redact(smallObj)
-  })
-
-  bench('custom censor function', () => {
-    const redact = fastRedact({
-      paths: ['user.password'],
-      censor: (value, path) => `HIDDEN:${path}`
-    })
-    redact(smallObj)
-  })
-})
-
-group('Large Object Redaction - @pinojs/redact', () => {
-  bench('wildcard patterns', () => {
-    wildcardSlowRedact(largeObj)
-  })
-
-  bench('deep nested paths', () => {
-    deepSlowRedact(largeObj)
-  })
-
-  bench('multiple wildcards', () => {
-    const redact = slowRedact({
-      paths: ['users.*.password', 'users.*.profile.preferences.*']
-    })
-    redact(largeObj)
-  })
-})
-
-group('Large Object Redaction - fast-redact', () => {
-  bench('wildcard patterns', () => {
-    wildcardFastRedact(largeObj)
-  })
-
-  bench('deep nested paths', () => {
-    deepFastRedact(largeObj)
-  })
-
-  bench('multiple wildcards', () => {
-    const redact = fastRedact({
-      paths: ['users.*.password', 'users.*.profile.preferences.*']
-    })
-    redact(largeObj)
-  })
-})
-
-group('Direct Performance Comparison', () => {
-  bench('@pinojs/redact - basic paths', () => {
-    basicSlowRedact(smallObj)
-  })
-
-  bench('fast-redact - basic paths', () => {
-    basicFastRedact(smallObj)
-  })
-
-  bench('@pinojs/redact - wildcards', () => {
-    wildcardSlowRedact(largeObj)
-  })
-
-  bench('fast-redact - wildcards', () => {
-    wildcardFastRedact(largeObj)
-  })
-})
-
-group('Object Cloning Overhead', () => {
-  bench('@pinojs/redact - no redaction (clone only)', () => {
-    const redact = slowRedact({ paths: [] })
-    redact(smallObj)
-  })
-
-  bench('fast-redact - no redaction', () => {
-    const redact = fastRedact({ paths: [] })
-    redact(smallObj)
-  })
-
-  bench('@pinojs/redact - large object clone', () => {
-    const redact = slowRedact({ paths: [] })
-    redact(largeObj)
-  })
-
-  bench('fast-redact - large object', () => {
-    const redact = fastRedact({ paths: [] })
-    redact(largeObj)
-  })
-})
-
-run()

package/node_modules/@pinojs/redact/eslint.config.js

@@ -1 +0,0 @@
-module.exports = require('neostandard')()

package/node_modules/@pinojs/redact/index.d.ts

@@ -1,52 +0,0 @@
-export = F;
-
-/**
- * When called without any options, or with a zero length paths array, @pinojs/redact will return JSON.stringify or the serialize option, if set.
- * @param redactOptions
- * @param redactOptions.paths An array of strings describing the nested location of a key in an object.
- * @param redactOptions.censor This is the value which overwrites redacted properties.
- * @param redactOptions.remove The remove option, when set to true will cause keys to be removed from the serialized output.
- * @param redactOptions.serialize The serialize option may either be a function or a boolean. If a function is supplied, this will be used to serialize the redacted object.
- * @param redactOptions.strict The strict option, when set to true, will cause the redactor function to throw if instead of an object it finds a primitive.
- * @returns Redacted value from input
- */
-declare function F(
-  redactOptions: F.RedactOptionsNoSerialize
-): F.redactFnNoSerialize;
-declare function F(redactOptions?: F.RedactOptions): F.redactFn;
-
-declare namespace F {
-  /** Redacts input */
-  type redactFn = <T>(input: T) => string | T;
-
-  /** Redacts input without serialization */
-  type redactFnNoSerialize = redactFn & {
-    /** Method that allowing the redacted keys to be restored with the original data. Supplied only when serialize option set to false. */
-    restore<T>(input: T): T;
-  };
-
-  interface RedactOptions {
-    /** An array of strings describing the nested location of a key in an object. */
-    paths?: string[] | undefined;
-
-    /** This is the value which overwrites redacted properties. */
-    censor?: string | ((v: any) => any) | undefined;
-
-    /** The remove option, when set to true will cause keys to be removed from the serialized output. */
-    remove?: boolean | undefined;
-
-    /**
-     * The serialize option may either be a function or a boolean. If a function is supplied, this will be used to serialize the redacted object.
-     * The default serialize is the function JSON.stringify
-     */
-    serialize?: boolean | ((v: any) => any) | undefined;
-
-    /** The strict option, when set to true, will cause the redactor function to throw if instead of an object it finds a primitive. */
-    strict?: boolean | undefined;
-  }
-
-  /** RedactOptions without serialization. Instead of the serialized object, the output of the redactor function will be the mutated object itself. */
-  interface RedactOptionsNoSerialize extends RedactOptions {
-    serialize: false;
-  }
-}