prismatica 0.2.0

package/node_modules/execa/types/stdio/type.d.ts

@@ -0,0 +1,170 @@
+import type {Readable, Writable} from 'node:stream';
+import type {ReadableStream, WritableStream, TransformStream} from 'node:stream/web';
+import type {
+	Not,
+	And,
+	Or,
+	Unless,
+	AndUnless,
+} from '../utils.js';
+import type {
+	GeneratorTransform,
+	GeneratorTransformFull,
+	DuplexTransform,
+	WebTransform,
+} from '../transform/normalize.js';
+
+type IsStandardStream<FdNumber extends string> = FdNumber extends keyof StandardStreams ? true : false;
+
+export type StandardStreams = readonly ['stdin', 'stdout', 'stderr'];
+
+// When `options.stdin|stdout|stderr|stdio` is set to one of those values, no stream is created
+export type NoStreamStdioOption<FdNumber extends string> =
+	| 'ignore'
+	| 'inherit'
+	| 'ipc'
+	| number
+	| Readable
+	| Writable
+	| Unless<IsStandardStream<FdNumber>, undefined>
+	| readonly [NoStreamStdioOption<FdNumber>];
+
+// `options.stdio` when it is not an array
+type SimpleStdioOption<
+	IsSync extends boolean,
+	IsExtra extends boolean,
+	IsArray extends boolean,
+> =
+	| undefined
+	| 'pipe'
+	| Unless<And<And<Not<IsSync>, IsArray>, IsExtra>, 'inherit'>
+	| Unless<IsArray, 'ignore'>
+	| Unless<IsSync, 'overlapped'>;
+
+// Values available in both `options.stdin|stdio` and `options.stdout|stderr|stdio`
+type CommonStdioOption<
+	IsSync extends boolean,
+	IsExtra extends boolean,
+	IsArray extends boolean,
+> =
+	| SimpleStdioOption<IsSync, IsExtra, IsArray>
+	| URL
+	| {readonly file: string; readonly append?: boolean}
+	| GeneratorTransform<IsSync>
+	| GeneratorTransformFull<IsSync>
+	| Unless<And<Not<IsSync>, IsArray>, 3 | 4 | 5 | 6 | 7 | 8 | 9>
+	| Unless<Or<IsSync, IsArray>, 'ipc'>
+	| Unless<IsSync, DuplexTransform | WebTransform | TransformStream>;
+
+// Synchronous iterables excluding strings, Uint8Arrays and Arrays
+type IterableObject<IsArray extends boolean> = Iterable<unknown>
+& object
+& {readonly BYTES_PER_ELEMENT?: never}
+& AndUnless<IsArray, {readonly lastIndexOf?: never}>;
+
+// `process.stdin|stdout|stderr` are `Duplex` with a `fd` property.
+// This ensures they can only be passed to `stdin`/`stdout`/`stderr`, based on their direction.
+type ProcessStdinFd = {readonly fd?: 0};
+type ProcessStdoutStderrFd = {readonly fd?: 1 | 2};
+
+// Values available only in `options.stdin|stdio`
+export type InputStdioOption<
+	IsSync extends boolean = boolean,
+	IsExtra extends boolean = boolean,
+	IsArray extends boolean = boolean,
+> =
+	| 0
+	| Unless<And<IsSync, IsExtra>, Uint8Array | IterableObject<IsArray>>
+	| Unless<And<IsSync, IsArray>, Readable & ProcessStdinFd>
+	| Unless<IsSync, (AsyncIterable<unknown> & ProcessStdinFd) | ReadableStream>;
+
+// Values available only in `options.stdout|stderr|stdio`
+type OutputStdioOption<
+	IsSync extends boolean,
+	IsArray extends boolean,
+> =
+	| 1
+	| 2
+	| Unless<And<IsSync, IsArray>, Writable & ProcessStdoutStderrFd>
+	| Unless<IsSync, WritableStream>;
+
+// `options.stdin` array items
+type StdinSingleOption<
+	IsSync extends boolean,
+	IsExtra extends boolean,
+	IsArray extends boolean,
+> =
+	| CommonStdioOption<IsSync, IsExtra, IsArray>
+	| InputStdioOption<IsSync, IsExtra, IsArray>;
+
+// `options.stdin`
+export type StdinOptionCommon<
+	IsSync extends boolean = boolean,
+	IsExtra extends boolean = boolean,
+> =
+	| StdinSingleOption<IsSync, IsExtra, false>
+	| ReadonlyArray<StdinSingleOption<IsSync, IsExtra, true>>;
+
+// `options.stdin`, async
+export type StdinOption = StdinOptionCommon<false, false>;
+// `options.stdin`, sync
+export type StdinSyncOption = StdinOptionCommon<true, false>;
+
+// `options.stdout|stderr` array items
+type StdoutStderrSingleOption<
+	IsSync extends boolean,
+	IsExtra extends boolean,
+	IsArray extends boolean,
+> =
+  | CommonStdioOption<IsSync, IsExtra, IsArray>
+  | OutputStdioOption<IsSync, IsArray>;
+
+// `options.stdout|stderr`
+export type StdoutStderrOptionCommon<
+	IsSync extends boolean = boolean,
+	IsExtra extends boolean = boolean,
+> =
+	| StdoutStderrSingleOption<IsSync, IsExtra, false>
+	| ReadonlyArray<StdoutStderrSingleOption<IsSync, IsExtra, true>>;
+
+// `options.stdout|stderr`, async
+export type StdoutStderrOption = StdoutStderrOptionCommon<false, false>;
+// `options.stdout|stderr`, sync
+export type StdoutStderrSyncOption = StdoutStderrOptionCommon<true, false>;
+
+// `options.stdio[3+]`
+type StdioExtraOptionCommon<IsSync extends boolean> =
+	| StdinOptionCommon<IsSync, true>
+	| StdoutStderrOptionCommon<IsSync, true>;
+
+// `options.stdin|stdout|stderr|stdio` array items
+type StdioSingleOption<
+	IsSync extends boolean = boolean,
+	IsExtra extends boolean = boolean,
+	IsArray extends boolean = boolean,
+> =
+	| StdinSingleOption<IsSync, IsExtra, IsArray>
+	| StdoutStderrSingleOption<IsSync, IsExtra, IsArray>;
+
+// Get `options.stdin|stdout|stderr|stdio` items if it is an array, else keep as is
+export type StdioSingleOptionItems<StdioOptionType> = StdioOptionType extends readonly StdioSingleOption[]
+	? StdioOptionType[number]
+	: StdioOptionType;
+
+// `options.stdin|stdout|stderr|stdio`
+export type StdioOptionCommon<IsSync extends boolean = boolean> =
+	| StdinOptionCommon<IsSync>
+	| StdoutStderrOptionCommon<IsSync>;
+
+// `options.stdio` when it is an array
+export type StdioOptionsArray<IsSync extends boolean = boolean> = readonly [
+	StdinOptionCommon<IsSync, false>,
+	StdoutStderrOptionCommon<IsSync, false>,
+	StdoutStderrOptionCommon<IsSync, false>,
+	...ReadonlyArray<StdioExtraOptionCommon<IsSync>>,
+];
+
+// `options.stdio`
+export type StdioOptionsProperty<IsSync extends boolean = boolean> =
+	| SimpleStdioOption<IsSync, false, false>
+	| StdioOptionsArray<IsSync>;

