karajan-code 3.4.1 → 3.4.2

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

@@ -1,170 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

@@ -1,117 +0,0 @@
-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

@@ -1,57 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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

@@ -1,98 +0,0 @@
-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/expand-template/.travis.yml

@@ -1,6 +0,0 @@
-language: node_js
-
-node_js:
-  - 6
-  - 8
-  - 10

package/node_modules/expand-template/LICENSE

@@ -1,21 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2018 Lars-Magnus Skog
-
-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/expand-template/README.md

@@ -1,43 +0,0 @@
-# expand-template
-
-> Expand placeholders in a template string.
-
-[![npm](https://img.shields.io/npm/v/expand-template.svg)](https://www.npmjs.com/package/expand-template)
-![Node version](https://img.shields.io/node/v/expand-template.svg)
-[![Build Status](https://travis-ci.org/ralphtheninja/expand-template.svg?branch=master)](https://travis-ci.org/ralphtheninja/expand-template)
-[![JavaScript Style Guide](https://img.shields.io/badge/code_style-standard-brightgreen.svg)](https://standardjs.com)
-
-## Install
-
-```
-$ npm i expand-template -S
-```
-
-## Usage
-
-Default functionality expands templates using `{}` as separators for string placeholders.
-
-```js
-var expand = require('expand-template')()
-var template = '{foo}/{foo}/{bar}/{bar}'
-console.log(expand(template, {
-  foo: 'BAR',
-  bar: 'FOO'
-}))
-// -> BAR/BAR/FOO/FOO
-```
-
-Custom separators:
-
-```js
-var expand = require('expand-template')({ sep: '[]' })
-var template = '[foo]/[foo]/[bar]/[bar]'
-console.log(expand(template, {
-  foo: 'BAR',
-  bar: 'FOO'
-}))
-// -> BAR/BAR/FOO/FOO
-```
-
-## License
-All code, unless stated otherwise, is dual-licensed under [`WTFPL`](http://www.wtfpl.net/txt/copying/) and [`MIT`](https://opensource.org/licenses/MIT).

package/node_modules/expand-template/index.js

@@ -1,26 +0,0 @@
-module.exports = function (opts) {
-  var sep = opts ? opts.sep : '{}'
-  var len = sep.length
-
-  var whitespace = '\\s*'
-  var left = escape(sep.substring(0, len / 2)) + whitespace
-  var right = whitespace + escape(sep.substring(len / 2, len))
-
-  return function (template, values) {
-    Object.keys(values).forEach(function (key) {
-      var value = String(values[key]).replace(/\$/g, '$$$$')
-      template = template.replace(regExp(key), value)
-    })
-    return template
-  }
-
-  function escape (s) {
-    return [].map.call(s, function (char) {
-      return '\\' + char
-    }).join('')
-  }
-
-  function regExp (key) {
-    return new RegExp(left + key + right, 'g')
-  }
-}

package/node_modules/expand-template/package.json

@@ -1,29 +0,0 @@
-{
-  "name": "expand-template",
-  "version": "2.0.3",
-  "description": "Expand placeholders in a template string",
-  "main": "index.js",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/ralphtheninja/expand-template.git"
-  },
-  "homepage": "https://github.com/ralphtheninja/expand-template",
-  "scripts": {
-    "test": "tape test.js && standard"
-  },
-  "keywords": [
-    "template",
-    "expand",
-    "replace"
-  ],
-  "author": "LM <ralphtheninja@riseup.net>",
-  "license": "(MIT OR WTFPL)",
-  "dependencies": {},
-  "devDependencies": {
-    "standard": "^12.0.0",
-    "tape": "^4.2.2"
-  },
-  "engines": {
-    "node": ">=6"
-  }
-}