package/node_modules/execa/types/subprocess/all.d.ts

@@ -0,0 +1,17 @@
+import type {Readable} from 'node:stream';
+import type {IgnoresSubprocessOutput} from '../return/ignore.js';
+import type {Options} from '../arguments/options.js';
+
+// `subprocess.all`
+export type SubprocessAll<OptionsType extends Options> = AllStream<AllIgnored<OptionsType['all'], OptionsType>>;
+
+type AllStream<IsIgnored> = IsIgnored extends true ? undefined : Readable;
+
+type AllIgnored<
+	AllOption,
+	OptionsType extends Options,
+> = AllOption extends true
+	? IgnoresSubprocessOutput<'1', OptionsType> extends true
+		? IgnoresSubprocessOutput<'2', OptionsType>
+		: false
+	: true;

package/node_modules/execa/types/subprocess/stdio.d.ts

@@ -0,0 +1,18 @@
+import type {StdioOptionNormalizedArray} from '../stdio/array.js';
+import type {Options} from '../arguments/options.js';
+import type {SubprocessStdioStream} from './stdout.js';
+
+// `subprocess.stdio`
+export type SubprocessStdioArray<OptionsType extends Options> = MapStdioStreams<StdioOptionNormalizedArray<OptionsType>, OptionsType>;
+
+// We cannot use mapped types because it must be compatible with Node.js `ChildProcess["stdio"]` which uses a tuple with exactly 5 items
+type MapStdioStreams<
+	StdioOptionsArrayType,
+	OptionsType extends Options,
+> = [
+	SubprocessStdioStream<'0', OptionsType>,
+	SubprocessStdioStream<'1', OptionsType>,
+	SubprocessStdioStream<'2', OptionsType>,
+	'3' extends keyof StdioOptionsArrayType ? SubprocessStdioStream<'3', OptionsType> : never,
+	'4' extends keyof StdioOptionsArrayType ? SubprocessStdioStream<'4', OptionsType> : never,
+];

package/node_modules/execa/types/subprocess/stdout.d.ts

@@ -0,0 +1,22 @@
+import type {Readable, Writable} from 'node:stream';
+import type {IsInputFd} from '../stdio/direction.js';
+import type {IgnoresSubprocessOutput} from '../return/ignore.js';
+import type {Options} from '../arguments/options.js';
+
+// `subprocess.stdin|stdout|stderr|stdio`
+export type SubprocessStdioStream<
+	FdNumber extends string,
+	OptionsType extends Options,
+> = SubprocessStream<FdNumber, IgnoresSubprocessOutput<FdNumber, OptionsType>, OptionsType>;
+
+type SubprocessStream<
+	FdNumber extends string,
+	StreamResultIgnored,
+	OptionsType extends Options,
+> = StreamResultIgnored extends true
+	? null
+	: InputOutputStream<IsInputFd<FdNumber, OptionsType>>;
+
+type InputOutputStream<IsInput extends boolean> = IsInput extends true
+	? Writable
+	: Readable;

package/node_modules/execa/types/subprocess/subprocess.d.ts

@@ -0,0 +1,117 @@
+import type {ChildProcess} from 'node:child_process';
+import type {SignalConstants} from 'node:os';
+import type {Readable, Writable, Duplex} from 'node:stream';
+import type {Options} from '../arguments/options.js';
+import type {Result} from '../return/result.js';
+import type {PipableSubprocess} from '../pipe.js';
+import type {
+	ReadableOptions,
+	WritableOptions,
+	DuplexOptions,
+	SubprocessAsyncIterable,
+} from '../convert.js';
+import type {IpcMethods, HasIpc} from '../ipc.js';
+import type {SubprocessStdioStream} from './stdout.js';
+import type {SubprocessStdioArray} from './stdio.js';
+import type {SubprocessAll} from './all.js';
+
+type ExecaCustomSubprocess<OptionsType extends Options> = {
+	/**
+	Process identifier ([PID](https://en.wikipedia.org/wiki/Process_identifier)).
+
+	This is `undefined` if the subprocess failed to spawn.
+	*/
+	pid?: number;
+
+	/**
+	The subprocess [`stdin`](https://en.wikipedia.org/wiki/Standard_streams#Standard_input_(stdin)) as a stream.
+
+	This is `null` if the `stdin` option is set to `'inherit'`, `'ignore'`, `Readable` or `integer`.
+	*/
+	stdin: SubprocessStdioStream<'0', OptionsType>;
+
+	/**
+	The subprocess [`stdout`](https://en.wikipedia.org/wiki/Standard_streams#Standard_output_(stdout)) as a stream.
+
+	This is `null` if the `stdout` option is set to `'inherit'`, `'ignore'`, `Writable` or `integer`, or if the `buffer` option is `false`.
+	*/
+	stdout: SubprocessStdioStream<'1', OptionsType>;
+
+	/**
+	The subprocess [`stderr`](https://en.wikipedia.org/wiki/Standard_streams#Standard_error_(stderr)) as a stream.
+
+	This is `null` if the `stderr` option is set to `'inherit'`, `'ignore'`, `Writable` or `integer`, or if the `buffer` option is `false`.
+	*/
+	stderr: SubprocessStdioStream<'2', OptionsType>;
+
+	/**
+	Stream combining/interleaving `subprocess.stdout` and `subprocess.stderr`.
+
+	This requires the `all` option to be `true`.
+
+	This is `undefined` if `stdout` and `stderr` options are set to `'inherit'`, `'ignore'`, `Writable` or `integer`, or if the `buffer` option is `false`.
+	*/
+	all: SubprocessAll<OptionsType>;
+
+	/**
+	The subprocess `stdin`, `stdout`, `stderr` and other files descriptors as an array of streams.
+
+	Each array item is `null` if the corresponding `stdin`, `stdout`, `stderr` or `stdio` option is set to `'inherit'`, `'ignore'`, `Stream` or `integer`, or if the `buffer` option is `false`.
+	*/
+	stdio: SubprocessStdioArray<OptionsType>;
+
+	/**
+	Sends a [signal](https://nodejs.org/api/os.html#signal-constants) to the subprocess. The default signal is the `killSignal` option. `killSignal` defaults to `SIGTERM`, which terminates the subprocess.
+
+	This returns `false` when the signal could not be sent, for example when the subprocess has already exited.
+
+	When an error is passed as argument, it is set to the subprocess' `error.cause`. The subprocess is then terminated with the default signal. This does not emit the [`error` event](https://nodejs.org/api/child_process.html#event-error).
+
+	[More info.](https://nodejs.org/api/child_process.html#subprocesskillsignal)
+	*/
+	kill(signal?: keyof SignalConstants | number, error?: Error): boolean;
+	kill(error?: Error): boolean;
+
+	/**
+	Subprocesses are [async iterables](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol/asyncIterator). They iterate over each output line.
+	*/
+	[Symbol.asyncIterator](): SubprocessAsyncIterable<undefined, OptionsType['encoding']>;
+
+	/**
+	Same as `subprocess[Symbol.asyncIterator]` except options can be provided.
+	*/
+	iterable<IterableOptions extends ReadableOptions = {}>(readableOptions?: IterableOptions): SubprocessAsyncIterable<IterableOptions['binary'], OptionsType['encoding']>;
+
+	/**
+	Converts the subprocess to a readable stream.
+	*/
+	readable(readableOptions?: ReadableOptions): Readable;
+
+	/**
+	Converts the subprocess to a writable stream.
+	*/
+	writable(writableOptions?: WritableOptions): Writable;
+
+	/**
+	Converts the subprocess to a duplex stream.
+	*/
+	duplex(duplexOptions?: DuplexOptions): Duplex;
+}
+& IpcMethods<HasIpc<OptionsType>, OptionsType['serialization']>
+& PipableSubprocess;
+
+/**
+[`child_process` instance](https://nodejs.org/api/child_process.html#child_process_class_childprocess) with additional methods and properties.
+*/
+export type Subprocess<OptionsType extends Options = Options> =
+	& Omit<ChildProcess, keyof ExecaCustomSubprocess<OptionsType>>
+	& ExecaCustomSubprocess<OptionsType>;
+
+/**
+The return value of all asynchronous methods is both:
+- the subprocess.
+- a `Promise` either resolving with its successful `result`, or rejecting with its `error`.
+*/
+export type ResultPromise<OptionsType extends Options = Options> =
+	& Subprocess<OptionsType>
+	& Promise<Result<OptionsType>>;

package/node_modules/execa/types/transform/normalize.d.ts

@@ -0,0 +1,57 @@
+import type {TransformStream} from 'node:stream/web';
+import type {Duplex} from 'node:stream';
+import type {Unless} from '../utils.js';
+
+// `options.std*: Generator`
+// @todo Use `string`, `Uint8Array` or `unknown` for both the argument and the return type, based on whether `encoding: 'buffer'` and `objectMode: true` are used.
+// See https://github.com/sindresorhus/execa/issues/694
+export type GeneratorTransform<IsSync extends boolean> = (chunk: unknown) =>
+| Unless<IsSync, AsyncGenerator<unknown, void, void>>
+| Generator<unknown, void, void>;
+type GeneratorFinal<IsSync extends boolean> = () =>
+| Unless<IsSync, AsyncGenerator<unknown, void, void>>
+| Generator<unknown, void, void>;
+
+export type TransformCommon = {
+	/**
+	If `true`, allow `transformOptions.transform` and `transformOptions.final` to return any type, not just `string` or `Uint8Array`.
+	*/
+	readonly objectMode?: boolean;
+};
+
+/**
+A transform or an array of transforms can be passed to the `stdin`, `stdout`, `stderr` or `stdio` option.
+
+A transform is either a generator function or a plain object with the following members.
+*/
+export type GeneratorTransformFull<IsSync extends boolean> = {
+	/**
+	Map or filter the input or output of the subprocess.
+	*/
+	readonly transform: GeneratorTransform<IsSync>;
+
+	/**
+	Create additional lines after the last one.
+	*/
+	readonly final?: GeneratorFinal<IsSync>;
+
+	/**
+	If `true`, iterate over arbitrary chunks of `Uint8Array`s instead of line `string`s.
+	*/
+	readonly binary?: boolean;
+
+	/**
+	If `true`, keep newlines in each `line` argument. Also, this allows multiple `yield`s to produces a single line.
+	*/
+	readonly preserveNewlines?: boolean;
+} & TransformCommon;
+
+// `options.std*: Duplex`
+export type DuplexTransform = {
+	readonly transform: Duplex;
+} & TransformCommon;
+
+// `options.std*: TransformStream`
+export type WebTransform = {
+	readonly transform: TransformStream;
+} & TransformCommon;

package/node_modules/execa/types/transform/object-mode.d.ts

@@ -0,0 +1,21 @@
+import type {StdioSingleOptionItems} from '../stdio/type.js';
+import type {FdStdioOption} from '../stdio/option.js';
+import type {CommonOptions} from '../arguments/options.js';
+import type {DuplexTransform, TransformCommon} from './normalize.js';
+
+// Whether a file descriptor is in object mode
+// I.e. whether `result.stdout|stderr|stdio|all` is an array of `unknown` due to `objectMode: true`
+export type IsObjectFd<
+	FdNumber extends string,
+	OptionsType extends CommonOptions,
+> = IsObjectStdioOption<FdStdioOption<FdNumber, OptionsType>>;
+
+type IsObjectStdioOption<StdioOptionType> = IsObjectStdioSingleOption<StdioSingleOptionItems<StdioOptionType>>;
+
+type IsObjectStdioSingleOption<StdioSingleOptionType> = StdioSingleOptionType extends TransformCommon
+	? BooleanObjectMode<StdioSingleOptionType['objectMode']>
+	: StdioSingleOptionType extends DuplexTransform
+		? StdioSingleOptionType['transform']['readableObjectMode']
+		: false;
+
+type BooleanObjectMode<ObjectModeOption extends boolean | undefined> = ObjectModeOption extends true ? true : false;

package/node_modules/execa/types/utils.d.ts

@@ -0,0 +1,13 @@
+export type Not<Value extends boolean> = Value extends true ? false : true;
+
+export type And<First extends boolean, Second extends boolean> = First extends true ? Second : false;
+
+export type Or<First extends boolean, Second extends boolean> = First extends true ? true : Second;
+
+export type Unless<Condition extends boolean, ThenValue, ElseValue = never> = Condition extends true ? ElseValue : ThenValue;
+
+export type AndUnless<Condition extends boolean, ThenValue, ElseValue = unknown> = Condition extends true ? ElseValue : ThenValue;
+
+// Whether any of T's union element is the same as one of U's union element.
+// `&` does not work here.
+export type Intersects<T, U> = true extends (T extends U ? true : false) ? true : false;

package/node_modules/execa/types/verbose.d.ts

@@ -0,0 +1,98 @@
+import type {FdGenericOption} from './arguments/specific.js';
+import type {Options, SyncOptions} from './arguments/options.js';
+import type {Result, SyncResult} from './return/result.js';
+
+export type VerboseOption = FdGenericOption<
+| 'none'
+| 'short'
+| 'full'
+| VerboseFunction
+>;
+
+type VerboseFunction = (verboseLine: string, verboseObject: MinimalVerboseObject) => string | void;
+
+type GenericVerboseObject = {
+	/**
+	Event type. This can be:
+	- `'command'`: subprocess start
+	- `'output'`: `stdout`/`stderr` output
+	- `'ipc'`: IPC output
+	- `'error'`: subprocess failure
+	- `'duration'`: subprocess success or failure
+	*/
+	type: 'command' | 'output' | 'ipc' | 'error' | 'duration';
+
+	/**
+	Depending on `verboseObject.type`, this is:
+	- `'command'`: the `result.escapedCommand`
+	- `'output'`: one line from `result.stdout` or `result.stderr`
+	- `'ipc'`: one IPC message from `result.ipcOutput`
+	- `'error'`: the `error.shortMessage`
+	- `'duration'`: the `result.durationMs`
+	*/
+	message: string;
+
+	/**
+	The file and arguments that were run. This is the same as `result.escapedCommand`.
+	*/
+	escapedCommand: string;
+
+	/**
+	Serial number identifying the subprocess within the current process. It is incremented from `'0'`.
+
+	This is helpful when multiple subprocesses are running at the same time.
+
+	This is similar to a [PID](https://en.wikipedia.org/wiki/Process_identifier) except it has no maximum limit, which means it never repeats. Also, it is usually shorter.
+	*/
+	commandId: string;
+
+	/**
+	Event date/time.
+	*/
+	timestamp: Date;
+
+	/**
+	Whether another subprocess is piped into this subprocess. This is `false` when `result.pipedFrom` is empty.
+	*/
+	piped: boolean;
+};
+
+type MinimalVerboseObject = GenericVerboseObject & {
+	// We cannot use the `CommonOptions` type because it would make this type recursive
+	options: object;
+	result?: never;
+};
+
+/**
+Subprocess event object, for logging purpose, using the `verbose` option and `execa()`.
+*/
+export type VerboseObject = GenericVerboseObject & {
+	/**
+	The options passed to the subprocess.
+	*/
+	options: Options;
+
+	/**
+	Subprocess result.
+
+	This is `undefined` if `verboseObject.type` is `'command'`, `'output'` or `'ipc'`.
+	*/
+	result?: Result;
+};
+
+/**
+Subprocess event object, for logging purpose, using the `verbose` option and `execaSync()`.
+*/
+export type SyncVerboseObject = GenericVerboseObject & {
+	/**
+	The options passed to the subprocess.
+	*/
+	options: SyncOptions;
+
+	/**
+	Subprocess result.
+
+	This is `undefined` if `verboseObject.type` is `'command'`, `'output'` or `'ipc'`.
+	*/
+	result?: SyncResult;
+};

package/node_modules/extend-shallow/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014-2015, Jon Schlinkert.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/node_modules/extend-shallow/README.md

@@ -0,0 +1,61 @@
+# extend-shallow [![NPM version](https://badge.fury.io/js/extend-shallow.svg)](http://badge.fury.io/js/extend-shallow)  [![Build Status](https://travis-ci.org/jonschlinkert/extend-shallow.svg)](https://travis-ci.org/jonschlinkert/extend-shallow)
+
+> Extend an object with the properties of additional objects. node.js/javascript util.
+
+## Install
+
+Install with [npm](https://www.npmjs.com/)
+
+```sh
+$ npm i extend-shallow --save
+```
+
+## Usage
+
+```js
+var extend = require('extend-shallow');
+
+extend({a: 'b'}, {c: 'd'})
+//=> {a: 'b', c: 'd'}
+```
+
+Pass an empty object to shallow clone:
+
+```js
+var obj = {};
+extend(obj, {a: 'b'}, {c: 'd'})
+//=> {a: 'b', c: 'd'}
+```
+
+## Related
+
+* [extend-shallow](https://github.com/jonschlinkert/extend-shallow): Extend an object with the properties of additional objects. node.js/javascript util.
+* [for-own](https://github.com/jonschlinkert/for-own): Iterate over the own enumerable properties of an object, and return an object with properties… [more](https://github.com/jonschlinkert/for-own)
+* [for-in](https://github.com/jonschlinkert/for-in): Iterate over the own and inherited enumerable properties of an objecte, and return an object… [more](https://github.com/jonschlinkert/for-in)
+* [is-plain-object](https://github.com/jonschlinkert/is-plain-object): Returns true if an object was created by the `Object` constructor.
+* [isobject](https://github.com/jonschlinkert/isobject): Returns true if the value is an object and not an array or null.
+* [kind-of](https://github.com/jonschlinkert/kind-of): Get the native type of a value.
+
+## Running tests
+
+Install dev dependencies:
+
+```sh
+$ npm i -d && npm test
+```
+
+## Author
+
+**Jon Schlinkert**
+
++ [github/jonschlinkert](https://github.com/jonschlinkert)
++ [twitter/jonschlinkert](http://twitter.com/jonschlinkert)
+
+## License
+
+Copyright © 2015 Jon Schlinkert
+Released under the MIT license.
+
+***
+
+_This file was generated by [verb-cli](https://github.com/assemble/verb-cli) on June 29, 2015._

package/node_modules/extend-shallow/index.js

@@ -0,0 +1,33 @@
+'use strict';
+
+var isObject = require('is-extendable');
+
+module.exports = function extend(o/*, objects*/) {
+  if (!isObject(o)) { o = {}; }
+
+  var len = arguments.length;
+  for (var i = 1; i < len; i++) {
+    var obj = arguments[i];
+
+    if (isObject(obj)) {
+      assign(o, obj);
+    }
+  }
+  return o;
+};
+
+function assign(a, b) {
+  for (var key in b) {
+    if (hasOwn(b, key)) {
+      a[key] = b[key];
+    }
+  }
+}
+
+/**
+ * Returns true if the given `key` is an own property of `obj`.
+ */
+
+function hasOwn(obj, key) {
+  return Object.prototype.hasOwnProperty.call(obj, key);
+}