diff --git a/.npmignore b/.npmignore new file mode 100644 index 0000000..d6448e4 --- /dev/null +++ b/.npmignore @@ -0,0 +1,5 @@ +examples +definitions +lib +gulpfile.js +tslint.json \ No newline at end of file diff --git a/bin.js b/bin.js new file mode 100644 index 0000000..46cf207 --- /dev/null +++ b/bin.js @@ -0,0 +1,2 @@ +#!/usr/bin/env node +require('./release/bin'); diff --git a/definitions/bluebird.d.ts b/definitions/bluebird.d.ts new file mode 100644 index 0000000..8912ebb --- /dev/null +++ b/definitions/bluebird.d.ts @@ -0,0 +1,670 @@ +// Type definitions for bluebird 1.0.0 +// Project: https://github.com/petkaantonov/bluebird +// Definitions by: Bart van der Schoor +// Definitions: https://github.com/borisyankov/DefinitelyTyped + +// ES6 model with generics overload was sourced and trans-multiplied from es6-promises.d.ts +// By: Campredon + +// Warning: recommended to use `tsc > v0.9.7` (critical bugs in earlier generic code): +// - https://github.com/borisyankov/DefinitelyTyped/issues/1563 + +// Note: replicate changes to all overloads in both definition and test file +// Note: keep both static and instance members inline (so similar) + +// TODO fix remaining TODO annotations in both definition and test + +// TODO verify support to have no return statement in handlers to get a Promise (more overloads?) + +declare class Promise implements Promise.Thenable { + /** + * Create a new promise. The passed in function will receive functions `resolve` and `reject` as its arguments which can be called to seal the fate of the created promise. + */ + constructor(callback: (resolve: (thenable: Promise.Thenable) => void, reject: (error: any) => void) => void); + constructor(callback: (resolve: (result: R) => void, reject: (error: any) => void) => void); + + /** + * Promises/A+ `.then()` with progress handler. Returns a new promise chained from this promise. The new promise will be rejected or resolved dedefer on the passed `fulfilledHandler`, `rejectedHandler` and the state of this promise. + */ + then(onFulfill: (value: R) => Promise.Thenable, onReject: (error: any) => Promise.Thenable, onProgress?: (note: any) => any): Promise; + then(onFulfill: (value: R) => Promise.Thenable, onReject?: (error: any) => U, onProgress?: (note: any) => any): Promise; + then(onFulfill: (value: R) => U, onReject: (error: any) => Promise.Thenable, onProgress?: (note: any) => any): Promise; + then(onFulfill?: (value: R) => U, onReject?: (error: any) => U, onProgress?: (note: any) => any): Promise; + + /** + * This is a catch-all exception handler, shortcut for calling `.then(null, handler)` on this promise. Any exception happening in a `.then`-chain will propagate to nearest `.catch` handler. + * + * Alias `.caught();` for compatibility with earlier ECMAScript version. + */ + catch(onReject?: (error: any) => Promise.Thenable): Promise; + caught(onReject?: (error: any) => Promise.Thenable): Promise; + + catch(onReject?: (error: any) => U): Promise; + caught(onReject?: (error: any) => U): Promise; + + /** + * This extends `.catch` to work more like catch-clauses in languages like Java or C#. Instead of manually checking `instanceof` or `.name === "SomeError"`, you may specify a number of error constructors which are eligible for this catch handler. The catch handler that is first met that has eligible constructors specified, is the one that will be called. + * + * This method also supports predicate-based filters. If you pass a predicate function instead of an error constructor, the predicate will receive the error as an argument. The return result of the predicate will be used determine whether the error handler should be called. + * + * Alias `.caught();` for compatibility with earlier ECMAScript version. + */ + catch(predicate: (error: any) => boolean, onReject: (error: any) => Promise.Thenable): Promise; + caught(predicate: (error: any) => boolean, onReject: (error: any) => Promise.Thenable): Promise; + + catch(predicate: (error: any) => boolean, onReject: (error: any) => U): Promise; + caught(predicate: (error: any) => boolean, onReject: (error: any) => U): Promise; + + catch(ErrorClass: Function, onReject: (error: any) => Promise.Thenable): Promise; + caught(ErrorClass: Function, onReject: (error: any) => Promise.Thenable): Promise; + + catch(ErrorClass: Function, onReject: (error: any) => U): Promise; + caught(ErrorClass: Function, onReject: (error: any) => U): Promise; + + /** + * Like `.catch` but instead of catching all types of exceptions, it only catches those that don't originate from thrown errors but rather from explicit rejections. + */ + error(onReject: (reason: any) => Promise.Thenable): Promise; + error(onReject: (reason: any) => U): Promise; + + /** + * Pass a handler that will be called regardless of this promise's fate. Returns a new promise chained from this promise. There are special semantics for `.finally()` in that the final value cannot be modified from the handler. + * + * Alias `.lastly();` for compatibility with earlier ECMAScript version. + */ + finally(handler: (value: R) => Promise.Thenable): Promise; + finally(handler: (value: R) => R): Promise; + finally(handler: (value: R) => void): Promise; + + lastly(handler: (value: R) => Promise.Thenable): Promise; + lastly(handler: (value: R) => R): Promise; + lastly(handler: (value: R) => void): Promise; + + /** + * Create a promise that follows this promise, but is bound to the given `thisArg` value. A bound promise will call its handlers with the bound value set to `this`. Additionally promises derived from a bound promise will also be bound promises with the same `thisArg` binding as the original promise. + */ + bind(thisArg: any): Promise; + + /** + * Like `.then()`, but any unhandled rejection that ends up here will be thrown as an error. + */ + done(onFulfilled: (value: R) => Promise.Thenable, onRejected: (error: any) => Promise.Thenable, onProgress?: (note: any) => any): Promise; + done(onFulfilled: (value: R) => Promise.Thenable, onRejected?: (error: any) => U, onProgress?: (note: any) => any): Promise; + done(onFulfilled: (value: R) => U, onRejected: (error: any) => Promise.Thenable, onProgress?: (note: any) => any): Promise; + done(onFulfilled?: (value: R) => U, onRejected?: (error: any) => U, onProgress?: (note: any) => any): Promise; + + /** + * Shorthand for `.then(null, null, handler);`. Attach a progress handler that will be called if this promise is progressed. Returns a new promise chained from this promise. + */ + progressed(handler: (note: any) => any): Promise; + + /** + * Same as calling `Promise.delay(this, ms)`. With the exception that if this promise is bound to a value, the returned promise is bound to that value too. + */ + delay(ms: number): Promise; + + /** + * Returns a promise that will be fulfilled with this promise's fulfillment value or rejection reason. However, if this promise is not fulfilled or rejected within `ms` milliseconds, the returned promise is rejected with a `Promise.TimeoutError` instance. + * + * You may specify a custom error message with the `message` parameter. + */ + timeout(ms: number, message?: string): Promise; + + /** + * Register a node-style callback on this promise. When this promise is is either fulfilled or rejected, the node callback will be called back with the node.js convention where error reason is the first argument and success value is the second argument. The error argument will be `null` in case of success. + * Returns back this promise instead of creating a new one. If the `callback` argument is not a function, this method does not do anything. + */ + nodeify(callback: (err: any, value?: R) => void): Promise; + nodeify(...sink: any[]): void; + + /** + * Marks this promise as cancellable. Promises by default are not cancellable after v0.11 and must be marked as such for `.cancel()` to have any effect. Marking a promise as cancellable is infectious and you don't need to remark any descendant promise. + */ + cancellable(): Promise; + + /** + * Cancel this promise. The cancellation will propagate to farthest cancellable ancestor promise which is still pending. + * + * That ancestor will then be rejected with a `CancellationError` (get a reference from `Promise.CancellationError`) object as the rejection reason. + * + * In a promise rejection handler you may check for a cancellation by seeing if the reason object has `.name === "Cancel"`. + * + * Promises are by default not cancellable. Use `.cancellable()` to mark a promise as cancellable. + */ + // TODO what to do with this? + cancel(): Promise; + + /** + * Like `.then()`, but cancellation of the the returned promise or any of its descendant will not propagate cancellation to this promise or this promise's ancestors. + */ + fork(onFulfilled: (value: R) => Promise.Thenable, onRejected: (error: any) => Promise.Thenable, onProgress?: (note: any) => any): Promise; + fork(onFulfilled: (value: R) => Promise.Thenable, onRejected?: (error: any) => U, onProgress?: (note: any) => any): Promise; + fork(onFulfilled: (value: R) => U, onRejected: (error: any) => Promise.Thenable, onProgress?: (note: any) => any): Promise; + fork(onFulfilled?: (value: R) => U, onRejected?: (error: any) => U, onProgress?: (note: any) => any): Promise; + + /** + * Create an uncancellable promise based on this promise. + */ + uncancellable(): Promise; + + /** + * See if this promise can be cancelled. + */ + isCancellable(): boolean; + + /** + * See if this `promise` has been fulfilled. + */ + isFulfilled(): boolean; + + /** + * See if this `promise` has been rejected. + */ + isRejected(): boolean; + + /** + * See if this `promise` is still defer. + */ + isPending(): boolean; + + /** + * See if this `promise` is resolved -> either fulfilled or rejected. + */ + isResolved(): boolean; + + /** + * Synchronously inspect the state of this `promise`. The `PromiseInspection` will represent the state of the promise as snapshotted at the time of calling `.inspect()`. + */ + inspect(): Promise.Inspection; + + /** + * This is a convenience method for doing: + * + * + * promise.then(function(obj){ + * return obj[propertyName].call(obj, arg...); + * }); + * + */ + call(propertyName: string, ...args: any[]): Promise; + + /** + * This is a convenience method for doing: + * + * + * promise.then(function(obj){ + * return obj[propertyName]; + * }); + * + */ + // TODO find way to fix get() + // get(propertyName: string): Promise; + + /** + * Convenience method for: + * + * + * .then(function() { + * return value; + * }); + * + * + * in the case where `value` doesn't change its value. That means `value` is bound at the time of calling `.return()` + * + * Alias `.thenReturn();` for compatibility with earlier ECMAScript version. + */ + return(): Promise; + thenReturn(): Promise; + return(value: U): Promise; + thenReturn(value: U): Promise; + + /** + * Convenience method for: + * + * + * .then(function() { + * throw reason; + * }); + * + * Same limitations apply as with `.return()`. + * + * Alias `.thenThrow();` for compatibility with earlier ECMAScript version. + */ + throw(reason: Error): Promise; + thenThrow(reason: Error): Promise; + + /** + * Convert to String. + */ + toString(): string; + + /** + * This is implicitly called by `JSON.stringify` when serializing the object. Returns a serialized representation of the `Promise`. + */ + toJSON(): Object; + + /** + * Like calling `.then`, but the fulfillment value or rejection reason is assumed to be an array, which is flattened to the formal parameters of the handlers. + */ + // TODO how to model instance.spread()? like Q? + spread(onFulfill: Function, onReject?: (reason: any) => Promise.Thenable): Promise; + spread(onFulfill: Function, onReject?: (reason: any) => U): Promise; + /* + // TODO or something like this? + spread(onFulfill: (...values: W[]) => Promise.Thenable, onReject?: (reason: any) => Promise.Thenable): Promise; + spread(onFulfill: (...values: W[]) => Promise.Thenable, onReject?: (reason: any) => U): Promise; + spread(onFulfill: (...values: W[]) => U, onReject?: (reason: any) => Promise.Thenable): Promise; + spread(onFulfill: (...values: W[]) => U, onReject?: (reason: any) => U): Promise; + */ + /** + * Same as calling `Promise.all(thisPromise)`. With the exception that if this promise is bound to a value, the returned promise is bound to that value too. + */ + // TODO type inference from array-resolving promise? + all(): Promise; + + /** + * Same as calling `Promise.props(thisPromise)`. With the exception that if this promise is bound to a value, the returned promise is bound to that value too. + */ + // TODO how to model instance.props()? + props(): Promise; + + /** + * Same as calling `Promise.settle(thisPromise)`. With the exception that if this promise is bound to a value, the returned promise is bound to that value too. + */ + // TODO type inference from array-resolving promise? + settle(): Promise[]>; + + /** + * Same as calling `Promise.any(thisPromise)`. With the exception that if this promise is bound to a value, the returned promise is bound to that value too. + */ + // TODO type inference from array-resolving promise? + any(): Promise; + + /** + * Same as calling `Promise.some(thisPromise)`. With the exception that if this promise is bound to a value, the returned promise is bound to that value too. + */ + // TODO type inference from array-resolving promise? + some(count: number): Promise; + + /** + * Same as calling `Promise.race(thisPromise, count)`. With the exception that if this promise is bound to a value, the returned promise is bound to that value too. + */ + // TODO type inference from array-resolving promise? + race(): Promise; + + /** + * Same as calling `Promise.map(thisPromise, mapper)`. With the exception that if this promise is bound to a value, the returned promise is bound to that value too. + */ + // TODO type inference from array-resolving promise? + map(mapper: (item: Q, index: number, arrayLength: number) => Promise.Thenable): Promise; + map(mapper: (item: Q, index: number, arrayLength: number) => U): Promise; + + /** + * Same as calling `Promise.reduce(thisPromise, Function reducer, initialValue)`. With the exception that if this promise is bound to a value, the returned promise is bound to that value too. + */ + // TODO type inference from array-resolving promise? + reduce(reducer: (memo: U, item: Q, index: number, arrayLength: number) => Promise.Thenable, initialValue?: U): Promise; + reduce(reducer: (memo: U, item: Q, index: number, arrayLength: number) => U, initialValue?: U): Promise; + + /** + * Same as calling ``Promise.filter(thisPromise, filterer)``. With the exception that if this promise is bound to a value, the returned promise is bound to that value too. + */ + // TODO type inference from array-resolving promise? + filter(filterer: (item: U, index: number, arrayLength: number) => Promise.Thenable): Promise; + filter(filterer: (item: U, index: number, arrayLength: number) => boolean): Promise; + + /** + * Start the chain of promises with `Promise.try`. Any synchronous exceptions will be turned into rejections on the returned promise. + * + * Note about second argument: if it's specifically a true array, its values become respective arguments for the function call. Otherwise it is passed as is as the first argument for the function call. + * + * Alias for `attempt();` for compatibility with earlier ECMAScript version. + */ + static try(fn: () => Promise.Thenable, args?: any[], ctx?: any): Promise; + static try(fn: () => R, args?: any[], ctx?: any): Promise; + + static attempt(fn: () => Promise.Thenable, args?: any[], ctx?: any): Promise; + static attempt(fn: () => R, args?: any[], ctx?: any): Promise; + + /** + * Returns a new function that wraps the given function `fn`. The new function will always return a promise that is fulfilled with the original functions return values or rejected with thrown exceptions from the original function. + * This method is convenient when a function can sometimes return synchronously or throw synchronously. + */ + static method(fn: Function): Function; + + /** + * Create a promise that is resolved with the given `value`. If `value` is a thenable or promise, the returned promise will assume its state. + */ + static resolve(): Promise; + static resolve(value: Promise.Thenable): Promise; + static resolve(value: R): Promise; + + /** + * Create a promise that is rejected with the given `reason`. + */ + static reject(reason: any): Promise; + static reject(reason: any): Promise; + + /** + * Create a promise with undecided fate and return a `PromiseResolver` to control it. See resolution?: Promise(#promise-resolution). + */ + static defer(): Promise.Resolver; + + /** + * Cast the given `value` to a trusted promise. If `value` is already a trusted `Promise`, it is returned as is. If `value` is not a thenable, a fulfilled is: Promise returned with `value` as its fulfillment value. If `value` is a thenable (Promise-like object, like those returned by jQuery's `$.ajax`), returns a trusted that: Promise assimilates the state of the thenable. + */ + static cast(value: Promise.Thenable): Promise; + static cast(value: R): Promise; + + /** + * Sugar for `Promise.resolve(undefined).bind(thisArg);`. See `.bind()`. + */ + static bind(thisArg: any): Promise; + + /** + * See if `value` is a trusted Promise. + */ + static is(value: any): boolean; + + /** + * Call this right after the library is loaded to enabled long stack traces. Long stack traces cannot be disabled after being enabled, and cannot be enabled after promises have alread been created. Long stack traces imply a substantial performance penalty, around 4-5x for throughput and 0.5x for latency. + */ + static longStackTraces(): void; + + /** + * Returns a promise that will be fulfilled with `value` (or `undefined`) after given `ms` milliseconds. If `value` is a promise, the delay will start counting down when it is fulfilled and the returned promise will be fulfilled with the fulfillment value of the `value` promise. + */ + // TODO enable more overloads + static delay(value: Promise.Thenable, ms: number): Promise; + static delay(value: R, ms: number): Promise; + static delay(ms: number): Promise; + + /** + * Returns a function that will wrap the given `nodeFunction`. Instead of taking a callback, the returned function will return a promise whose fate is decided by the callback behavior of the given node function. The node function should conform to node.js convention of accepting a callback as last argument and calling that callback with error as the first argument and success value on the second argument. + * + * If the `nodeFunction` calls its callback with multiple success values, the fulfillment value will be an array of them. + * + * If you pass a `receiver`, the `nodeFunction` will be called as a method on the `receiver`. + */ + // TODO how to model promisify? + static promisify(nodeFunction: Function, receiver?: any): Function; + + /** + * Promisifies the entire object by going through the object's properties and creating an async equivalent of each function on the object and its prototype chain. The promisified method name will be the original method name postfixed with `Async`. Returns the input object. + * + * Note that the original methods on the object are not overwritten but new methods are created with the `Async`-postfix. For example, if you `promisifyAll()` the node.js `fs` object use `fs.statAsync()` to call the promisified `stat` method. + */ + // TODO how to model promisifyAll? + static promisifyAll(target: Object): Object; + + /** + * Returns a function that can use `yield` to run asynchronous code synchronously. This feature requires the support of generators which are drafted in the next version of the language. Node version greater than `0.11.2` is required and needs to be executed with the `--harmony-generators` (or `--harmony`) command-line switch. + */ + // TODO fix coroutine GeneratorFunction + static coroutine(generatorFunction: Function): Function; + + /** + * Spawn a coroutine which may yield promises to run asynchronous code synchronously. This feature requires the support of generators which are drafted in the next version of the language. Node version greater than `0.11.2` is required and needs to be executed with the `--harmony-generators` (or `--harmony`) command-line switch. + */ + // TODO fix spawn GeneratorFunction + static spawn(generatorFunction: Function): Promise; + + /** + * This is relevant to browser environments with no module loader. + * + * Release control of the `Promise` namespace to whatever it was before this library was loaded. Returns a reference to the library namespace so you can attach it to something else. + */ + static noConflict(): typeof Promise; + + /** + * Add `handler` as the handler to call when there is a possibly unhandled rejection. The default handler logs the error stack to stderr or `console.error` in browsers. + * + * Passing no value or a non-function will have the effect of removing any kind of handling for possibly unhandled rejections. + */ + static onPossiblyUnhandledRejection(handler: (reason: any) => any): void; + + /** + * Given an array, or a promise of an array, which contains promises (or a mix of promises and values) return a promise that is fulfilled when all the items in the array are fulfilled. The promise's fulfillment value is an array with fulfillment values at respective positions to the original array. If any promise in the array rejects, the returned promise is rejected with the rejection reason. + */ + // TODO enable more overloads + // promise of array with promises of value + static all(values: Promise.Thenable[]>): Promise; + // promise of array with values + static all(values: Promise.Thenable): Promise; + // array with promises of value + static all(values: Promise.Thenable[]): Promise; + // array with values + static all(values: R[]): Promise; + + /** + * Like ``Promise.all`` but for object properties instead of array items. Returns a promise that is fulfilled when all the properties of the object are fulfilled. The promise's fulfillment value is an object with fulfillment values at respective keys to the original object. If any promise in the object rejects, the returned promise is rejected with the rejection reason. + * + * If `object` is a trusted `Promise`, then it will be treated as a promise for object rather than for its properties. All other objects are treated for their properties as is returned by `Object.keys` - the object's own enumerable properties. + * + * *The original object is not modified.* + */ + // TODO verify this is correct + // trusted promise for object + static props(object: Promise): Promise; + // object + static props(object: Object): Promise; + + /** + * Given an array, or a promise of an array, which contains promises (or a mix of promises and values) return a promise that is fulfilled when all the items in the array are either fulfilled or rejected. The fulfillment value is an array of ``PromiseInspection`` instances at respective positions in relation to the input array. + * + * *original: The array is not modified. The input array sparsity is retained in the resulting array.* + */ + // promise of array with promises of value + static settle(values: Promise.Thenable[]>): Promise[]>; + // promise of array with values + static settle(values: Promise.Thenable): Promise[]>; + // array with promises of value + static settle(values: Promise.Thenable[]): Promise[]>; + // array with values + static settle(values: R[]): Promise[]>; + + /** + * Like `Promise.some()`, with 1 as `count`. However, if the promise fulfills, the fulfillment value is not an array of 1 but the value directly. + */ + // promise of array with promises of value + static any(values: Promise.Thenable[]>): Promise; + // promise of array with values + static any(values: Promise.Thenable): Promise; + // array with promises of value + static any(values: Promise.Thenable[]): Promise; + // array with values + static any(values: R[]): Promise; + + /** + * Given an array, or a promise of an array, which contains promises (or a mix of promises and values) return a promise that is fulfilled or rejected as soon as a promise in the array is fulfilled or rejected with the respective rejection reason or fulfillment value. + * + * **Note** If you pass empty array or a sparse array with no values, or a promise/thenable for such, it will be forever pending. + */ + // promise of array with promises of value + static race(values: Promise.Thenable[]>): Promise; + // promise of array with values + static race(values: Promise.Thenable): Promise; + // array with promises of value + static race(values: Promise.Thenable[]): Promise; + // array with values + static race(values: R[]): Promise; + + /** + * Initiate a competetive race between multiple promises or values (values will become immediately fulfilled promises). When `count` amount of promises have been fulfilled, the returned promise is fulfilled with an array that contains the fulfillment values of the winners in order of resolution. + * + * If too many promises are rejected so that the promise can never become fulfilled, it will be immediately rejected with an array of rejection reasons in the order they were thrown in. + * + * *The original array is not modified.* + */ + // promise of array with promises of value + static some(values: Promise.Thenable[]>, count: number): Promise; + // promise of array with values + static some(values: Promise.Thenable, count: number): Promise; + // array with promises of value + static some(values: Promise.Thenable[], count: number): Promise; + // array with values + static some(values: R[], count: number): Promise; + + /** + * Like `Promise.all()` but instead of having to pass an array, the array is generated from the passed variadic arguments. + */ + // variadic array with promises of value + static join(...values: Promise.Thenable[]): Promise; + // variadic array with values + static join(...values: R[]): Promise; + + /** + * Map an array, or a promise of an array, which contains a promises (or a mix of promises and values) with the given `mapper` function with the signature `(item, index, arrayLength)` where `item` is the resolved value of a respective promise in the input array. If any promise in the input array is rejected the returned promise is rejected as well. + * + * If the `mapper` function returns promises or thenables, the returned promise will wait for all the mapped results to be resolved as well. + * + * *The original array is not modified.* + */ + // promise of array with promises of value + static map(values: Promise.Thenable[]>, mapper: (item: R, index: number, arrayLength: number) => Promise.Thenable): Promise; + static map(values: Promise.Thenable[]>, mapper: (item: R, index: number, arrayLength: number) => U): Promise; + + // promise of array with values + static map(values: Promise.Thenable, mapper: (item: R, index: number, arrayLength: number) => Promise.Thenable): Promise; + static map(values: Promise.Thenable, mapper: (item: R, index: number, arrayLength: number) => U): Promise; + + // array with promises of value + static map(values: Promise.Thenable[], mapper: (item: R, index: number, arrayLength: number) => Promise.Thenable): Promise; + static map(values: Promise.Thenable[], mapper: (item: R, index: number, arrayLength: number) => U): Promise; + + // array with values + static map(values: R[], mapper: (item: R, index: number, arrayLength: number) => Promise.Thenable): Promise; + static map(values: R[], mapper: (item: R, index: number, arrayLength: number) => U): Promise; + + /** + * Reduce an array, or a promise of an array, which contains a promises (or a mix of promises and values) with the given `reducer` function with the signature `(total, current, index, arrayLength)` where `item` is the resolved value of a respective promise in the input array. If any promise in the input array is rejected the returned promise is rejected as well. + * + * If the reducer function returns a promise or a thenable, the result for the promise is awaited for before continuing with next iteration. + * + * *The original array is not modified. If no `intialValue` is given and the array doesn't contain at least 2 items, the callback will not be called and `undefined` is returned. If `initialValue` is given and the array doesn't have at least 1 item, `initialValue` is returned.* + */ + // promise of array with promises of value + static reduce(values: Promise.Thenable[]>, reducer: (total: U, current: R, index: number, arrayLength: number) => Promise.Thenable, initialValue?: U): Promise; + static reduce(values: Promise.Thenable[]>, reducer: (total: U, current: R, index: number, arrayLength: number) => U, initialValue?: U): Promise; + + // promise of array with values + static reduce(values: Promise.Thenable, reducer: (total: U, current: R, index: number, arrayLength: number) => Promise.Thenable, initialValue?: U): Promise; + static reduce(values: Promise.Thenable, reducer: (total: U, current: R, index: number, arrayLength: number) => U, initialValue?: U): Promise; + + // array with promises of value + static reduce(values: Promise.Thenable[], reducer: (total: U, current: R, index: number, arrayLength: number) => Promise.Thenable, initialValue?: U): Promise; + static reduce(values: Promise.Thenable[], reducer: (total: U, current: R, index: number, arrayLength: number) => U, initialValue?: U): Promise; + + // array with values + static reduce(values: R[], reducer: (total: U, current: R, index: number, arrayLength: number) => Promise.Thenable, initialValue?: U): Promise; + static reduce(values: R[], reducer: (total: U, current: R, index: number, arrayLength: number) => U, initialValue?: U): Promise; + + /** + * Filter an array, or a promise of an array, which contains a promises (or a mix of promises and values) with the given `filterer` function with the signature `(item, index, arrayLength)` where `item` is the resolved value of a respective promise in the input array. If any promise in the input array is rejected the returned promise is rejected as well. + * + * The return values from the filtered functions are coerced to booleans, with the exception of promises and thenables which are awaited for their eventual result. + * + * *The original array is not modified. + */ + // promise of array with promises of value + static filter(values: Promise.Thenable[]>, filterer: (item: R, index: number, arrayLength: number) => Promise.Thenable): Promise; + static filter(values: Promise.Thenable[]>, filterer: (item: R, index: number, arrayLength: number) => boolean): Promise; + + // promise of array with values + static filter(values: Promise.Thenable, filterer: (item: R, index: number, arrayLength: number) => Promise.Thenable): Promise; + static filter(values: Promise.Thenable, filterer: (item: R, index: number, arrayLength: number) => boolean): Promise; + + // array with promises of value + static filter(values: Promise.Thenable[], filterer: (item: R, index: number, arrayLength: number) => Promise.Thenable): Promise; + static filter(values: Promise.Thenable[], filterer: (item: R, index: number, arrayLength: number) => boolean): Promise; + + // array with values + static filter(values: R[], filterer: (item: R, index: number, arrayLength: number) => Promise.Thenable): Promise; + static filter(values: R[], filterer: (item: R, index: number, arrayLength: number) => boolean): Promise; +} + +declare module Promise { + export interface RangeError extends Error { + } + export interface CancellationError extends Error { + } + export interface TimeoutError extends Error { + } + export interface TypeError extends Error { + } + export interface RejectionError extends Error { + } + + export interface Thenable { + then(onFulfilled: (value: R) => Thenable, onRejected: (error: any) => Thenable): Thenable; + then(onFulfilled: (value: R) => Thenable, onRejected?: (error: any) => U): Thenable; + then(onFulfilled: (value: R) => U, onRejected: (error: any) => Thenable): Thenable; + then(onFulfilled?: (value: R) => U, onRejected?: (error: any) => U): Thenable; + } + + export interface Resolver { + /** + * Returns a reference to the controlled promise that can be passed to clients. + */ + promise: Promise; + + /** + * Resolve the underlying promise with `value` as the resolution value. If `value` is a thenable or a promise, the underlying promise will assume its state. + */ + resolve(value: R): void; + resolve(): void; + + /** + * Reject the underlying promise with `reason` as the rejection reason. + */ + reject(reason: any): void; + + /** + * Progress the underlying promise with `value` as the progression value. + */ + progress(value: any): void; + + /** + * Gives you a callback representation of the `PromiseResolver`. Note that this is not a method but a property. The callback accepts error object in first argument and success values on the 2nd parameter and the rest, I.E. node js conventions. + * + * If the the callback is called with multiple success values, the resolver fullfills its promise with an array of the values. + */ + // TODO specify resolver callback + callback: (err: any, value: R, ...values: R[]) => void; + } + + export interface Inspection { + /** + * See if the underlying promise was fulfilled at the creation time of this inspection object. + */ + isFulfilled(): boolean; + + /** + * See if the underlying promise was rejected at the creation time of this inspection object. + */ + isRejected(): boolean; + + /** + * See if the underlying promise was defer at the creation time of this inspection object. + */ + isPending(): boolean; + + /** + * Get the fulfillment value of the underlying promise. Throws if the promise wasn't fulfilled at the creation time of this inspection object. + * + * throws `TypeError` + */ + value(): R; + + /** + * Get the rejection reason for the underlying promise. Throws if the promise wasn't rejected at the creation time of this inspection object. + * + * throws `TypeError` + */ + error(): any; + } +} + +declare module 'bluebird' { + export = Promise; +} diff --git a/definitions/browser-builtins.d.ts b/definitions/browser-builtins.d.ts new file mode 100644 index 0000000..c259af3 --- /dev/null +++ b/definitions/browser-builtins.d.ts @@ -0,0 +1,39 @@ +declare module 'browser-builtins' { + var a: { + [ name: string ]: string; + + assert: string; + child_process: string; + cluster: string; + dgram: string; + dns: string; + domain: string; + events: string; + fs: string; + https: string; + net: string; + path: string; + process: string; + querystring: string; + readline: string; + repl: string; + stream: string; + string_decoder: string; + sys: string; + timers: string; + tls: string; + tty: string; + url: string; + util: string; + punycode: string; + http: string; + vm: string; + crypto: string; + console: string; + zlib: string; + buffer: string; + constants: string; + os: string; + }; + export = a; +} diff --git a/definitions/chalk.d.ts b/definitions/chalk.d.ts new file mode 100644 index 0000000..fee5139 --- /dev/null +++ b/definitions/chalk.d.ts @@ -0,0 +1,52 @@ +declare module 'chalk' { + export interface ColorStyle { + (str: string): string; + + reset: ColorStyle; + bold: ColorStyle; + italic: ColorStyle; + underline: ColorStyle; + inverse: ColorStyle; + strikethrough: ColorStyle; + black: ColorStyle; + red: ColorStyle; + green: ColorStyle; + yellow: ColorStyle; + blue: ColorStyle; + magenta: ColorStyle; + cyan: ColorStyle; + white: ColorStyle; + gray: ColorStyle; + bgBlack: ColorStyle; + bgRed: ColorStyle; + bgGreen: ColorStyle; + bgYellow: ColorStyle; + bgBlue: ColorStyle; + bgMagenta: ColorStyle; + bgCyan: ColorStyle; + bgWhite: ColorStyle; + } + export var reset: ColorStyle; + export var bold: ColorStyle; + export var italic: ColorStyle; + export var underline: ColorStyle; + export var inverse: ColorStyle; + export var strikethrough: ColorStyle; + export var black: ColorStyle; + export var red: ColorStyle; + export var green: ColorStyle; + export var yellow: ColorStyle; + export var blue: ColorStyle; + export var magenta: ColorStyle; + export var cyan: ColorStyle; + export var white: ColorStyle; + export var gray: ColorStyle; + export var bgBlack: ColorStyle; + export var bgRed: ColorStyle; + export var bgGreen: ColorStyle; + export var bgYellow: ColorStyle; + export var bgBlue: ColorStyle; + export var bgMagenta: ColorStyle; + export var bgCyan: ColorStyle; + export var bgWhite: ColorStyle; +} diff --git a/definitions/commander.d.ts b/definitions/commander.d.ts new file mode 100644 index 0000000..e2f536a --- /dev/null +++ b/definitions/commander.d.ts @@ -0,0 +1,228 @@ +// Type definitions for commanderjs 1.1.1 +// Project: https://github.com/visionmedia/commander.js +// Definitions by: Marcelo Dezem +// Definitions: https://github.com/borisyankov/DefinitelyTyped + +declare module "commander" { + export interface Command { + /** + * The command name. + */ + name: string; + + // + // + // NOTE: the methods below are COPIED to the module + // as functions exports. If changes need to be made here, + // remember to re-paste the definitions in the module. + // Read below to know why such ugly thing is required. + // + // + + /** + * Register callback fn for the command. + */ + action(fn: (...args: any[]) => any): Command; + + /** + * Define option with flags, description and optional coercion function and default value. + * The flags string should contain both the short and long flags + * separated by comma, a pipe or space. The following are all valid + * all will output this way when --help is used. + * + * "-p, --pepper" + * "-p|--pepper" + * "-p --pepper" + * + * @param flags the option flags. + * @param description the option description. The description is printed when "--help" is used. + * @param coerceFn (optional) specifies a callback function to coerce the option arg. + * @param defaultValue (optional) specifies a default value. + */ + option(flags: string, description: string, coerceFn?: (value: string) => any, defaultValue?: any): Command; + + + /** + * Sets the command version + */ + version(version: string): Command; + + /** + * Parse the arguments array and invokes the commands passing the parsed options. + * @param argv the arguments array. + */ + parse(argv: string[]): Command; + + /** + * Gets or sets the command description. + * @param description the new description for the command. When ommited this returns the current description, otherwise returns the current Command. + */ + description(description: string): Command; + description(): string; + + /** + * Gets or sets the usage help string. + */ + usage(usage: string): Command; + usage(): string; + + /* + * Prompt the user for a value, calling the callback function. + * + * Supports single-line and multi-line prompts. + * To issue a single-line prompt simply add a whitespace + * to the end of label, something like "name: ", whereas + * for a multi-line prompt omit this "description:". + * @param label the label string to be printed in console. + * @param callback a callback function to handle the inputed string. + */ + prompt(label: string, callback: (value: string) => any): void; + + promptForNumber(label: string, callback: (value: number) => any): void; + promptForDate(label: string, callback: (value: Date) => any): void; + promptSingleLine(label: string, callback: (value: string) => any): void; + promptMultiLine(label: string, callback: (value: string) => any): void; + + /** + * Prompt for password with a label, a optional mask char and callback function. + * The mask string defaults to '', aka no output is written while typing, you may want to use "*" etc. + */ + password(label: string, mask: string, callback: (value: string) => any): void; + password(label: string, callback: (value: string) => any): void; + + /** + * Prompts the user for a confirmation. + */ + confirm(label: string, callback: (flag: boolean) => any): void; + + /** + * Prompt for password with str, mask char and callback fn(val). + * The mask string defaults to '', aka no output is written while typing, you may want to use "*" etc. + */ + choose(options: string[], callback: (idx: number) => any): void; + choose(options: any[], callback: (idx: number) => any): void; + + /** + * Add command with the specified name. Returns a new instance of Command. + * + * The .action() callback is invoked when the + * command name is specified via ARGV, + * and the remaining arguments are applied to the + * function for access. + + * When the name is "*" an un-matched command + * will be passed as the first arg, followed by + * the rest of ARGV remaining. + * + * @param name the name of the command. Pass "*" to trap un-matched commands. + */ + command(name: string): Command; + } + + // + // + // since TypeScript (and ECMA6) does not supports module.exports, + // there is no way to set the default Command instance as the module itself. + // It's ugly but the only way is to copy all the methods from Command + // and paste it in the module as functions exports. + // + // + + /** + * Register callback fn for the command. + */ + export function action(fn: (...args: any[]) => any): Command; + + /** + * Define option with flags, description and optional coercion function and default value. + * The flags string should contain both the short and long flags + * separated by comma, a pipe or space. The following are all valid + * all will output this way when --help is used. + * + * "-p, --pepper" + * "-p|--pepper" + * "-p --pepper" + * + * @param flags the option flags. + * @param description the option description. The description is printed when "--help" is used. + * @param coerceFn (optional) specifies a callback function to coerce the option arg. + * @param defaultValue (optional) specifies a default value. + */ + export function option(flags: string, description: string, coerceFn?: (value: string) => any, defaultValue?: any): Command; + + + /** + * Sets the command version + */ + export function version(version: string): Command; + + /** + * Parse the arguments array and invokes the commands passing the parsed options. + * @param argv the arguments array. + */ + export function parse(argv: string[]): Command; + + /** + * Gets or sets the command description. + * @param description the new description for the command. When ommited this returns the current description, otherwise returns the current Command. + */ + export function description(description: string): Command; + export function description(): string; + + /** + * Gets or sets the usage help string. + */ + export function usage(usage: string): Command; + export function usage(): string; + + /* + * Prompt the user for a value, calling the callback function. + * + * Supports single-line and multi-line prompts. + * To issue a single-line prompt simply add a whitespace + * to the end of label, something like "name: ", whereas + * for a multi-line prompt omit this "description:". + * @param label the label string to be printed in console. + * @param callback a callback function to handle the inputed string. + */ + export function prompt(label: string, callback: (value: string) => any): void; + + export function promptForNumber(label: string, callback: (value: number) => any): void; + export function promptForDate(label: string, callback: (value: Date) => any): void; + export function promptSingleLine(label: string, callback: (value: string) => any): void; + export function promptMultiLine(label: string, callback: (value: string) => any): void; + /** + * Prompt for password with a label, a optional mask char and callback function. + * The mask string defaults to '', aka no output is written while typing, you may want to use "*" etc. + */ + export function password(label: string, mask: string, callback: (value: string) => any): void; + export function password(label: string, callback: (value: string) => any): void; + + /** + * Prompts the user for a confirmation. + */ + export function confirm(label: string, callback: (flag: boolean) => any): void; + + /** + * Prompt for password with str, mask char and callback fn(val). + * The mask string defaults to '', aka no output is written while typing, you may want to use "*" etc. + */ + export function choose(options: string[], callback: (idx: number) => any): void; + export function choose(options: any[], callback: (idx: number) => any): void; + + /** + * Add command with the specified name. Returns a new instance of Command. + * + * The .action() callback is invoked when the + * command name is specified via ARGV, + * and the remaining arguments are applied to the + * function for access. + + * When the name is "*" an un-matched command + * will be passed as the first arg, followed by + * the rest of ARGV remaining. + * + * @param name the name of the command. Pass "*" to trap un-matched commands. + */ + export function command(name: string): Command; +} diff --git a/definitions/node.d.ts b/definitions/node.d.ts new file mode 100644 index 0000000..305cbc0 --- /dev/null +++ b/definitions/node.d.ts @@ -0,0 +1,1256 @@ +// Type definitions for Node.js v0.10.1 +// Project: http://nodejs.org/ +// Definitions: https://github.com/borisyankov/DefinitelyTyped + +/************************************************ +* * +* Node.js v0.10.1 API * +* * +************************************************/ + +/************************************************ +* * +* GLOBAL * +* * +************************************************/ +declare var process: NodeProcess; +declare var global: any; + +declare var __filename: string; +declare var __dirname: string; + +declare function setTimeout(callback: (...args: any[]) => void , ms: number , ...args: any[]): NodeTimer; +declare function clearTimeout(timeoutId: NodeTimer): void; +declare function setInterval(callback: (...args: any[]) => void , ms: number , ...args: any[]): NodeTimer; +declare function clearInterval(intervalId: NodeTimer): void; +declare function setImmediate(callback: (...args: any[]) => void , ...args: any[]): any; +declare function clearImmediate(immediateId: any): void; + +declare var require: { + (id: string): any; + resolve(id:string): string; + cache: any; + extensions: any; + main: any; +} + +declare var module: { + exports: any; + require(id: string): any; + id: string; + filename: string; + loaded: boolean; + parent: any; + children: any[]; +} + +// Same as module.exports +declare var exports: any; +declare var SlowBuffer: { + new (str: string, encoding?: string): NodeBuffer; + new (size: number): NodeBuffer; + new (array: any[]): NodeBuffer; + prototype: NodeBuffer; + isBuffer(obj: any): boolean; + byteLength(string: string, encoding?: string): number; + concat(list: NodeBuffer[], totalLength?: number): NodeBuffer; +}; +declare var Buffer: { + new (str: string, encoding?: string): NodeBuffer; + new (size: number): NodeBuffer; + new (array: any[]): NodeBuffer; + prototype: NodeBuffer; + isBuffer(obj: any): boolean; + byteLength(string: string, encoding?: string): number; + concat(list: NodeBuffer[], totalLength?: number): NodeBuffer; +} + +/************************************************ +* * +* INTERFACES * +* * +************************************************/ + +interface ErrnoException extends Error { + errno?: any; + code?: string; + path?: string; + syscall?: string; +} + +interface NodeEventEmitter { + addListener(event: string, listener: Function): NodeEventEmitter; + on(event: string, listener: Function): NodeEventEmitter; + once(event: string, listener: Function): NodeEventEmitter; + removeListener(event: string, listener: Function): NodeEventEmitter; + removeAllListeners(event?: string): NodeEventEmitter; + setMaxListeners(n: number): void; + listeners(event: string): Function[]; + emit(event: string, ...args: any[]): boolean; +} + +interface ReadableStream extends NodeEventEmitter { + readable: boolean; + read(size?: number): any; + setEncoding(encoding: string): void; + pause(): void; + resume(): void; + pipe(destination: T, options?: { end?: boolean; }): T; + unpipe(destination?: T): void; + unshift(chunk: string): void; + unshift(chunk: NodeBuffer): void; + wrap(oldStream: ReadableStream): ReadableStream; +} + +interface WritableStream extends NodeEventEmitter { + writable: boolean; + write(buffer: NodeBuffer, cb?: Function): boolean; + write(str: string, cb?: Function): boolean; + write(str: string, encoding?: string, cb?: Function): boolean; + end(): void; + end(buffer: NodeBuffer, cb?: Function): void; + end(str: string, cb?: Function): void; + end(str: string, encoding?: string, cb?: Function): void; +} + +interface ReadWriteStream extends ReadableStream, WritableStream { } + +interface NodeProcess extends NodeEventEmitter { + stdout: WritableStream; + stderr: WritableStream; + stdin: ReadableStream; + argv: string[]; + execPath: string; + abort(): void; + chdir(directory: string): void; + cwd(): string; + env: any; + exit(code?: number): void; + getgid(): number; + setgid(id: number): void; + setgid(id: string): void; + getuid(): number; + setuid(id: number): void; + setuid(id: string): void; + version: string; + versions: { http_parser: string; node: string; v8: string; ares: string; uv: string; zlib: string; openssl: string; }; + config: { + target_defaults: { + cflags: any[]; + default_configuration: string; + defines: string[]; + include_dirs: string[]; + libraries: string[]; + }; + variables: { + clang: number; + host_arch: string; + node_install_npm: boolean; + node_install_waf: boolean; + node_prefix: string; + node_shared_openssl: boolean; + node_shared_v8: boolean; + node_shared_zlib: boolean; + node_use_dtrace: boolean; + node_use_etw: boolean; + node_use_openssl: boolean; + target_arch: string; + v8_no_strict_aliasing: number; + v8_use_snapshot: boolean; + visibility: string; + }; + }; + kill(pid: number, signal?: string): void; + pid: number; + title: string; + arch: string; + platform: string; + memoryUsage(): { rss: number; heapTotal: number; heapUsed: number; }; + nextTick(callback: Function): void; + umask(mask?: number): number; + uptime(): number; + hrtime(time?:number[]): number[]; + + // Worker + send?(message: any, sendHandle?: any): void; +} + +// Buffer class +interface NodeBuffer { + [index: number]: number; + write(string: string, offset?: number, length?: number, encoding?: string): number; + toString(encoding?: string, start?: number, end?: number): string; + length: number; + copy(targetBuffer: NodeBuffer, targetStart?: number, sourceStart?: number, sourceEnd?: number): number; + slice(start?: number, end?: number): NodeBuffer; + readUInt8(offset: number, noAsset?: boolean): number; + readUInt16LE(offset: number, noAssert?: boolean): number; + readUInt16BE(offset: number, noAssert?: boolean): number; + readUInt32LE(offset: number, noAssert?: boolean): number; + readUInt32BE(offset: number, noAssert?: boolean): number; + readInt8(offset: number, noAssert?: boolean): number; + readInt16LE(offset: number, noAssert?: boolean): number; + readInt16BE(offset: number, noAssert?: boolean): number; + readInt32LE(offset: number, noAssert?: boolean): number; + readInt32BE(offset: number, noAssert?: boolean): number; + readFloatLE(offset: number, noAssert?: boolean): number; + readFloatBE(offset: number, noAssert?: boolean): number; + readDoubleLE(offset: number, noAssert?: boolean): number; + readDoubleBE(offset: number, noAssert?: boolean): number; + writeUInt8(value: number, offset: number, noAssert?: boolean): void; + writeUInt16LE(value: number, offset: number, noAssert?: boolean): void; + writeUInt16BE(value: number, offset: number, noAssert?: boolean): void; + writeUInt32LE(value: number, offset: number, noAssert?: boolean): void; + writeUInt32BE(value: number, offset: number, noAssert?: boolean): void; + writeInt8(value: number, offset: number, noAssert?: boolean): void; + writeInt16LE(value: number, offset: number, noAssert?: boolean): void; + writeInt16BE(value: number, offset: number, noAssert?: boolean): void; + writeInt32LE(value: number, offset: number, noAssert?: boolean): void; + writeInt32BE(value: number, offset: number, noAssert?: boolean): void; + writeFloatLE(value: number, offset: number, noAssert?: boolean): void; + writeFloatBE(value: number, offset: number, noAssert?: boolean): void; + writeDoubleLE(value: number, offset: number, noAssert?: boolean): void; + writeDoubleBE(value: number, offset: number, noAssert?: boolean): void; + fill(value: any, offset?: number, end?: number): void; +} + +interface NodeTimer { + ref() : void; + unref() : void; +} + +/************************************************ +* * +* MODULES * +* * +************************************************/ +declare module "querystring" { + export function stringify(obj: any, sep?: string, eq?: string): string; + export function parse(str: string, sep?: string, eq?: string, options?: { maxKeys?: number; }): any; + export function escape(): any; + export function unescape(): any; +} + +declare module "events" { + export class EventEmitter implements NodeEventEmitter { + static listenerCount(emitter: EventEmitter, event: string): number; + + addListener(event: string, listener: Function): EventEmitter; + on(event: string, listener: Function): EventEmitter; + once(event: string, listener: Function): EventEmitter; + removeListener(event: string, listener: Function): EventEmitter; + removeAllListeners(event?: string): EventEmitter; + setMaxListeners(n: number): void; + listeners(event: string): Function[]; + emit(event: string, ...args: any[]): boolean; + } +} + +declare module "http" { + import events = require("events"); + import net = require("net"); + import stream = require("stream"); + + export interface Server extends NodeEventEmitter { + listen(port: number, hostname?: string, backlog?: number, callback?: Function): void; + listen(path: string, callback?: Function): void; + listen(handle: any, listeningListener?: Function): void; + close(cb?: any): void; + maxHeadersCount: number; + } + export interface ServerRequest extends NodeEventEmitter, ReadableStream { + method: string; + url: string; + headers: any; + trailers: string; + httpVersion: string; + setEncoding(encoding?: string): void; + pause(): void; + resume(): void; + connection: net.NodeSocket; + } + export interface ServerResponse extends NodeEventEmitter, WritableStream { + // Extended base methods + write(buffer: NodeBuffer): boolean; + write(buffer: NodeBuffer, cb?: Function): boolean; + write(str: string, cb?: Function): boolean; + write(str: string, encoding?: string, cb?: Function): boolean; + write(str: string, encoding?: string, fd?: string): boolean; + + writeContinue(): void; + writeHead(statusCode: number, reasonPhrase?: string, headers?: any): void; + writeHead(statusCode: number, headers?: any): void; + statusCode: number; + setHeader(name: string, value: string): void; + sendDate: boolean; + getHeader(name: string): string; + removeHeader(name: string): void; + write(chunk: any, encoding?: string): any; + addTrailers(headers: any): void; + + // Extended base methods + end(): void; + end(buffer: NodeBuffer, cb?: Function): void; + end(str: string, cb?: Function): void; + end(str: string, encoding?: string, cb?: Function): void; + end(data?: any, encoding?: string): void; + } + export interface ClientRequest extends NodeEventEmitter, WritableStream { + // Extended base methods + write(buffer: NodeBuffer): boolean; + write(buffer: NodeBuffer, cb?: Function): boolean; + write(str: string, cb?: Function): boolean; + write(str: string, encoding?: string, cb?: Function): boolean; + write(str: string, encoding?: string, fd?: string): boolean; + + write(chunk: any, encoding?: string): void; + abort(): void; + setTimeout(timeout: number, callback?: Function): void; + setNoDelay(noDelay?: Function): void; + setSocketKeepAlive(enable?: boolean, initialDelay?: number): void; + + // Extended base methods + end(): void; + end(buffer: NodeBuffer, cb?: Function): void; + end(str: string, cb?: Function): void; + end(str: string, encoding?: string, cb?: Function): void; + end(data?: any, encoding?: string): void; + } + export interface ClientResponse extends NodeEventEmitter, ReadableStream { + statusCode: number; + httpVersion: string; + headers: any; + trailers: any; + setEncoding(encoding?: string): void; + pause(): void; + resume(): void; + } + export interface Agent { maxSockets: number; sockets: any; requests: any; } + + export var STATUS_CODES: any; + export function createServer(requestListener?: (request: ServerRequest, response: ServerResponse) =>void ): Server; + export function createClient(port?: number, host?: string): any; + export function request(options: any, callback?: Function): ClientRequest; + export function get(options: any, callback?: Function): ClientRequest; + export var globalAgent: Agent; +} + +declare module "cluster" { + import child = require("child_process"); + import events = require("events"); + + export interface ClusterSettings { + exec?: string; + args?: string[]; + silent?: boolean; + } + + export class Worker extends events.EventEmitter { + id: string; + process: child.ChildProcess; + suicide: boolean; + send(message: any, sendHandle?: any): void; + kill(signal?: string): void; + destroy(signal?: string): void; + disconnect(): void; + } + + export var settings: ClusterSettings; + export var isMaster: boolean; + export var isWorker: boolean; + export function setupMaster(settings?: ClusterSettings): void; + export function fork(env?: any): Worker; + export function disconnect(callback?: Function): void; + export var worker: Worker; + export var workers: Worker[]; + + // Event emitter + export function addListener(event: string, listener: Function): void; + export function on(event: string, listener: Function): any; + export function once(event: string, listener: Function): void; + export function removeListener(event: string, listener: Function): void; + export function removeAllListeners(event?: string): void; + export function setMaxListeners(n: number): void; + export function listeners(event: string): Function[]; + export function emit(event: string, ...args: any[]): boolean; +} + +declare module "zlib" { + import stream = require("stream"); + export interface ZlibOptions { chunkSize?: number; windowBits?: number; level?: number; memLevel?: number; strategy?: number; dictionary?: any; } + + export interface Gzip extends ReadWriteStream { } + export interface Gunzip extends ReadWriteStream { } + export interface Deflate extends ReadWriteStream { } + export interface Inflate extends ReadWriteStream { } + export interface DeflateRaw extends ReadWriteStream { } + export interface InflateRaw extends ReadWriteStream { } + export interface Unzip extends ReadWriteStream { } + + export function createGzip(options?: ZlibOptions): Gzip; + export function createGunzip(options?: ZlibOptions): Gunzip; + export function createDeflate(options?: ZlibOptions): Deflate; + export function createInflate(options?: ZlibOptions): Inflate; + export function createDeflateRaw(options?: ZlibOptions): DeflateRaw; + export function createInflateRaw(options?: ZlibOptions): InflateRaw; + export function createUnzip(options?: ZlibOptions): Unzip; + + export function deflate(buf: NodeBuffer, callback: (error: Error, result: any) =>void ): void; + export function deflateRaw(buf: NodeBuffer, callback: (error: Error, result: any) =>void ): void; + export function gzip(buf: NodeBuffer, callback: (error: Error, result: any) =>void ): void; + export function gunzip(buf: NodeBuffer, callback: (error: Error, result: any) =>void ): void; + export function inflate(buf: NodeBuffer, callback: (error: Error, result: any) =>void ): void; + export function inflateRaw(buf: NodeBuffer, callback: (error: Error, result: any) =>void ): void; + export function unzip(buf: NodeBuffer, callback: (error: Error, result: any) =>void ): void; + + // Constants + export var Z_NO_FLUSH: number; + export var Z_PARTIAL_FLUSH: number; + export var Z_SYNC_FLUSH: number; + export var Z_FULL_FLUSH: number; + export var Z_FINISH: number; + export var Z_BLOCK: number; + export var Z_TREES: number; + export var Z_OK: number; + export var Z_STREAM_END: number; + export var Z_NEED_DICT: number; + export var Z_ERRNO: number; + export var Z_STREAM_ERROR: number; + export var Z_DATA_ERROR: number; + export var Z_MEM_ERROR: number; + export var Z_BUF_ERROR: number; + export var Z_VERSION_ERROR: number; + export var Z_NO_COMPRESSION: number; + export var Z_BEST_SPEED: number; + export var Z_BEST_COMPRESSION: number; + export var Z_DEFAULT_COMPRESSION: number; + export var Z_FILTERED: number; + export var Z_HUFFMAN_ONLY: number; + export var Z_RLE: number; + export var Z_FIXED: number; + export var Z_DEFAULT_STRATEGY: number; + export var Z_BINARY: number; + export var Z_TEXT: number; + export var Z_ASCII: number; + export var Z_UNKNOWN: number; + export var Z_DEFLATED: number; + export var Z_NULL: number; +} + +declare module "os" { + export function tmpDir(): string; + export function hostname(): string; + export function type(): string; + export function platform(): string; + export function arch(): string; + export function release(): string; + export function uptime(): number; + export function loadavg(): number[]; + export function totalmem(): number; + export function freemem(): number; + export function cpus(): { model: string; speed: number; times: { user: number; nice: number; sys: number; idle: number; irq: number; }; }[]; + export function networkInterfaces(): any; + export var EOL: string; +} + +declare module "https" { + import tls = require("tls"); + import events = require("events"); + import http = require("http"); + + export interface ServerOptions { + pfx?: any; + key?: any; + passphrase?: string; + cert?: any; + ca?: any; + crl?: any; + ciphers?: string; + honorCipherOrder?: boolean; + requestCert?: boolean; + rejectUnauthorized?: boolean; + NPNProtocols?: any; + SNICallback?: (servername: string) => any; + } + + export interface RequestOptions { + host?: string; + hostname?: string; + port?: number; + path?: string; + method?: string; + headers?: any; + auth?: string; + agent?: any; + pfx?: any; + key?: any; + passphrase?: string; + cert?: any; + ca?: any; + ciphers?: string; + rejectUnauthorized?: boolean; + } + + export interface NodeAgent { + maxSockets: number; + sockets: any; + requests: any; + } + export var Agent: { + new (options?: RequestOptions): NodeAgent; + }; + export interface Server extends tls.Server { } + export function createServer(options: ServerOptions, requestListener?: Function): Server; + export function request(options: RequestOptions, callback?: (res: NodeEventEmitter) =>void ): http.ClientRequest; + export function get(options: RequestOptions, callback?: (res: NodeEventEmitter) =>void ): http.ClientRequest; + export var globalAgent: NodeAgent; +} + +declare module "punycode" { + export function decode(string: string): string; + export function encode(string: string): string; + export function toUnicode(domain: string): string; + export function toASCII(domain: string): string; + export var ucs2: ucs2; + interface ucs2 { + decode(string: string): string; + encode(codePoints: number[]): string; + } + export var version: any; +} + +declare module "repl" { + import stream = require("stream"); + import events = require("events"); + + export interface ReplOptions { + prompt?: string; + input?: ReadableStream; + output?: WritableStream; + terminal?: boolean; + eval?: Function; + useColors?: boolean; + useGlobal?: boolean; + ignoreUndefined?: boolean; + writer?: Function; + } + export function start(options: ReplOptions): NodeEventEmitter; +} + +declare module "readline" { + import events = require("events"); + import stream = require("stream"); + + export interface ReadLine extends NodeEventEmitter { + setPrompt(prompt: string, length: number): void; + prompt(preserveCursor?: boolean): void; + question(query: string, callback: Function): void; + pause(): void; + resume(): void; + close(): void; + write(data: any, key?: any): void; + } + export interface ReadLineOptions { + input: ReadableStream; + output: WritableStream; + completer?: Function; + terminal?: boolean; + } + export function createInterface(options: ReadLineOptions): ReadLine; +} + +declare module "vm" { + export interface Context { } + export interface Script { + runInThisContext(): void; + runInNewContext(sandbox?: Context): void; + } + export function runInThisContext(code: string, filename?: string): void; + export function runInNewContext(code: string, sandbox?: Context, filename?: string): void; + export function runInContext(code: string, context: Context, filename?: string): void; + export function createContext(initSandbox?: Context): Context; + export function createScript(code: string, filename?: string): Script; +} + +declare module "child_process" { + import events = require("events"); + import stream = require("stream"); + + export interface ChildProcess extends NodeEventEmitter { + stdin: WritableStream; + stdout: ReadableStream; + stderr: ReadableStream; + pid: number; + kill(signal?: string): void; + send(message: any, sendHandle: any): void; + disconnect(): void; + } + + export function spawn(command: string, args?: string[], options?: { + cwd?: string; + stdio?: any; + custom?: any; + env?: any; + detached?: boolean; + }): ChildProcess; + export function exec(command: string, options: { + cwd?: string; + stdio?: any; + customFds?: any; + env?: any; + encoding?: string; + timeout?: number; + maxBuffer?: number; + killSignal?: string; + }, callback: (error: Error, stdout: NodeBuffer, stderr: NodeBuffer) =>void ): ChildProcess; + export function exec(command: string, callback: (error: Error, stdout: NodeBuffer, stderr: NodeBuffer) =>void ): ChildProcess; + export function execFile(file: string, args: string[], options: { + cwd?: string; + stdio?: any; + customFds?: any; + env?: any; + encoding?: string; + timeout?: number; + maxBuffer?: string; + killSignal?: string; + }, callback: (error: Error, stdout: NodeBuffer, stderr: NodeBuffer) =>void ): ChildProcess; + export function fork(modulePath: string, args?: string[], options?: { + cwd?: string; + env?: any; + encoding?: string; + }): ChildProcess; +} + +declare module "url" { + export interface Url { + href: string; + protocol: string; + auth: string; + hostname: string; + port: string; + host: string; + pathname: string; + search: string; + query: string; + slashes: boolean; + } + + export interface UrlOptions { + protocol?: string; + auth?: string; + hostname?: string; + port?: string; + host?: string; + pathname?: string; + search?: string; + query?: any; + } + + export function parse(urlStr: string, parseQueryString?: boolean , slashesDenoteHost?: boolean ): Url; + export function format(url: UrlOptions): string; + export function resolve(from: string, to: string): string; +} + +declare module "dns" { + export function lookup(domain: string, family: number, callback: (err: Error, address: string, family: number) =>void ): string; + export function lookup(domain: string, callback: (err: Error, address: string, family: number) =>void ): string; + export function resolve(domain: string, rrtype: string, callback: (err: Error, addresses: string[]) =>void ): string[]; + export function resolve(domain: string, callback: (err: Error, addresses: string[]) =>void ): string[]; + export function resolve4(domain: string, callback: (err: Error, addresses: string[]) =>void ): string[]; + export function resolve6(domain: string, callback: (err: Error, addresses: string[]) =>void ): string[]; + export function resolveMx(domain: string, callback: (err: Error, addresses: string[]) =>void ): string[]; + export function resolveTxt(domain: string, callback: (err: Error, addresses: string[]) =>void ): string[]; + export function resolveSrv(domain: string, callback: (err: Error, addresses: string[]) =>void ): string[]; + export function resolveNs(domain: string, callback: (err: Error, addresses: string[]) =>void ): string[]; + export function resolveCname(domain: string, callback: (err: Error, addresses: string[]) =>void ): string[]; + export function reverse(ip: string, callback: (err: Error, domains: string[]) =>void ): string[]; +} + +declare module "net" { + import stream = require("stream"); + + export interface NodeSocket extends ReadWriteStream { + // Extended base methods + write(buffer: NodeBuffer): boolean; + write(buffer: NodeBuffer, cb?: Function): boolean; + write(str: string, cb?: Function): boolean; + write(str: string, encoding?: string, cb?: Function): boolean; + write(str: string, encoding?: string, fd?: string): boolean; + + connect(port: number, host?: string, connectionListener?: Function): void; + connect(path: string, connectionListener?: Function): void; + bufferSize: number; + setEncoding(encoding?: string): void; + write(data: any, encoding?: string, callback?: Function): void; + destroy(): void; + pause(): void; + resume(): void; + setTimeout(timeout: number, callback?: Function): void; + setNoDelay(noDelay?: boolean): void; + setKeepAlive(enable?: boolean, initialDelay?: number): void; + address(): { port: number; family: string; address: string; }; + remoteAddress: string; + remotePort: number; + bytesRead: number; + bytesWritten: number; + + // Extended base methods + end(): void; + end(buffer: NodeBuffer, cb?: Function): void; + end(str: string, cb?: Function): void; + end(str: string, encoding?: string, cb?: Function): void; + end(data?: any, encoding?: string): void; + } + + export var Socket: { + new (options?: { fd?: string; type?: string; allowHalfOpen?: boolean; }): NodeSocket; + }; + + export interface Server extends NodeSocket { + listen(port: number, host?: string, backlog?: number, listeningListener?: Function): void; + listen(path: string, listeningListener?: Function): void; + listen(handle: any, listeningListener?: Function): void; + close(callback?: Function): void; + address(): { port: number; family: string; address: string; }; + maxConnections: number; + connections: number; + } + export function createServer(connectionListener?: (socket: NodeSocket) =>void ): Server; + export function createServer(options?: { allowHalfOpen?: boolean; }, connectionListener?: (socket: NodeSocket) =>void ): Server; + export function connect(options: { allowHalfOpen?: boolean; }, connectionListener?: Function): NodeSocket; + export function connect(port: number, host?: string, connectionListener?: Function): NodeSocket; + export function connect(path: string, connectionListener?: Function): NodeSocket; + export function createConnection(options: { allowHalfOpen?: boolean; }, connectionListener?: Function): NodeSocket; + export function createConnection(port: number, host?: string, connectionListener?: Function): NodeSocket; + export function createConnection(path: string, connectionListener?: Function): NodeSocket; + export function isIP(input: string): number; + export function isIPv4(input: string): boolean; + export function isIPv6(input: string): boolean; +} + +declare module "dgram" { + import events = require("events"); + + export function createSocket(type: string, callback?: Function): Socket; + + interface Socket extends NodeEventEmitter { + send(buf: NodeBuffer, offset: number, length: number, port: number, address: string, callback?: Function): void; + bind(port: number, address?: string): void; + close(): void; + address: { address: string; family: string; port: number; }; + setBroadcast(flag: boolean): void; + setMulticastTTL(ttl: number): void; + setMulticastLoopback(flag: boolean): void; + addMembership(multicastAddress: string, multicastInterface?: string): void; + dropMembership(multicastAddress: string, multicastInterface?: string): void; + } +} + +declare module "fs" { + import stream = require("stream"); + + interface Stats { + isFile(): boolean; + isDirectory(): boolean; + isBlockDevice(): boolean; + isCharacterDevice(): boolean; + isSymbolicLink(): boolean; + isFIFO(): boolean; + isSocket(): boolean; + dev: number; + ino: number; + mode: number; + nlink: number; + uid: number; + gid: number; + rdev: number; + size: number; + blksize: number; + blocks: number; + atime: Date; + mtime: Date; + ctime: Date; + } + + interface FSWatcher extends NodeEventEmitter { + close(): void; + } + + export interface ReadStream extends ReadableStream { } + export interface WriteStream extends WritableStream { } + + export function rename(oldPath: string, newPath: string, callback?: (err?: ErrnoException) => void): void; + export function renameSync(oldPath: string, newPath: string): void; + export function truncate(path: string, callback?: (err?: ErrnoException) => void): void; + export function truncate(path: string, len: number, callback?: (err?: ErrnoException) => void): void; + export function truncateSync(path: string, len?: number): void; + export function ftruncate(fd: number, callback?: (err?: ErrnoException) => void): void; + export function ftruncate(fd: number, len: number, callback?: (err?: ErrnoException) => void): void; + export function ftruncateSync(fd: number, len?: number): void; + export function chown(path: string, uid: number, gid: number, callback?: (err?: ErrnoException) => void): void; + export function chownSync(path: string, uid: number, gid: number): void; + export function fchown(fd: number, uid: number, gid: number, callback?: (err?: ErrnoException) => void): void; + export function fchownSync(fd: number, uid: number, gid: number): void; + export function lchown(path: string, uid: number, gid: number, callback?: (err?: ErrnoException) => void): void; + export function lchownSync(path: string, uid: number, gid: number): void; + export function chmod(path: string, mode: number, callback?: (err?: ErrnoException) => void): void; + export function chmod(path: string, mode: string, callback?: (err?: ErrnoException) => void): void; + export function chmodSync(path: string, mode: number): void; + export function chmodSync(path: string, mode: string): void; + export function fchmod(fd: number, mode: number, callback?: (err?: ErrnoException) => void): void; + export function fchmod(fd: number, mode: string, callback?: (err?: ErrnoException) => void): void; + export function fchmodSync(fd: number, mode: number): void; + export function fchmodSync(fd: number, mode: string): void; + export function lchmod(path: string, mode: number, callback?: (err?: ErrnoException) => void): void; + export function lchmod(path: string, mode: string, callback?: (err?: ErrnoException) => void): void; + export function lchmodSync(path: string, mode: number): void; + export function lchmodSync(path: string, mode: string): void; + export function stat(path: string, callback?: (err: ErrnoException, stats: Stats) => any): void; + export function lstat(path: string, callback?: (err: ErrnoException, stats: Stats) => any): void; + export function fstat(fd: number, callback?: (err: ErrnoException, stats: Stats) => any): void; + export function statSync(path: string): Stats; + export function lstatSync(path: string): Stats; + export function fstatSync(fd: number): Stats; + export function link(srcpath: string, dstpath: string, callback?: (err?: ErrnoException) => void): void; + export function linkSync(srcpath: string, dstpath: string): void; + export function symlink(srcpath: string, dstpath: string, type?: string, callback?: (err?: ErrnoException) => void): void; + export function symlinkSync(srcpath: string, dstpath: string, type?: string): void; + export function readlink(path: string, callback?: (err: ErrnoException, linkString: string) => any): void; + export function readlinkSync(path: string): string; + export function realpath(path: string, callback?: (err: ErrnoException, resolvedPath: string) => any): void; + export function realpath(path: string, cache: {[path: string]: string}, callback: (err: ErrnoException, resolvedPath: string) =>any): void; + export function realpathSync(path: string, cache?: {[path: string]: string}): void; + export function unlink(path: string, callback?: (err?: ErrnoException) => void): void; + export function unlinkSync(path: string): void; + export function rmdir(path: string, callback?: (err?: ErrnoException) => void): void; + export function rmdirSync(path: string): void; + export function mkdir(path: string, callback?: (err?: ErrnoException) => void): void; + export function mkdir(path: string, mode: number, callback?: (err?: ErrnoException) => void): void; + export function mkdir(path: string, mode: string, callback?: (err?: ErrnoException) => void): void; + export function mkdirSync(path: string, mode?: number): void; + export function mkdirSync(path: string, mode?: string): void; + export function readdir(path: string, callback?: (err: ErrnoException, files: string[]) => void): void; + export function readdirSync(path: string): string[]; + export function close(fd: number, callback?: (err?: ErrnoException) => void): void; + export function closeSync(fd: number): void; + export function open(path: string, flags: string, callback?: (err: ErrnoException, fd: number) => any): void; + export function open(path: string, flags: string, mode: number, callback?: (err: ErrnoException, fd: number) => any): void; + export function open(path: string, flags: string, mode: string, callback?: (err: ErrnoException, fd: number) => any): void; + export function openSync(path: string, flags: string, mode?: number): number; + export function openSync(path: string, flags: string, mode?: string): number; + export function utimes(path: string, atime: number, mtime: number, callback?: (err?: ErrnoException) => void): void; + export function utimesSync(path: string, atime: number, mtime: number): void; + export function futimes(fd: number, atime: number, mtime: number, callback?: (err?: ErrnoException) => void): void; + export function futimesSync(fd: number, atime: number, mtime: number): void; + export function fsync(fd: number, callback?: (err?: ErrnoException) => void): void; + export function fsyncSync(fd: number): void; + export function write(fd: number, buffer: NodeBuffer, offset: number, length: number, position: number, callback?: (err: ErrnoException, written: number, buffer: NodeBuffer) => void): void; + export function writeSync(fd: number, buffer: NodeBuffer, offset: number, length: number, position: number): number; + export function read(fd: number, buffer: NodeBuffer, offset: number, length: number, position: number, callback?: (err: ErrnoException, bytesRead: number, buffer: NodeBuffer) => void): void; + export function readSync(fd: number, buffer: NodeBuffer, offset: number, length: number, position: number): number; + export function readFile(filename: string, options: { encoding?: string; flag?: string; }, callback: (err: ErrnoException, data: any) => void): void; + export function readFile(filename: string, callback: (err: ErrnoException, data: NodeBuffer) => void ): void; + export function readFileSync(filename: string, options?: { flag?: string; }): NodeBuffer; + export function readFileSync(filename: string, options: { encoding: string; flag?: string; }): string; + export function writeFile(filename: string, data: any, callback?: (err: ErrnoException) => void): void; + export function writeFile(filename: string, data: any, options: { encoding?: string; mode?: number; flag?: string; }, callback?: (err: ErrnoException) => void): void; + export function writeFile(filename: string, data: any, options: { encoding?: string; mode?: string; flag?: string; }, callback?: (err: ErrnoException) => void): void; + export function writeFileSync(filename: string, data: any, options?: { encoding?: string; mode?: number; flag?: string; }): void; + export function writeFileSync(filename: string, data: any, options?: { encoding?: string; mode?: string; flag?: string; }): void; + export function appendFile(filename: string, data: any, options: { encoding?: string; mode?: number; flag?: string; }, callback?: (err: ErrnoException) => void): void; + export function appendFile(filename: string, data: any, options: { encoding?: string; mode?: string; flag?: string; }, callback?: (err: ErrnoException) => void): void; + export function appendFile(filename: string, data: any, callback?: (err: ErrnoException) => void): void; + export function appendFileSync(filename: string, data: any, options?: { encoding?: string; mode?: number; flag?: string; }): void; + export function appendFileSync(filename: string, data: any, options?: { encoding?: string; mode?: string; flag?: string; }): void; + export function watchFile(filename: string, listener: (curr: Stats, prev: Stats) => void): void; + export function watchFile(filename: string, options: { persistent?: boolean; interval?: number; }, listener: (curr: Stats, prev: Stats) => void): void; + export function unwatchFile(filename: string, listener?: (curr: Stats, prev: Stats) => void): void; + export function watch(filename: string, listener?: (event: string, filename: string) => any): FSWatcher; + export function watch(filename: string, options: { persistent?: boolean; }, listener?: (event: string, filename: string) => any): FSWatcher; + export function exists(path: string, callback?: (exists: boolean) => void): void; + export function existsSync(path: string): boolean; + export function createReadStream(path: string, options?: { + flags?: string; + encoding?: string; + fd?: string; + mode?: number; + bufferSize?: number; + }): ReadStream; + export function createReadStream(path: string, options?: { + flags?: string; + encoding?: string; + fd?: string; + mode?: string; + bufferSize?: number; + }): ReadStream; + export function createWriteStream(path: string, options?: { + flags?: string; + encoding?: string; + string?: string; + }): WriteStream; +} + +declare module "path" { + export function normalize(p: string): string; + export function join(...paths: any[]): string; + export function resolve(...pathSegments: any[]): string; + export function relative(from: string, to: string): string; + export function dirname(p: string): string; + export function basename(p: string, ext?: string): string; + export function extname(p: string): string; + export var sep: string; +} + +declare module "string_decoder" { + export interface NodeStringDecoder { + write(buffer: NodeBuffer): string; + detectIncompleteChar(buffer: NodeBuffer): number; + } + export var StringDecoder: { + new (encoding: string): NodeStringDecoder; + }; +} + +declare module "tls" { + import crypto = require("crypto"); + import net = require("net"); + import stream = require("stream"); + + var CLIENT_RENEG_LIMIT: number; + var CLIENT_RENEG_WINDOW: number; + + export interface TlsOptions { + pfx?: any; //string or buffer + key?: any; //string or buffer + passphrase?: string; + cert?: any; + ca?: any; //string or buffer + crl?: any; //string or string array + ciphers?: string; + honorCipherOrder?: any; + requestCert?: boolean; + rejectUnauthorized?: boolean; + NPNProtocols?: any; //array or Buffer; + SNICallback?: (servername: string) => any; + } + + export interface ConnectionOptions { + host?: string; + port?: number; + socket?: net.NodeSocket; + pfx?: any; //string | Buffer + key?: any; //string | Buffer + passphrase?: string; + cert?: any; //string | Buffer + ca?: any; //Array of string | Buffer + rejectUnauthorized?: boolean; + NPNProtocols?: any; //Array of string | Buffer + servername?: string; + } + + export interface Server extends net.Server { + // Extended base methods + listen(port: number, host?: string, backlog?: number, listeningListener?: Function): void; + listen(path: string, listeningListener?: Function): void; + listen(handle: any, listeningListener?: Function): void; + + listen(port: number, host?: string, callback?: Function): void; + close(): void; + address(): { port: number; family: string; address: string; }; + addContext(hostName: string, credentials: { + key: string; + cert: string; + ca: string; + }): void; + maxConnections: number; + connections: number; + } + + export interface ClearTextStream extends ReadWriteStream { + authorized: boolean; + authorizationError: Error; + getPeerCertificate(): any; + getCipher: { + name: string; + version: string; + }; + address: { + port: number; + family: string; + address: string; + }; + remoteAddress: string; + remotePort: number; + } + + export interface SecurePair { + encrypted: any; + cleartext: any; + } + + export function createServer(options: TlsOptions, secureConnectionListener?: (cleartextStream: ClearTextStream) =>void ): Server; + export function connect(options: TlsOptions, secureConnectionListener?: () =>void ): ClearTextStream; + export function connect(port: number, host?: string, options?: ConnectionOptions, secureConnectListener?: () =>void ): ClearTextStream; + export function connect(port: number, options?: ConnectionOptions, secureConnectListener?: () =>void ): ClearTextStream; + export function createSecurePair(credentials?: crypto.Credentials, isServer?: boolean, requestCert?: boolean, rejectUnauthorized?: boolean): SecurePair; +} + +declare module "crypto" { + export interface CredentialDetails { + pfx: string; + key: string; + passphrase: string; + cert: string; + ca: any; //string | string array + crl: any; //string | string array + ciphers: string; + } + export interface Credentials { context?: any; } + export function createCredentials(details: CredentialDetails): Credentials; + export function createHash(algorithm: string): Hash; + export function createHmac(algorithm: string, key: string): Hmac; + interface Hash { + update(data: any, input_encoding?: string): Hash; + digest(encoding?: string): string; + } + interface Hmac { + update(data: any): void; + digest(encoding?: string): void; + } + export function createCipher(algorithm: string, password: any): Cipher; + export function createCipheriv(algorithm: string, key: any, iv: any): Cipher; + interface Cipher { + update(data: any, input_encoding?: string, output_encoding?: string): string; + final(output_encoding?: string): string; + setAutoPadding(auto_padding: boolean): void; + createDecipher(algorithm: string, password: any): Decipher; + createDecipheriv(algorithm: string, key: any, iv: any): Decipher; + } + interface Decipher { + update(data: any, input_encoding?: string, output_encoding?: string): void; + final(output_encoding?: string): string; + setAutoPadding(auto_padding: boolean): void; + } + export function createSign(algorithm: string): Signer; + interface Signer { + update(data: any): void; + sign(private_key: string, output_format: string): string; + } + export function createVerify(algorith: string): Verify; + interface Verify { + update(data: any): void; + verify(object: string, signature: string, signature_format?: string): boolean; + } + export function createDiffieHellman(prime_length: number): DiffieHellman; + export function createDiffieHellman(prime: number, encoding?: string): DiffieHellman; + interface DiffieHellman { + generateKeys(encoding?: string): string; + computeSecret(other_public_key: string, input_encoding?: string, output_encoding?: string): string; + getPrime(encoding?: string): string; + getGenerator(encoding: string): string; + getPublicKey(encoding?: string): string; + getPrivateKey(encoding?: string): string; + setPublicKey(public_key: string, encoding?: string): void; + setPrivateKey(public_key: string, encoding?: string): void; + } + export function getDiffieHellman(group_name: string): DiffieHellman; + export function pbkdf2(password: string, salt: string, iterations: number, keylen: number, callback: (err: Error, derivedKey: string) => any): void; + export function randomBytes(size: number): NodeBuffer; + export function randomBytes(size: number, callback: (err: Error, buf: NodeBuffer) =>void ): void; + export function pseudoRandomBytes(size: number): NodeBuffer; + export function pseudoRandomBytes(size: number, callback: (err: Error, buf: NodeBuffer) =>void ): void; +} + +declare module "stream" { + import events = require("events"); + + export interface ReadableOptions { + highWaterMark?: number; + encoding?: string; + objectMode?: boolean; + } + + export class Readable extends events.EventEmitter implements ReadableStream { + readable: boolean; + constructor(opts?: ReadableOptions); + _read(size: number): void; + read(size?: number): any; + setEncoding(encoding: string): void; + pause(): void; + resume(): void; + pipe(destination: T, options?: { end?: boolean; }): T; + unpipe(destination?: T): void; + unshift(chunk: string): void; + unshift(chunk: NodeBuffer): void; + wrap(oldStream: ReadableStream): ReadableStream; + push(chunk: any, encoding?: string): boolean; + } + + export interface WritableOptions { + highWaterMark?: number; + decodeStrings?: boolean; + } + + export class Writable extends events.EventEmitter implements WritableStream { + writable: boolean; + constructor(opts?: WritableOptions); + _write(data: NodeBuffer, encoding: string, callback: Function): void; + _write(data: string, encoding: string, callback: Function): void; + write(buffer: NodeBuffer, cb?: Function): boolean; + write(str: string, cb?: Function): boolean; + write(str: string, encoding?: string, cb?: Function): boolean; + end(): void; + end(buffer: NodeBuffer, cb?: Function): void; + end(str: string, cb?: Function): void; + end(str: string, encoding?: string, cb?: Function): void; + } + + export interface DuplexOptions extends ReadableOptions, WritableOptions { + allowHalfOpen?: boolean; + } + + // Note: Duplex extends both Readable and Writable. + export class Duplex extends Readable implements ReadWriteStream { + writable: boolean; + constructor(opts?: DuplexOptions); + _write(data: any, encoding: string, callback: Function): void; + write(str: any, cb?: Function): boolean; + write(str: any, encoding?: string, cb?: Function): boolean; + end(): void; + end(buffer: NodeBuffer, cb?: Function): void; + end(str: string, cb?: Function): void; + end(str: string, encoding?: string, cb?: Function): void; + } + + export interface TransformOptions extends ReadableOptions, WritableOptions {} + + // Note: Transform lacks the _read and _write methods of Readable/Writable. + export class Transform extends events.EventEmitter implements ReadWriteStream { + readable: boolean; + writable: boolean; + constructor(opts?: TransformOptions); + _transform(chunk: NodeBuffer, encoding: string, callback: Function): void; + _transform(chunk: string, encoding: string, callback: Function): void; + _flush(callback: Function): void; + read(size?: number): any; + setEncoding(encoding: string): void; + pause(): void; + resume(): void; + pipe(destination: T, options?: { end?: boolean; }): T; + unpipe(destination?: T): void; + unshift(chunk: string): void; + unshift(chunk: NodeBuffer): void; + wrap(oldStream: ReadableStream): ReadableStream; + push(chunk: any, encoding?: string): boolean; + write(buffer: NodeBuffer, cb?: Function): boolean; + write(str: string, cb?: Function): boolean; + write(str: string, encoding?: string, cb?: Function): boolean; + end(): void; + end(buffer: NodeBuffer, cb?: Function): void; + end(str: string, cb?: Function): void; + end(str: string, encoding?: string, cb?: Function): void; + } + + export class PassThrough extends Transform {} +} + +declare module "util" { + export interface InspectOptions { + showHidden?: boolean; + depth?: number; + colors?: boolean; + customInspect?: boolean; + } + + export function format(format: any, ...param: any[]): string; + export function debug(string: string): void; + export function error(...param: any[]): void; + export function puts(...param: any[]): void; + export function print(...param: any[]): void; + export function log(string: string): void; + export function inspect(object: any, showHidden?: boolean, depth?: number, color?: boolean): string; + export function inspect(object: any, options: InspectOptions): string; + export function isArray(object: any): boolean; + export function isRegExp(object: any): boolean; + export function isDate(object: any): boolean; + export function isError(object: any): boolean; + export function inherits(constructor: any, superConstructor: any): void; +} + +declare module "assert" { + function internal (value: any, message?: string): void; + module internal { + export class AssertionError implements Error { + name: string; + message: string; + actual: any; + expected: any; + operator: string; + generatedMessage: boolean; + + constructor(options?: {message?: string; actual?: any; expected?: any; + operator?: string; stackStartFunction?: Function}); + } + + export function fail(actual?: any, expected?: any, message?: string, operator?: string): void; + export function ok(value: any, message?: string): void; + export function equal(actual: any, expected: any, message?: string): void; + export function notEqual(actual: any, expected: any, message?: string): void; + export function deepEqual(actual: any, expected: any, message?: string): void; + export function notDeepEqual(acutal: any, expected: any, message?: string): void; + export function strictEqual(actual: any, expected: any, message?: string): void; + export function notStrictEqual(actual: any, expected: any, message?: string): void; + export var throws: { + (block: Function, message?: string): void; + (block: Function, error: Function, message?: string): void; + (block: Function, error: RegExp, message?: string): void; + (block: Function, error: (err: any) => boolean, message?: string): void; + } + + export var doesNotThrow: { + (block: Function, message?: string): void; + (block: Function, error: Function, message?: string): void; + (block: Function, error: RegExp, message?: string): void; + (block: Function, error: (err: any) => boolean, message?: string): void; + } + + export function ifError(value: any): void; + } + + export = internal; +} + +declare module "tty" { + import net = require("net"); + + export function isatty(fd: number): boolean; + export interface ReadStream extends net.NodeSocket { + isRaw: boolean; + setRawMode(mode: boolean): void; + } + export interface WriteStream extends net.NodeSocket { + columns: number; + rows: number; + } +} + +declare module "domain" { + import events = require("events"); + + export class Domain extends events.EventEmitter { + run(fn: Function): void; + add(emitter: NodeEventEmitter): void; + remove(emitter: NodeEventEmitter): void; + bind(cb: (err: Error, data: any) => any): any; + intercept(cb: (data: any) => any): any; + dispose(): void; + + addListener(event: string, listener: Function): Domain; + on(event: string, listener: Function): Domain; + once(event: string, listener: Function): Domain; + removeListener(event: string, listener: Function): Domain; + removeAllListeners(event?: string): Domain; + } + + export function create(): Domain; +} diff --git a/definitions/ref.d.ts b/definitions/ref.d.ts new file mode 100644 index 0000000..ab706ae --- /dev/null +++ b/definitions/ref.d.ts @@ -0,0 +1,7 @@ +/// +/// +/// +/// +/// +/// +/// diff --git a/definitions/uglify.d.ts b/definitions/uglify.d.ts new file mode 100644 index 0000000..8952f0c --- /dev/null +++ b/definitions/uglify.d.ts @@ -0,0 +1,827 @@ +declare module 'uglify-js' { + export function parse(code: string, options?: ParseOptions): AST_Toplevel; + + export interface ParseOptions { + strict?: boolean; + filename?: string; + toplevel?: AST_Toplevel; + } + + /** + * A setter/getter function. The `name` property is always null. + */ + export class AST_Accessor extends AST_Lambda { + } + + /** + * An array literal + */ + export class AST_Array extends AST_Node { + /** + * array of elements + */ + elements: AST_Node[]; + } + + /** + * An assignment expression — `a = b + 5` + */ + export class AST_Assign extends AST_Binary { + } + + /** + * Base class for atoms + */ + export class AST_Atom extends AST_Constant { + } + + /** + * Binary expression, i.e. `a + b` + */ + export class AST_Binary extends AST_Node { + /** + * left-hand side expression + */ + left: AST_Node; + /** + * the operator + */ + operator: string; + /** + * right-hand side expression + */ + right: AST_Node; + } + + /** + * A body of statements (usually bracketed) + */ + export class AST_Block extends AST_Statement { + /** + * an array of statements + */ + body: AST_Statement[]; + } + + /** + * A block statement + */ + export class AST_BlockStatement extends AST_Block { + } + + /** + * Base class for booleans + */ + export class AST_Boolean extends AST_Atom { + } + + /** + * A `break` statement + */ + export class AST_Break extends AST_LoopControl { + } + + /** + * A function call expression + */ + export class AST_Call extends AST_Node { + /** + * expression to invoke as function + */ + expression: AST_Node; + /** + * array of arguments + */ + args: AST_Node[]; + } + + /** + * A `case` switch branch + */ + export class AST_Case extends AST_SwitchBranch { + /** + * the `case` expression + */ + expression: AST_Node; + } + + /** + * A `catch` node; only makes sense as part of a `try` statement + */ + export class AST_Catch extends AST_Block { + /** + * symbol for the exception + */ + argname: AST_SymbolCatch; + } + + /** + * Conditional expression using the ternary operator, i.e. `a ? b : c` + */ + export class AST_Conditional extends AST_Node { + /** + * [AST_Node] + */ + condition: any; + /** + * [AST_Node] + */ + consequent: any; + /** + * [AST_Node] + */ + alternative: any; + } + + /** + * A `const` statement + */ + export class AST_Const extends AST_Definitions { + } + + /** + * Base class for all constants + */ + export class AST_Constant extends AST_Node { + } + + /** + * A `continue` statement + */ + export class AST_Continue extends AST_LoopControl { + } + + /** + * Base class for do/while statements + */ + export class AST_DWLoop extends AST_IterationStatement { + /** + * the loop condition. Should not be instanceof AST_Statement + */ + condition: AST_Node; + } + + /** + * Represents a debugger statement + */ + export class AST_Debugger extends AST_Statement { + } + + /** + * A `default` switch branch + */ + export class AST_Default extends AST_SwitchBranch { + } + + /** + * Base class for `var` or `const` nodes (variable declarations/initializations) + */ + export class AST_Definitions extends AST_Statement { + /** + * array of variable definitions + */ + definitions: AST_VarDef[]; + } + + /** + * A function definition + */ + export class AST_Defun extends AST_Lambda { + } + + /** + * Represents a directive, like "use strict"; + */ + export class AST_Directive extends AST_Statement { + /** + * The value of this directive as a plain string (it's not an AST_String!) + */ + value: string; + /** + * The scope that this directive affects. This property is only available after a call to toplevel.figure_out_scope + */ + scope: AST_Scope; + } + + /** + * A `do` statement + */ + export class AST_Do extends AST_DWLoop { + } + + /** + * A dotted property access expression + */ + export class AST_Dot extends AST_PropAccess { + } + + /** + * The empty statement (empty block or simply a semicolon) + */ + export class AST_EmptyStatement extends AST_Statement { + } + + /** + * Base class for “exits” (`return` and `throw`) + */ + export class AST_Exit extends AST_Jump { + /** + * the value returned or thrown by this statement; could be null for AST_Return + */ + value: AST_Node; + } + + /** + * The `false` atom + */ + export class AST_False extends AST_Boolean { + } + + /** + * A `finally` node; only makes sense as part of a `try` statement + */ + export class AST_Finally extends AST_Block { + } + + /** + * A `for` statement + */ + export class AST_For extends AST_IterationStatement { + /** + * the `for` initialization code, or null if empty + */ + init: AST_Node; + /** + * the `for` termination clause, or null if empty + */ + condition: AST_Node; + /** + * the `for` update clause, or null if empty + */ + step: AST_Node; + } + + /** + * A `for ... in` statement + */ + export class AST_ForIn extends AST_IterationStatement { + /** + * the `for/in` initialization code + */ + init: AST_Node; + /** + * the loop variable, only if `init` is AST_Var + */ + name: AST_SymbolRef; + /** + * the object that we're looping through + */ + object: AST_Node; + } + + /** + * A function expression + */ + export class AST_Function extends AST_Lambda { + } + + /** + * A hole in an array + */ + export class AST_Hole extends AST_Atom { + } + + /** + * A `if` statement + */ + export class AST_If extends AST_StatementWithBody { + /** + * the `if` condition + */ + condition: AST_Node; + /** + * the `else` part, or null if not present + */ + alternative: AST_Statement; + } + + /** + * The `Infinity` value + */ + export class AST_Infinity extends AST_Atom { + } + + /** + * Internal class. All loops inherit from it. + */ + export class AST_IterationStatement extends AST_StatementWithBody { + } + + /** + * Base class for “jumps” (for now that's `return`, `throw`, `break` and `continue`) + */ + export class AST_Jump extends AST_Statement { + } + + /** + * Symbol naming a label (declaration) + */ + export class AST_Label extends AST_Symbol { + /** + * a list of nodes referring to this label + */ + references: AST_LoopControl[]; + } + + /** + * Reference to a label symbol + */ + export class AST_LabelRef extends AST_Symbol { + } + + /** + * Statement with a label + */ + export class AST_LabeledStatement extends AST_StatementWithBody { + /** + * a label definition + */ + label: AST_Label; + } + + /** + * Base class for functions + */ + export class AST_Lambda extends AST_Scope { + /** + * the name of this function + */ + name: AST_SymbolDeclaration; + /** + * array of function arguments + */ + argnames: AST_SymbolFunarg[]; + /** + * tells whether this function accesses the arguments array. This property is only available after a call to toplevel.figure_out_scope + */ + uses_arguments: boolean; + } + + /** + * Base class for loop control statements (`break` and `continue`) + */ + export class AST_LoopControl extends AST_Jump { + /** + * the label, or null if none + */ + label: AST_LabelRef; + } + + /** + * The impossible value + */ + export class AST_NaN extends AST_Atom { + } + + /** + * An object instantiation. Derives from a function call since it has exactly the same properties + */ + export class AST_New extends AST_Call { + } + + /** + * Base class of all AST nodes + */ + export class AST_Node { + walk(visitor: TreeWalker); + /** + * The first token of this node + */ + start: AST_Token; + /** + * The last token of this node + */ + end: AST_Token; + } + + /** + * The `null` atom + */ + export class AST_Null extends AST_Atom { + } + + /** + * A number literal + */ + export class AST_Number extends AST_Constant { + /** + * the numeric value + */ + value: number; + } + + /** + * An object literal + */ + export class AST_Object extends AST_Node { + /** + * array of properties + */ + properties: AST_ObjectProperty[]; + } + + /** + * An object getter property + */ + export class AST_ObjectGetter extends AST_ObjectProperty { + } + + /** + * A key: value object property + */ + export class AST_ObjectKeyVal extends AST_ObjectProperty { + } + + /** + * Base class for literal object properties + */ + export class AST_ObjectProperty extends AST_Node { + /** + * the property name converted to a string for ObjectKeyVal. For setters and getters this is an arbitrary AST_Node. + */ + key: string; + /** + * property value. For setters and getters this is an AST_Function. + */ + value: AST_Node; + } + + /** + * An object setter property + */ + export class AST_ObjectSetter extends AST_ObjectProperty { + } + + /** + * Base class for property access expressions, i.e. `a.foo` or `a["foo"]` + */ + export class AST_PropAccess extends AST_Node { + /** + * the “container” expression + */ + expression: AST_Node; + /** + * the property to access. For AST_Dot this is always a plain string, while for AST_Sub it's an arbitrary AST_Node + */ + property: any; + } + + /** + * A regexp literal + */ + export class AST_RegExp extends AST_Constant { + /** + * the actual regexp + */ + value: RegExp; + } + + /** + * A `return` statement + */ + export class AST_Return extends AST_Exit { + } + + /** + * Base class for all statements introducing a lexical scope + */ + export class AST_Scope extends AST_Block { + /** + * an array of directives declared in this scope. This property is only available after a call to toplevel.figure_out_scope + */ + directives: string[]; + /** + * a map of name -> SymbolDef for all variables/functions defined in this scope. This property is only available after a call to toplevel.figure_out_scope + */ + variables: Object; + /** + * like `variables`, but only lists function declarations. This property is only available after a call to toplevel.figure_out_scope + */ + functions: Object; + /** + * tells whether this scope uses the `with` statement. This property is only available after a call to toplevel.figure_out_scope + */ + uses_with: boolean; + /** + * tells whether this scope contains a direct call to the global `eval`. This property is only available after a call to toplevel.figure_out_scope + */ + uses_eval: boolean; + /** + * link to the parent scope. This property is only available after a call to toplevel.figure_out_scope + */ + parent_scope: AST_Scope; + /** + * a list of all symbol definitions that are accessed from this scope or any subscopes. This property is only available after a call to toplevel.figure_out_scope + */ + enclosed: SymbolDef[]; + /** + * current index for mangling variables (used internally by the mangler). This property is only available after a call to toplevel.figure_out_scope + */ + cname: number; + } + + /** + * A sequence expression (two comma-separated expressions) + */ + export class AST_Seq extends AST_Node { + /** + * first element in sequence + */ + car: AST_Node; + /** + * second element in sequence + */ + cdr: AST_Node; + } + + /** + * A statement consisting of an expression, i.e. a = 1 + 2 + */ + export class AST_SimpleStatement extends AST_Statement { + /** + * an expression node (should not be instanceof AST_Statement) + */ + body: AST_Node; + } + + /** + * Base class of all statements + */ + export class AST_Statement extends AST_Node { + } + + /** + * Base class for all statements that contain one nested body: `For`, `ForIn`, `Do`, `While`, `With` + */ + export class AST_StatementWithBody extends AST_Statement { + /** + * the body; this should always be present, even if it's an AST_EmptyStatement + */ + body: AST_Statement; + } + + /** + * A string literal + */ + export class AST_String extends AST_Constant { + /** + * the contents of this string + */ + value: string; + } + + /** + * Index-style property access, i.e. `a["foo"]` + */ + export class AST_Sub extends AST_PropAccess { + } + + /** + * A `switch` statement + */ + export class AST_Switch extends AST_Block { + /** + * the `switch` “discriminant” + */ + expression: AST_Node; + } + + /** + * Base class for `switch` branches + */ + export class AST_SwitchBranch extends AST_Block { + } + + /** + * Base class for all symbols + */ + export class AST_Symbol extends AST_Node { + /** + * the current scope (not necessarily the definition scope). This property is only available after a call to toplevel.figure_out_scope + */ + scope: AST_Scope; + /** + * name of this symbol + */ + name: string; + /** + * the definition of this symbol. This property is only available after a call to toplevel.figure_out_scope + */ + thedef: SymbolDef; + } + + /** + * The name of a property accessor (setter/getter function) + */ + export class AST_SymbolAccessor extends AST_Symbol { + } + + /** + * Symbol naming the exception in catch + */ + export class AST_SymbolCatch extends AST_SymbolDeclaration { + } + + /** + * A constant declaration + */ + export class AST_SymbolConst extends AST_SymbolDeclaration { + } + + /** + * A declaration symbol (symbol in var/const, function name or argument, symbol in catch) + */ + export class AST_SymbolDeclaration extends AST_Symbol { + /** + * array of initializers for this declaration.. This property is only available after a call to toplevel.figure_out_scope + */ + init: AST_Node[]; + } + + /** + * Symbol defining a function + */ + export class AST_SymbolDefun extends AST_SymbolDeclaration { + } + + /** + * Symbol naming a function argument + */ + export class AST_SymbolFunarg extends AST_SymbolVar { + } + + /** + * Symbol naming a function expression + */ + export class AST_SymbolLambda extends AST_SymbolDeclaration { + } + + /** + * Reference to some symbol (not definition/declaration) + */ + export class AST_SymbolRef extends AST_Symbol { + } + + /** + * Symbol defining a variable + */ + export class AST_SymbolVar extends AST_SymbolDeclaration { + } + + /** + * The `this` symbol + */ + export class AST_This extends AST_Symbol { + } + + /** + * A `throw` statement + */ + export class AST_Throw extends AST_Exit { + } + + export class AST_Token { + type: any; + value: any; + line: any; + col: any; + pos: any; + endpos: any; + nlb: any; + comments_before: any; + file: any; + } + + /** + * The toplevel scope + */ + export class AST_Toplevel extends AST_Scope { + figure_out_scope(options?: {screw_ie8:boolean}); + /** + * a map of name -> SymbolDef for all undeclared names. This property is only available after a call to toplevel.figure_out_scope + */ + globals: Object; + } + + /** + * The `true` atom + */ + export class AST_True extends AST_Boolean { + } + + /** + * A `try` statement + */ + export class AST_Try extends AST_Block { + /** + * the catch block, or null if not present + */ + bcatch: AST_Catch; + /** + * the finally block, or null if not present + */ + bfinally: AST_Finally; + } + + /** + * Base class for unary expressions + */ + export class AST_Unary extends AST_Node { + /** + * the operator + */ + operator: string; + /** + * expression that this unary operator applies to + */ + expression: AST_Node; + } + + /** + * Unary postfix expression, i.e. `i++` + */ + export class AST_UnaryPostfix extends AST_Unary { + } + + /** + * Unary prefix expression, i.e. `typeof i` or `++i` + */ + export class AST_UnaryPrefix extends AST_Unary { + } + + /** + * The `undefined` value + */ + export class AST_Undefined extends AST_Atom { + } + + /** + * A `var` statement + */ + export class AST_Var extends AST_Definitions { + } + + /** + * A variable declaration; only appears in a AST_Definitions node + */ + export class AST_VarDef extends AST_Node { + /** + * name of the variable + */ + name: any; + /** + * initializer, or null of there's no initializer + */ + value: AST_Node; + } + + /** + * A `while` statement + */ + export class AST_While extends AST_DWLoop { + } + + /** + * A `with` statement + */ + export class AST_With extends AST_StatementWithBody { + /** + * the `with` expression + */ + expression: AST_Node; + } + + + + export class SymbolDef { + name: string; + orig: AST_SymbolDeclaration[]; + scope: AST_Scope; + references: AST_SymbolRef[]; + global: boolean; + undeclared: boolean; + constant: boolean; + mangled_name: boolean; + } + + export class TreeWalker { + constructor(visitor: (node: AST_Node, descend: () => void) => boolean); + constructor(visitor: (node: AST_Node, descend: () => void) => void); + + parent(n?: number): AST_Node; + stack: AST_Node[]; + find_parent(type: { new(): T} ): T; + in_boolean_context(): boolean; + loopcontrol_target(label?: string): AST_Block; + } +} diff --git a/definitions/vinyl.d.ts b/definitions/vinyl.d.ts new file mode 100644 index 0000000..ab3ab93 --- /dev/null +++ b/definitions/vinyl.d.ts @@ -0,0 +1,54 @@ +/// + + +declare module 'vinyl' { + import fs = require('fs'); + import stream = require('stream'); + + class File { + constructor(options: File.FileOptions); + + cwd: string; + base: string; + path: string; + + stat: fs.Stats; + + isBuffer(): boolean; + isStream(): boolean; + isNull(): boolean; + + clone(): File; + + pipe(stream: stream.Writable, opt?: any); + + inspect(): string; + + relative: string; + + contents: any; + } + + module File { + export interface FileOptions { + cwd?: string; + base?: string; + path: string; + + stat?: fs.Stats; + + contents: any; // Buffer or stream + } + + export interface FileBuffer extends File { + clone(): FileBuffer; + contents: NodeBuffer; + } + export interface FileStream extends File { + clone(): FileStream; + contents: stream.Readable; + } + } + + export = File; +} diff --git a/examples/big/a.js b/examples/big/a.js new file mode 100644 index 0000000..7f3105f --- /dev/null +++ b/examples/big/a.js @@ -0,0 +1,28 @@ +exports.ipsum = require('./ipsum'); +exports.sit = require('./sit'); +exports.nullam = require('./nullam'); +exports.odio = require('./odio'); +exports.tortor = require('./tortor'); +exports.ac = require('./ac'); +exports.nullam = require('./nullam'); +exports.pellentesque = require('./pellentesque'); +exports.cursus = require('./cursus'); +exports.cras = require('./cras'); +exports.semper = require('./semper'); +exports.malesuada = require('./malesuada'); +exports.elementum = require('./elementum'); +exports.pretium = require('./pretium'); +exports.sodales = require('./sodales'); +exports.tortor = require('./tortor'); +exports.risus = require('./risus'); +exports.hendrerit = require('./hendrerit'); +exports.tristique = require('./tristique'); +exports.vel = require('./vel'); +exports.non = require('./non'); +exports.mattis = require('./mattis'); +exports.dolor = require('./dolor'); +exports.nisi = require('./nisi'); +exports.quis = require('./quis'); +exports.mi = require('./mi'); +exports.mauris = require('./mauris'); +exports.in = require('./in'); diff --git a/examples/big/ac.js b/examples/big/ac.js new file mode 100644 index 0000000..ed81d25 --- /dev/null +++ b/examples/big/ac.js @@ -0,0 +1,10 @@ +module.exports = { + dolor: require('./dolor'), + elit: require('./elit'), + rutrum: require('./rutrum'), + interdum: require('./interdum'), + mollis: require('./mollis'), + etiam: require('./etiam'), + nunc: require('./nunc'), + ornare: require('./ornare') +}; diff --git a/examples/big/adipiscing.js b/examples/big/adipiscing.js new file mode 100644 index 0000000..3593ba7 --- /dev/null +++ b/examples/big/adipiscing.js @@ -0,0 +1 @@ +exports.lorem = require('./lorem'); diff --git a/examples/big/aenean.js b/examples/big/aenean.js new file mode 100644 index 0000000..8ed0cea --- /dev/null +++ b/examples/big/aenean.js @@ -0,0 +1,22 @@ +exports.lorem = require('./lorem'); +exports.mi = require('./mi'); +exports.pellentesque = require('./pellentesque'); +exports.egestas = require('./egestas'); +exports.pulvinar = require('./pulvinar'); +exports.at = require('./at'); +exports.nisi = require('./nisi'); +exports.nec = require('./nec'); +exports.diam = require('./diam'); +exports.sit = require('./sit'); +exports.ipsum = require('./ipsum'); +exports.porta = require('./porta'); +exports.suscipit = require('./suscipit'); +exports.et = require('./et'); +exports.viverra = require('./viverra'); +exports.ultrices = require('./ultrices'); +exports.at = require('./at'); +exports.vehicula = require('./vehicula'); +exports.dui = require('./dui'); +exports.nibh = require('./nibh'); +exports.mattis = require('./mattis'); +exports.imperdiet = require('./imperdiet'); diff --git a/examples/big/aliquam.js b/examples/big/aliquam.js new file mode 100644 index 0000000..10170bf --- /dev/null +++ b/examples/big/aliquam.js @@ -0,0 +1,39 @@ +exports.amet = require('./amet'); +exports.consectetur = require('./consectetur'); +exports.adipiscing = require('./adipiscing'); +exports.lobortis = require('./lobortis'); +exports.in = require('./in'); +exports.scelerisque = require('./scelerisque'); +exports.vulputate = require('./vulputate'); +exports.at = require('./at'); +exports.facilisis = require('./facilisis'); +exports.urna = require('./urna'); +exports.donec = require('./donec'); +exports.morbi = require('./morbi'); +exports.eleifend = require('./eleifend'); +exports.quisque = require('./quisque'); +exports.justo = require('./justo'); +exports.vehicula = require('./vehicula'); +exports.nunc = require('./nunc'); +exports.pharetra = require('./pharetra'); +exports.lacus = require('./lacus'); +exports.pulvinar = require('./pulvinar'); +exports.ac = require('./ac'); +exports.at = require('./at'); +exports.aenean = require('./aenean'); +exports.odio = require('./odio'); +exports.ac = require('./ac'); +exports.erat = require('./erat'); +exports.nam = require('./nam'); +exports.justo = require('./justo'); +exports.aliquet = require('./aliquet'); +exports.scelerisque = require('./scelerisque'); +exports.metus = require('./metus'); +exports.volutpat = require('./volutpat'); +exports.ac = require('./ac'); +exports.venenatis = require('./venenatis'); +exports.justo = require('./justo'); +exports.quam = require('./quam'); +exports.quis = require('./quis'); +exports.augue = require('./augue'); +exports.euismod = require('./euismod'); diff --git a/examples/big/aliquet.js b/examples/big/aliquet.js new file mode 100644 index 0000000..49c6cc8 --- /dev/null +++ b/examples/big/aliquet.js @@ -0,0 +1,7 @@ +this.ipsum = require('./ipsum'); +this.sit = require('./sit'); +this.nullam = require('./nullam'); +this.odio = require('./odio'); +this.tortor = require('./tortor'); +this.ac = require('./ac'); +this.nullam = require('./nullam'); diff --git a/examples/big/amet.js b/examples/big/amet.js new file mode 100644 index 0000000..0156647 --- /dev/null +++ b/examples/big/amet.js @@ -0,0 +1 @@ +module.exports.lorem = require('./lorem'); diff --git a/examples/big/ante.js b/examples/big/ante.js new file mode 100644 index 0000000..a3c37d4 --- /dev/null +++ b/examples/big/ante.js @@ -0,0 +1,36 @@ +module.exports = { + amet: require('./amet'), + consectetur: require('./consectetur'), + adipiscing: require('./adipiscing'), + lobortis: require('./lobortis'), + in: require('./in'), + scelerisque: require('./scelerisque'), + vulputate: require('./vulputate'), + at: require('./at'), + facilisis: require('./facilisis'), + urna: require('./urna'), + donec: require('./donec'), + morbi: require('./morbi'), + eleifend: require('./eleifend'), + quisque: require('./quisque'), + justo: require('./justo'), + vehicula: require('./vehicula'), + nunc: require('./nunc'), + pharetra: require('./pharetra'), + lacus: require('./lacus'), + pulvinar: require('./pulvinar'), + ac: require('./ac'), + at: require('./at'), + aenean: require('./aenean'), + odio: require('./odio'), + ac: require('./ac'), + erat: require('./erat'), + nam: require('./nam'), + justo: require('./justo'), + aliquet: require('./aliquet'), + scelerisque: require('./scelerisque'), + metus: require('./metus'), + volutpat: require('./volutpat'), + ac: require('./ac'), + venenatis: require('./venenatis') +}; diff --git a/examples/big/at.js b/examples/big/at.js new file mode 100644 index 0000000..ade10cf --- /dev/null +++ b/examples/big/at.js @@ -0,0 +1,6 @@ +exports.amet = require('./amet'); +exports.consectetur = require('./consectetur'); +exports.adipiscing = require('./adipiscing'); +exports.lobortis = require('./lobortis'); +exports.in = require('./in'); +exports.scelerisque = require('./scelerisque'); diff --git a/examples/big/auctor.js b/examples/big/auctor.js new file mode 100644 index 0000000..4b88d76 --- /dev/null +++ b/examples/big/auctor.js @@ -0,0 +1,32 @@ +exports.amet = require('./amet'); +exports.consectetur = require('./consectetur'); +exports.adipiscing = require('./adipiscing'); +exports.lobortis = require('./lobortis'); +exports.in = require('./in'); +exports.scelerisque = require('./scelerisque'); +exports.vulputate = require('./vulputate'); +exports.at = require('./at'); +exports.facilisis = require('./facilisis'); +exports.urna = require('./urna'); +exports.donec = require('./donec'); +exports.morbi = require('./morbi'); +exports.eleifend = require('./eleifend'); +exports.quisque = require('./quisque'); +exports.justo = require('./justo'); +exports.vehicula = require('./vehicula'); +exports.nunc = require('./nunc'); +exports.pharetra = require('./pharetra'); +exports.lacus = require('./lacus'); +exports.pulvinar = require('./pulvinar'); +exports.ac = require('./ac'); +exports.at = require('./at'); +exports.aenean = require('./aenean'); +exports.odio = require('./odio'); +exports.ac = require('./ac'); +exports.erat = require('./erat'); +exports.nam = require('./nam'); +exports.justo = require('./justo'); +exports.aliquet = require('./aliquet'); +exports.scelerisque = require('./scelerisque'); +exports.metus = require('./metus'); +exports.volutpat = require('./volutpat'); diff --git a/examples/big/augue.js b/examples/big/augue.js new file mode 100644 index 0000000..cadc58c --- /dev/null +++ b/examples/big/augue.js @@ -0,0 +1,33 @@ +module.exports = { + lorem: require('./lorem'), + mi: require('./mi'), + pellentesque: require('./pellentesque'), + egestas: require('./egestas'), + pulvinar: require('./pulvinar'), + at: require('./at'), + nisi: require('./nisi'), + nec: require('./nec'), + diam: require('./diam'), + sit: require('./sit'), + ipsum: require('./ipsum'), + porta: require('./porta'), + suscipit: require('./suscipit'), + et: require('./et'), + viverra: require('./viverra'), + ultrices: require('./ultrices'), + at: require('./at'), + vehicula: require('./vehicula'), + dui: require('./dui'), + nibh: require('./nibh'), + mattis: require('./mattis'), + imperdiet: require('./imperdiet'), + integer: require('./integer'), + varius: require('./varius'), + in: require('./in'), + auctor: require('./auctor'), + urna: require('./urna'), + auctor: require('./auctor'), + ante: require('./ante'), + sed: require('./sed'), + sed: require('./sed') +}; diff --git a/examples/big/commodo.js b/examples/big/commodo.js new file mode 100644 index 0000000..3adc41d --- /dev/null +++ b/examples/big/commodo.js @@ -0,0 +1,35 @@ +exports.dolor = require('./dolor'); +exports.elit = require('./elit'); +exports.rutrum = require('./rutrum'); +exports.interdum = require('./interdum'); +exports.mollis = require('./mollis'); +exports.etiam = require('./etiam'); +exports.nunc = require('./nunc'); +exports.ornare = require('./ornare'); +exports.eros = require('./eros'); +exports.nulla = require('./nulla'); +exports.pulvinar = require('./pulvinar'); +exports.aliquet = require('./aliquet'); +exports.ligula = require('./ligula'); +exports.ullamcorper = require('./ullamcorper'); +exports.amet = require('./amet'); +exports.vulputate = require('./vulputate'); +exports.lorem = require('./lorem'); +exports.libero = require('./libero'); +exports.tincidunt = require('./tincidunt'); +exports.felis = require('./felis'); +exports.nisi = require('./nisi'); +exports.sed = require('./sed'); +exports.felis = require('./felis'); +exports.ligula = require('./ligula'); +exports.vulputate = require('./vulputate'); +exports.nam = require('./nam'); +exports.viverra = require('./viverra'); +exports.metus = require('./metus'); +exports.tellus = require('./tellus'); +exports.lectus = require('./lectus'); +exports.urna = require('./urna'); +exports.neque = require('./neque'); +exports.mauris = require('./mauris'); +exports.a = require('./a'); +exports.posuere = require('./posuere'); diff --git a/examples/big/condimentum.js b/examples/big/condimentum.js new file mode 100644 index 0000000..6c22a6d --- /dev/null +++ b/examples/big/condimentum.js @@ -0,0 +1,33 @@ +this.ipsum = require('./ipsum'); +this.sit = require('./sit'); +this.nullam = require('./nullam'); +this.odio = require('./odio'); +this.tortor = require('./tortor'); +this.ac = require('./ac'); +this.nullam = require('./nullam'); +this.pellentesque = require('./pellentesque'); +this.cursus = require('./cursus'); +this.cras = require('./cras'); +this.semper = require('./semper'); +this.malesuada = require('./malesuada'); +this.elementum = require('./elementum'); +this.pretium = require('./pretium'); +this.sodales = require('./sodales'); +this.tortor = require('./tortor'); +this.risus = require('./risus'); +this.hendrerit = require('./hendrerit'); +this.tristique = require('./tristique'); +this.vel = require('./vel'); +this.non = require('./non'); +this.mattis = require('./mattis'); +this.dolor = require('./dolor'); +this.nisi = require('./nisi'); +this.quis = require('./quis'); +this.mi = require('./mi'); +this.mauris = require('./mauris'); +this.in = require('./in'); +this.porttitor = require('./porttitor'); +this.commodo = require('./commodo'); +this.vel = require('./vel'); +this.porta = require('./porta'); +this.vel = require('./vel'); diff --git a/examples/big/consectetur.js b/examples/big/consectetur.js new file mode 100644 index 0000000..9ad231d --- /dev/null +++ b/examples/big/consectetur.js @@ -0,0 +1,3 @@ +module.exports = { + lorem: require('./lorem') +}; diff --git a/examples/big/cras.js b/examples/big/cras.js new file mode 100644 index 0000000..d9872dc --- /dev/null +++ b/examples/big/cras.js @@ -0,0 +1,12 @@ +module.exports.dolor = require('./dolor'); +module.exports.elit = require('./elit'); +module.exports.rutrum = require('./rutrum'); +module.exports.interdum = require('./interdum'); +module.exports.mollis = require('./mollis'); +module.exports.etiam = require('./etiam'); +module.exports.nunc = require('./nunc'); +module.exports.ornare = require('./ornare'); +module.exports.eros = require('./eros'); +module.exports.nulla = require('./nulla'); +module.exports.pulvinar = require('./pulvinar'); +module.exports.aliquet = require('./aliquet'); diff --git a/examples/big/cursus.js b/examples/big/cursus.js new file mode 100644 index 0000000..41f50d6 --- /dev/null +++ b/examples/big/cursus.js @@ -0,0 +1,12 @@ +exports.dolor = require('./dolor'); +exports.elit = require('./elit'); +exports.rutrum = require('./rutrum'); +exports.interdum = require('./interdum'); +exports.mollis = require('./mollis'); +exports.etiam = require('./etiam'); +exports.nunc = require('./nunc'); +exports.ornare = require('./ornare'); +exports.eros = require('./eros'); +exports.nulla = require('./nulla'); +exports.pulvinar = require('./pulvinar'); +exports.aliquet = require('./aliquet'); diff --git a/examples/big/diam.js b/examples/big/diam.js new file mode 100644 index 0000000..a12ff65 --- /dev/null +++ b/examples/big/diam.js @@ -0,0 +1,13 @@ +module.exports = { + amet: require('./amet'), + consectetur: require('./consectetur'), + adipiscing: require('./adipiscing'), + lobortis: require('./lobortis'), + in: require('./in'), + scelerisque: require('./scelerisque'), + vulputate: require('./vulputate'), + at: require('./at'), + facilisis: require('./facilisis'), + urna: require('./urna'), + donec: require('./donec') +}; diff --git a/examples/big/dolor.js b/examples/big/dolor.js new file mode 100644 index 0000000..cfd08ed --- /dev/null +++ b/examples/big/dolor.js @@ -0,0 +1 @@ +exports.ipsum = require('./ipsum'); diff --git a/examples/big/donec.js b/examples/big/donec.js new file mode 100644 index 0000000..3364b2a --- /dev/null +++ b/examples/big/donec.js @@ -0,0 +1,8 @@ +this.lorem = require('./lorem'); +this.mi = require('./mi'); +this.pellentesque = require('./pellentesque'); +this.egestas = require('./egestas'); +this.pulvinar = require('./pulvinar'); +this.at = require('./at'); +this.nisi = require('./nisi'); +this.nec = require('./nec'); diff --git a/examples/big/dui.js b/examples/big/dui.js new file mode 100644 index 0000000..064fd41 --- /dev/null +++ b/examples/big/dui.js @@ -0,0 +1,20 @@ +module.exports = { + amet: require('./amet'), + consectetur: require('./consectetur'), + adipiscing: require('./adipiscing'), + lobortis: require('./lobortis'), + in: require('./in'), + scelerisque: require('./scelerisque'), + vulputate: require('./vulputate'), + at: require('./at'), + facilisis: require('./facilisis'), + urna: require('./urna'), + donec: require('./donec'), + morbi: require('./morbi'), + eleifend: require('./eleifend'), + quisque: require('./quisque'), + justo: require('./justo'), + vehicula: require('./vehicula'), + nunc: require('./nunc'), + pharetra: require('./pharetra') +}; diff --git a/examples/big/egestas.js b/examples/big/egestas.js new file mode 100644 index 0000000..cccf5be --- /dev/null +++ b/examples/big/egestas.js @@ -0,0 +1,5 @@ +exports.amet = require('./amet'); +exports.consectetur = require('./consectetur'); +exports.adipiscing = require('./adipiscing'); +exports.lobortis = require('./lobortis'); +exports.in = require('./in'); diff --git a/examples/big/eleifend.js b/examples/big/eleifend.js new file mode 100644 index 0000000..ee60be8 --- /dev/null +++ b/examples/big/eleifend.js @@ -0,0 +1,14 @@ +exports.lorem = require('./lorem'); +exports.mi = require('./mi'); +exports.pellentesque = require('./pellentesque'); +exports.egestas = require('./egestas'); +exports.pulvinar = require('./pulvinar'); +exports.at = require('./at'); +exports.nisi = require('./nisi'); +exports.nec = require('./nec'); +exports.diam = require('./diam'); +exports.sit = require('./sit'); +exports.ipsum = require('./ipsum'); +exports.porta = require('./porta'); +exports.suscipit = require('./suscipit'); +exports.et = require('./et'); diff --git a/examples/big/elementum.js b/examples/big/elementum.js new file mode 100644 index 0000000..b5b568c --- /dev/null +++ b/examples/big/elementum.js @@ -0,0 +1,15 @@ +module.exports.dolor = require('./dolor'); +module.exports.elit = require('./elit'); +module.exports.rutrum = require('./rutrum'); +module.exports.interdum = require('./interdum'); +module.exports.mollis = require('./mollis'); +module.exports.etiam = require('./etiam'); +module.exports.nunc = require('./nunc'); +module.exports.ornare = require('./ornare'); +module.exports.eros = require('./eros'); +module.exports.nulla = require('./nulla'); +module.exports.pulvinar = require('./pulvinar'); +module.exports.aliquet = require('./aliquet'); +module.exports.ligula = require('./ligula'); +module.exports.ullamcorper = require('./ullamcorper'); +module.exports.amet = require('./amet'); diff --git a/examples/big/elit.js b/examples/big/elit.js new file mode 100644 index 0000000..623b04d --- /dev/null +++ b/examples/big/elit.js @@ -0,0 +1,2 @@ +exports.ipsum = require('./ipsum'); +exports.sit = require('./sit'); diff --git a/examples/big/erat.js b/examples/big/erat.js new file mode 100644 index 0000000..30bd742 --- /dev/null +++ b/examples/big/erat.js @@ -0,0 +1,24 @@ +exports.lorem = require('./lorem'); +exports.mi = require('./mi'); +exports.pellentesque = require('./pellentesque'); +exports.egestas = require('./egestas'); +exports.pulvinar = require('./pulvinar'); +exports.at = require('./at'); +exports.nisi = require('./nisi'); +exports.nec = require('./nec'); +exports.diam = require('./diam'); +exports.sit = require('./sit'); +exports.ipsum = require('./ipsum'); +exports.porta = require('./porta'); +exports.suscipit = require('./suscipit'); +exports.et = require('./et'); +exports.viverra = require('./viverra'); +exports.ultrices = require('./ultrices'); +exports.at = require('./at'); +exports.vehicula = require('./vehicula'); +exports.dui = require('./dui'); +exports.nibh = require('./nibh'); +exports.mattis = require('./mattis'); +exports.imperdiet = require('./imperdiet'); +exports.integer = require('./integer'); +exports.varius = require('./varius'); diff --git a/examples/big/eros.js b/examples/big/eros.js new file mode 100644 index 0000000..2733cb3 --- /dev/null +++ b/examples/big/eros.js @@ -0,0 +1,6 @@ +this.ipsum = require('./ipsum'); +this.sit = require('./sit'); +this.nullam = require('./nullam'); +this.odio = require('./odio'); +this.tortor = require('./tortor'); +this.ac = require('./ac'); diff --git a/examples/big/est.js b/examples/big/est.js new file mode 100644 index 0000000..63db61c --- /dev/null +++ b/examples/big/est.js @@ -0,0 +1,45 @@ +module.exports.ipsum = require('./ipsum'); +module.exports.sit = require('./sit'); +module.exports.nullam = require('./nullam'); +module.exports.odio = require('./odio'); +module.exports.tortor = require('./tortor'); +module.exports.ac = require('./ac'); +module.exports.nullam = require('./nullam'); +module.exports.pellentesque = require('./pellentesque'); +module.exports.cursus = require('./cursus'); +module.exports.cras = require('./cras'); +module.exports.semper = require('./semper'); +module.exports.malesuada = require('./malesuada'); +module.exports.elementum = require('./elementum'); +module.exports.pretium = require('./pretium'); +module.exports.sodales = require('./sodales'); +module.exports.tortor = require('./tortor'); +module.exports.risus = require('./risus'); +module.exports.hendrerit = require('./hendrerit'); +module.exports.tristique = require('./tristique'); +module.exports.vel = require('./vel'); +module.exports.non = require('./non'); +module.exports.mattis = require('./mattis'); +module.exports.dolor = require('./dolor'); +module.exports.nisi = require('./nisi'); +module.exports.quis = require('./quis'); +module.exports.mi = require('./mi'); +module.exports.mauris = require('./mauris'); +module.exports.in = require('./in'); +module.exports.porttitor = require('./porttitor'); +module.exports.commodo = require('./commodo'); +module.exports.vel = require('./vel'); +module.exports.porta = require('./porta'); +module.exports.vel = require('./vel'); +module.exports.quis = require('./quis'); +module.exports.iaculis = require('./iaculis'); +module.exports.a = require('./a'); +module.exports.viverra = require('./viverra'); +module.exports.egestas = require('./egestas'); +module.exports.donec = require('./donec'); +module.exports.pharetra = require('./pharetra'); +module.exports.tortor = require('./tortor'); +module.exports.adipiscing = require('./adipiscing'); +module.exports.amet = require('./amet'); +module.exports.et = require('./et'); +module.exports.scelerisque = require('./scelerisque'); diff --git a/examples/big/et.js b/examples/big/et.js new file mode 100644 index 0000000..b6188e4 --- /dev/null +++ b/examples/big/et.js @@ -0,0 +1,14 @@ +module.exports = { + amet: require('./amet'), + consectetur: require('./consectetur'), + adipiscing: require('./adipiscing'), + lobortis: require('./lobortis'), + in: require('./in'), + scelerisque: require('./scelerisque'), + vulputate: require('./vulputate'), + at: require('./at'), + facilisis: require('./facilisis'), + urna: require('./urna'), + donec: require('./donec'), + morbi: require('./morbi') +}; diff --git a/examples/big/etiam.js b/examples/big/etiam.js new file mode 100644 index 0000000..f1b85ce --- /dev/null +++ b/examples/big/etiam.js @@ -0,0 +1,4 @@ +module.exports.ipsum = require('./ipsum'); +module.exports.sit = require('./sit'); +module.exports.nullam = require('./nullam'); +module.exports.odio = require('./odio'); diff --git a/examples/big/euismod.js b/examples/big/euismod.js new file mode 100644 index 0000000..8761693 --- /dev/null +++ b/examples/big/euismod.js @@ -0,0 +1,31 @@ +exports.lorem = require('./lorem'); +exports.mi = require('./mi'); +exports.pellentesque = require('./pellentesque'); +exports.egestas = require('./egestas'); +exports.pulvinar = require('./pulvinar'); +exports.at = require('./at'); +exports.nisi = require('./nisi'); +exports.nec = require('./nec'); +exports.diam = require('./diam'); +exports.sit = require('./sit'); +exports.ipsum = require('./ipsum'); +exports.porta = require('./porta'); +exports.suscipit = require('./suscipit'); +exports.et = require('./et'); +exports.viverra = require('./viverra'); +exports.ultrices = require('./ultrices'); +exports.at = require('./at'); +exports.vehicula = require('./vehicula'); +exports.dui = require('./dui'); +exports.nibh = require('./nibh'); +exports.mattis = require('./mattis'); +exports.imperdiet = require('./imperdiet'); +exports.integer = require('./integer'); +exports.varius = require('./varius'); +exports.in = require('./in'); +exports.auctor = require('./auctor'); +exports.urna = require('./urna'); +exports.auctor = require('./auctor'); +exports.ante = require('./ante'); +exports.sed = require('./sed'); +exports.sed = require('./sed'); diff --git a/examples/big/facilisis.js b/examples/big/facilisis.js new file mode 100644 index 0000000..4aa125a --- /dev/null +++ b/examples/big/facilisis.js @@ -0,0 +1,7 @@ +module.exports.lorem = require('./lorem'); +module.exports.mi = require('./mi'); +module.exports.pellentesque = require('./pellentesque'); +module.exports.egestas = require('./egestas'); +module.exports.pulvinar = require('./pulvinar'); +module.exports.at = require('./at'); +module.exports.nisi = require('./nisi'); diff --git a/examples/big/felis.js b/examples/big/felis.js new file mode 100644 index 0000000..1c421bd --- /dev/null +++ b/examples/big/felis.js @@ -0,0 +1,14 @@ +exports.ipsum = require('./ipsum'); +exports.sit = require('./sit'); +exports.nullam = require('./nullam'); +exports.odio = require('./odio'); +exports.tortor = require('./tortor'); +exports.ac = require('./ac'); +exports.nullam = require('./nullam'); +exports.pellentesque = require('./pellentesque'); +exports.cursus = require('./cursus'); +exports.cras = require('./cras'); +exports.semper = require('./semper'); +exports.malesuada = require('./malesuada'); +exports.elementum = require('./elementum'); +exports.pretium = require('./pretium'); diff --git a/examples/big/feugiat.js b/examples/big/feugiat.js new file mode 100644 index 0000000..4b8b3a1 --- /dev/null +++ b/examples/big/feugiat.js @@ -0,0 +1,44 @@ +exports.amet = require('./amet'); +exports.consectetur = require('./consectetur'); +exports.adipiscing = require('./adipiscing'); +exports.lobortis = require('./lobortis'); +exports.in = require('./in'); +exports.scelerisque = require('./scelerisque'); +exports.vulputate = require('./vulputate'); +exports.at = require('./at'); +exports.facilisis = require('./facilisis'); +exports.urna = require('./urna'); +exports.donec = require('./donec'); +exports.morbi = require('./morbi'); +exports.eleifend = require('./eleifend'); +exports.quisque = require('./quisque'); +exports.justo = require('./justo'); +exports.vehicula = require('./vehicula'); +exports.nunc = require('./nunc'); +exports.pharetra = require('./pharetra'); +exports.lacus = require('./lacus'); +exports.pulvinar = require('./pulvinar'); +exports.ac = require('./ac'); +exports.at = require('./at'); +exports.aenean = require('./aenean'); +exports.odio = require('./odio'); +exports.ac = require('./ac'); +exports.erat = require('./erat'); +exports.nam = require('./nam'); +exports.justo = require('./justo'); +exports.aliquet = require('./aliquet'); +exports.scelerisque = require('./scelerisque'); +exports.metus = require('./metus'); +exports.volutpat = require('./volutpat'); +exports.ac = require('./ac'); +exports.venenatis = require('./venenatis'); +exports.justo = require('./justo'); +exports.quam = require('./quam'); +exports.quis = require('./quis'); +exports.augue = require('./augue'); +exports.euismod = require('./euismod'); +exports.nunc = require('./nunc'); +exports.molestie = require('./molestie'); +exports.sed = require('./sed'); +exports.varius = require('./varius'); +exports.sit = require('./sit'); diff --git a/examples/big/fringilla.js b/examples/big/fringilla.js new file mode 100644 index 0000000..ccbe038 --- /dev/null +++ b/examples/big/fringilla.js @@ -0,0 +1,37 @@ +exports.ipsum = require('./ipsum'); +exports.sit = require('./sit'); +exports.nullam = require('./nullam'); +exports.odio = require('./odio'); +exports.tortor = require('./tortor'); +exports.ac = require('./ac'); +exports.nullam = require('./nullam'); +exports.pellentesque = require('./pellentesque'); +exports.cursus = require('./cursus'); +exports.cras = require('./cras'); +exports.semper = require('./semper'); +exports.malesuada = require('./malesuada'); +exports.elementum = require('./elementum'); +exports.pretium = require('./pretium'); +exports.sodales = require('./sodales'); +exports.tortor = require('./tortor'); +exports.risus = require('./risus'); +exports.hendrerit = require('./hendrerit'); +exports.tristique = require('./tristique'); +exports.vel = require('./vel'); +exports.non = require('./non'); +exports.mattis = require('./mattis'); +exports.dolor = require('./dolor'); +exports.nisi = require('./nisi'); +exports.quis = require('./quis'); +exports.mi = require('./mi'); +exports.mauris = require('./mauris'); +exports.in = require('./in'); +exports.porttitor = require('./porttitor'); +exports.commodo = require('./commodo'); +exports.vel = require('./vel'); +exports.porta = require('./porta'); +exports.vel = require('./vel'); +exports.quis = require('./quis'); +exports.iaculis = require('./iaculis'); +exports.a = require('./a'); +exports.viverra = require('./viverra'); diff --git a/examples/big/gravida.js b/examples/big/gravida.js new file mode 100644 index 0000000..f91818f --- /dev/null +++ b/examples/big/gravida.js @@ -0,0 +1,34 @@ +exports.ipsum = require('./ipsum'); +exports.sit = require('./sit'); +exports.nullam = require('./nullam'); +exports.odio = require('./odio'); +exports.tortor = require('./tortor'); +exports.ac = require('./ac'); +exports.nullam = require('./nullam'); +exports.pellentesque = require('./pellentesque'); +exports.cursus = require('./cursus'); +exports.cras = require('./cras'); +exports.semper = require('./semper'); +exports.malesuada = require('./malesuada'); +exports.elementum = require('./elementum'); +exports.pretium = require('./pretium'); +exports.sodales = require('./sodales'); +exports.tortor = require('./tortor'); +exports.risus = require('./risus'); +exports.hendrerit = require('./hendrerit'); +exports.tristique = require('./tristique'); +exports.vel = require('./vel'); +exports.non = require('./non'); +exports.mattis = require('./mattis'); +exports.dolor = require('./dolor'); +exports.nisi = require('./nisi'); +exports.quis = require('./quis'); +exports.mi = require('./mi'); +exports.mauris = require('./mauris'); +exports.in = require('./in'); +exports.porttitor = require('./porttitor'); +exports.commodo = require('./commodo'); +exports.vel = require('./vel'); +exports.porta = require('./porta'); +exports.vel = require('./vel'); +exports.quis = require('./quis'); diff --git a/examples/big/hendrerit.js b/examples/big/hendrerit.js new file mode 100644 index 0000000..6cd1fd3 --- /dev/null +++ b/examples/big/hendrerit.js @@ -0,0 +1,22 @@ +exports.dolor = require('./dolor'); +exports.elit = require('./elit'); +exports.rutrum = require('./rutrum'); +exports.interdum = require('./interdum'); +exports.mollis = require('./mollis'); +exports.etiam = require('./etiam'); +exports.nunc = require('./nunc'); +exports.ornare = require('./ornare'); +exports.eros = require('./eros'); +exports.nulla = require('./nulla'); +exports.pulvinar = require('./pulvinar'); +exports.aliquet = require('./aliquet'); +exports.ligula = require('./ligula'); +exports.ullamcorper = require('./ullamcorper'); +exports.amet = require('./amet'); +exports.vulputate = require('./vulputate'); +exports.lorem = require('./lorem'); +exports.libero = require('./libero'); +exports.tincidunt = require('./tincidunt'); +exports.felis = require('./felis'); +exports.nisi = require('./nisi'); +exports.sed = require('./sed'); diff --git a/examples/big/iaculis.js b/examples/big/iaculis.js new file mode 100644 index 0000000..6656261 --- /dev/null +++ b/examples/big/iaculis.js @@ -0,0 +1,48 @@ +module.exports.dolor = require('./dolor'); +module.exports.elit = require('./elit'); +module.exports.rutrum = require('./rutrum'); +module.exports.interdum = require('./interdum'); +module.exports.mollis = require('./mollis'); +module.exports.etiam = require('./etiam'); +module.exports.nunc = require('./nunc'); +module.exports.ornare = require('./ornare'); +module.exports.eros = require('./eros'); +module.exports.nulla = require('./nulla'); +module.exports.pulvinar = require('./pulvinar'); +module.exports.aliquet = require('./aliquet'); +module.exports.ligula = require('./ligula'); +module.exports.ullamcorper = require('./ullamcorper'); +module.exports.amet = require('./amet'); +module.exports.vulputate = require('./vulputate'); +module.exports.lorem = require('./lorem'); +module.exports.libero = require('./libero'); +module.exports.tincidunt = require('./tincidunt'); +module.exports.felis = require('./felis'); +module.exports.nisi = require('./nisi'); +module.exports.sed = require('./sed'); +module.exports.felis = require('./felis'); +module.exports.ligula = require('./ligula'); +module.exports.vulputate = require('./vulputate'); +module.exports.nam = require('./nam'); +module.exports.viverra = require('./viverra'); +module.exports.metus = require('./metus'); +module.exports.tellus = require('./tellus'); +module.exports.lectus = require('./lectus'); +module.exports.urna = require('./urna'); +module.exports.neque = require('./neque'); +module.exports.mauris = require('./mauris'); +module.exports.a = require('./a'); +module.exports.posuere = require('./posuere'); +module.exports.cursus = require('./cursus'); +module.exports.a = require('./a'); +module.exports.nam = require('./nam'); +module.exports.nulla = require('./nulla'); +module.exports.viverra = require('./viverra'); +module.exports.id = require('./id'); +module.exports.velit = require('./velit'); +module.exports.condimentum = require('./condimentum'); +module.exports.vestibulum = require('./vestibulum'); +module.exports.eros = require('./eros'); +module.exports.gravida = require('./gravida'); +module.exports.metus = require('./metus'); +module.exports.donec = require('./donec'); diff --git a/examples/big/id.js b/examples/big/id.js new file mode 100644 index 0000000..f056198 --- /dev/null +++ b/examples/big/id.js @@ -0,0 +1,35 @@ +module.exports = { + ipsum: require('./ipsum'), + sit: require('./sit'), + nullam: require('./nullam'), + odio: require('./odio'), + tortor: require('./tortor'), + ac: require('./ac'), + nullam: require('./nullam'), + pellentesque: require('./pellentesque'), + cursus: require('./cursus'), + cras: require('./cras'), + semper: require('./semper'), + malesuada: require('./malesuada'), + elementum: require('./elementum'), + pretium: require('./pretium'), + sodales: require('./sodales'), + tortor: require('./tortor'), + risus: require('./risus'), + hendrerit: require('./hendrerit'), + tristique: require('./tristique'), + vel: require('./vel'), + non: require('./non'), + mattis: require('./mattis'), + dolor: require('./dolor'), + nisi: require('./nisi'), + quis: require('./quis'), + mi: require('./mi'), + mauris: require('./mauris'), + in: require('./in'), + porttitor: require('./porttitor'), + commodo: require('./commodo'), + vel: require('./vel'), + porta: require('./porta'), + vel: require('./vel') +}; diff --git a/examples/big/imperdiet.js b/examples/big/imperdiet.js new file mode 100644 index 0000000..d07096a --- /dev/null +++ b/examples/big/imperdiet.js @@ -0,0 +1,22 @@ +module.exports.amet = require('./amet'); +module.exports.consectetur = require('./consectetur'); +module.exports.adipiscing = require('./adipiscing'); +module.exports.lobortis = require('./lobortis'); +module.exports.in = require('./in'); +module.exports.scelerisque = require('./scelerisque'); +module.exports.vulputate = require('./vulputate'); +module.exports.at = require('./at'); +module.exports.facilisis = require('./facilisis'); +module.exports.urna = require('./urna'); +module.exports.donec = require('./donec'); +module.exports.morbi = require('./morbi'); +module.exports.eleifend = require('./eleifend'); +module.exports.quisque = require('./quisque'); +module.exports.justo = require('./justo'); +module.exports.vehicula = require('./vehicula'); +module.exports.nunc = require('./nunc'); +module.exports.pharetra = require('./pharetra'); +module.exports.lacus = require('./lacus'); +module.exports.pulvinar = require('./pulvinar'); +module.exports.ac = require('./ac'); +module.exports.at = require('./at'); diff --git a/examples/big/in.js b/examples/big/in.js new file mode 100644 index 0000000..d36961b --- /dev/null +++ b/examples/big/in.js @@ -0,0 +1 @@ +this.lorem = require('./lorem'); diff --git a/examples/big/integer.js b/examples/big/integer.js new file mode 100644 index 0000000..8910d60 --- /dev/null +++ b/examples/big/integer.js @@ -0,0 +1,26 @@ +module.exports = { + amet: require('./amet'), + consectetur: require('./consectetur'), + adipiscing: require('./adipiscing'), + lobortis: require('./lobortis'), + in: require('./in'), + scelerisque: require('./scelerisque'), + vulputate: require('./vulputate'), + at: require('./at'), + facilisis: require('./facilisis'), + urna: require('./urna'), + donec: require('./donec'), + morbi: require('./morbi'), + eleifend: require('./eleifend'), + quisque: require('./quisque'), + justo: require('./justo'), + vehicula: require('./vehicula'), + nunc: require('./nunc'), + pharetra: require('./pharetra'), + lacus: require('./lacus'), + pulvinar: require('./pulvinar'), + ac: require('./ac'), + at: require('./at'), + aenean: require('./aenean'), + odio: require('./odio') +}; diff --git a/examples/big/interdum.js b/examples/big/interdum.js new file mode 100644 index 0000000..e3ef772 --- /dev/null +++ b/examples/big/interdum.js @@ -0,0 +1,4 @@ +exports.ipsum = require('./ipsum'); +exports.sit = require('./sit'); +exports.nullam = require('./nullam'); +exports.odio = require('./odio'); diff --git a/examples/big/ipsum.js b/examples/big/ipsum.js new file mode 100644 index 0000000..e69de29 diff --git a/examples/big/justo.js b/examples/big/justo.js new file mode 100644 index 0000000..3003c95 --- /dev/null +++ b/examples/big/justo.js @@ -0,0 +1,15 @@ +module.exports.lorem = require('./lorem'); +module.exports.mi = require('./mi'); +module.exports.pellentesque = require('./pellentesque'); +module.exports.egestas = require('./egestas'); +module.exports.pulvinar = require('./pulvinar'); +module.exports.at = require('./at'); +module.exports.nisi = require('./nisi'); +module.exports.nec = require('./nec'); +module.exports.diam = require('./diam'); +module.exports.sit = require('./sit'); +module.exports.ipsum = require('./ipsum'); +module.exports.porta = require('./porta'); +module.exports.suscipit = require('./suscipit'); +module.exports.et = require('./et'); +module.exports.viverra = require('./viverra'); diff --git a/examples/big/lacus.js b/examples/big/lacus.js new file mode 100644 index 0000000..f201a40 --- /dev/null +++ b/examples/big/lacus.js @@ -0,0 +1,19 @@ +exports.lorem = require('./lorem'); +exports.mi = require('./mi'); +exports.pellentesque = require('./pellentesque'); +exports.egestas = require('./egestas'); +exports.pulvinar = require('./pulvinar'); +exports.at = require('./at'); +exports.nisi = require('./nisi'); +exports.nec = require('./nec'); +exports.diam = require('./diam'); +exports.sit = require('./sit'); +exports.ipsum = require('./ipsum'); +exports.porta = require('./porta'); +exports.suscipit = require('./suscipit'); +exports.et = require('./et'); +exports.viverra = require('./viverra'); +exports.ultrices = require('./ultrices'); +exports.at = require('./at'); +exports.vehicula = require('./vehicula'); +exports.dui = require('./dui'); diff --git a/examples/big/lectus.js b/examples/big/lectus.js new file mode 100644 index 0000000..7bd3427 --- /dev/null +++ b/examples/big/lectus.js @@ -0,0 +1,26 @@ +this.ipsum = require('./ipsum'); +this.sit = require('./sit'); +this.nullam = require('./nullam'); +this.odio = require('./odio'); +this.tortor = require('./tortor'); +this.ac = require('./ac'); +this.nullam = require('./nullam'); +this.pellentesque = require('./pellentesque'); +this.cursus = require('./cursus'); +this.cras = require('./cras'); +this.semper = require('./semper'); +this.malesuada = require('./malesuada'); +this.elementum = require('./elementum'); +this.pretium = require('./pretium'); +this.sodales = require('./sodales'); +this.tortor = require('./tortor'); +this.risus = require('./risus'); +this.hendrerit = require('./hendrerit'); +this.tristique = require('./tristique'); +this.vel = require('./vel'); +this.non = require('./non'); +this.mattis = require('./mattis'); +this.dolor = require('./dolor'); +this.nisi = require('./nisi'); +this.quis = require('./quis'); +this.mi = require('./mi'); diff --git a/examples/big/libero.js b/examples/big/libero.js new file mode 100644 index 0000000..7e30c20 --- /dev/null +++ b/examples/big/libero.js @@ -0,0 +1,13 @@ +exports.ipsum = require('./ipsum'); +exports.sit = require('./sit'); +exports.nullam = require('./nullam'); +exports.odio = require('./odio'); +exports.tortor = require('./tortor'); +exports.ac = require('./ac'); +exports.nullam = require('./nullam'); +exports.pellentesque = require('./pellentesque'); +exports.cursus = require('./cursus'); +exports.cras = require('./cras'); +exports.semper = require('./semper'); +exports.malesuada = require('./malesuada'); +exports.elementum = require('./elementum'); diff --git a/examples/big/ligula.js b/examples/big/ligula.js new file mode 100644 index 0000000..d305e77 --- /dev/null +++ b/examples/big/ligula.js @@ -0,0 +1,11 @@ +exports.ipsum = require('./ipsum'); +exports.sit = require('./sit'); +exports.nullam = require('./nullam'); +exports.odio = require('./odio'); +exports.tortor = require('./tortor'); +exports.ac = require('./ac'); +exports.nullam = require('./nullam'); +exports.pellentesque = require('./pellentesque'); +exports.cursus = require('./cursus'); +exports.cras = require('./cras'); +exports.semper = require('./semper'); diff --git a/examples/big/lobortis.js b/examples/big/lobortis.js new file mode 100644 index 0000000..3593ba7 --- /dev/null +++ b/examples/big/lobortis.js @@ -0,0 +1 @@ +exports.lorem = require('./lorem'); diff --git a/examples/big/lorem.js b/examples/big/lorem.js new file mode 100644 index 0000000..f4d6253 --- /dev/null +++ b/examples/big/lorem.js @@ -0,0 +1,3 @@ +module.exports = { + +}; diff --git a/examples/big/malesuada.js b/examples/big/malesuada.js new file mode 100644 index 0000000..d267090 --- /dev/null +++ b/examples/big/malesuada.js @@ -0,0 +1,13 @@ +exports.dolor = require('./dolor'); +exports.elit = require('./elit'); +exports.rutrum = require('./rutrum'); +exports.interdum = require('./interdum'); +exports.mollis = require('./mollis'); +exports.etiam = require('./etiam'); +exports.nunc = require('./nunc'); +exports.ornare = require('./ornare'); +exports.eros = require('./eros'); +exports.nulla = require('./nulla'); +exports.pulvinar = require('./pulvinar'); +exports.aliquet = require('./aliquet'); +exports.ligula = require('./ligula'); diff --git a/examples/big/massa.js b/examples/big/massa.js new file mode 100644 index 0000000..9e410a9 --- /dev/null +++ b/examples/big/massa.js @@ -0,0 +1,36 @@ +exports.ipsum = require('./ipsum'); +exports.sit = require('./sit'); +exports.nullam = require('./nullam'); +exports.odio = require('./odio'); +exports.tortor = require('./tortor'); +exports.ac = require('./ac'); +exports.nullam = require('./nullam'); +exports.pellentesque = require('./pellentesque'); +exports.cursus = require('./cursus'); +exports.cras = require('./cras'); +exports.semper = require('./semper'); +exports.malesuada = require('./malesuada'); +exports.elementum = require('./elementum'); +exports.pretium = require('./pretium'); +exports.sodales = require('./sodales'); +exports.tortor = require('./tortor'); +exports.risus = require('./risus'); +exports.hendrerit = require('./hendrerit'); +exports.tristique = require('./tristique'); +exports.vel = require('./vel'); +exports.non = require('./non'); +exports.mattis = require('./mattis'); +exports.dolor = require('./dolor'); +exports.nisi = require('./nisi'); +exports.quis = require('./quis'); +exports.mi = require('./mi'); +exports.mauris = require('./mauris'); +exports.in = require('./in'); +exports.porttitor = require('./porttitor'); +exports.commodo = require('./commodo'); +exports.vel = require('./vel'); +exports.porta = require('./porta'); +exports.vel = require('./vel'); +exports.quis = require('./quis'); +exports.iaculis = require('./iaculis'); +exports.a = require('./a'); diff --git a/examples/big/mattis.js b/examples/big/mattis.js new file mode 100644 index 0000000..96cb909 --- /dev/null +++ b/examples/big/mattis.js @@ -0,0 +1,22 @@ +this.amet = require('./amet'); +this.consectetur = require('./consectetur'); +this.adipiscing = require('./adipiscing'); +this.lobortis = require('./lobortis'); +this.in = require('./in'); +this.scelerisque = require('./scelerisque'); +this.vulputate = require('./vulputate'); +this.at = require('./at'); +this.facilisis = require('./facilisis'); +this.urna = require('./urna'); +this.donec = require('./donec'); +this.morbi = require('./morbi'); +this.eleifend = require('./eleifend'); +this.quisque = require('./quisque'); +this.justo = require('./justo'); +this.vehicula = require('./vehicula'); +this.nunc = require('./nunc'); +this.pharetra = require('./pharetra'); +this.lacus = require('./lacus'); +this.pulvinar = require('./pulvinar'); +this.ac = require('./ac'); +this.at = require('./at'); diff --git a/examples/big/mauris.js b/examples/big/mauris.js new file mode 100644 index 0000000..c9036b2 --- /dev/null +++ b/examples/big/mauris.js @@ -0,0 +1,31 @@ +exports.dolor = require('./dolor'); +exports.elit = require('./elit'); +exports.rutrum = require('./rutrum'); +exports.interdum = require('./interdum'); +exports.mollis = require('./mollis'); +exports.etiam = require('./etiam'); +exports.nunc = require('./nunc'); +exports.ornare = require('./ornare'); +exports.eros = require('./eros'); +exports.nulla = require('./nulla'); +exports.pulvinar = require('./pulvinar'); +exports.aliquet = require('./aliquet'); +exports.ligula = require('./ligula'); +exports.ullamcorper = require('./ullamcorper'); +exports.amet = require('./amet'); +exports.vulputate = require('./vulputate'); +exports.lorem = require('./lorem'); +exports.libero = require('./libero'); +exports.tincidunt = require('./tincidunt'); +exports.felis = require('./felis'); +exports.nisi = require('./nisi'); +exports.sed = require('./sed'); +exports.felis = require('./felis'); +exports.ligula = require('./ligula'); +exports.vulputate = require('./vulputate'); +exports.nam = require('./nam'); +exports.viverra = require('./viverra'); +exports.metus = require('./metus'); +exports.tellus = require('./tellus'); +exports.lectus = require('./lectus'); +exports.urna = require('./urna'); diff --git a/examples/big/metus.js b/examples/big/metus.js new file mode 100644 index 0000000..f498120 --- /dev/null +++ b/examples/big/metus.js @@ -0,0 +1,24 @@ +exports.ipsum = require('./ipsum'); +exports.sit = require('./sit'); +exports.nullam = require('./nullam'); +exports.odio = require('./odio'); +exports.tortor = require('./tortor'); +exports.ac = require('./ac'); +exports.nullam = require('./nullam'); +exports.pellentesque = require('./pellentesque'); +exports.cursus = require('./cursus'); +exports.cras = require('./cras'); +exports.semper = require('./semper'); +exports.malesuada = require('./malesuada'); +exports.elementum = require('./elementum'); +exports.pretium = require('./pretium'); +exports.sodales = require('./sodales'); +exports.tortor = require('./tortor'); +exports.risus = require('./risus'); +exports.hendrerit = require('./hendrerit'); +exports.tristique = require('./tristique'); +exports.vel = require('./vel'); +exports.non = require('./non'); +exports.mattis = require('./mattis'); +exports.dolor = require('./dolor'); +exports.nisi = require('./nisi'); diff --git a/examples/big/mi.js b/examples/big/mi.js new file mode 100644 index 0000000..780d2a0 --- /dev/null +++ b/examples/big/mi.js @@ -0,0 +1,5 @@ +module.exports.amet = require('./amet'); +module.exports.consectetur = require('./consectetur'); +module.exports.adipiscing = require('./adipiscing'); +module.exports.lobortis = require('./lobortis'); +module.exports.in = require('./in'); diff --git a/examples/big/molestie.js b/examples/big/molestie.js new file mode 100644 index 0000000..3d0f47e --- /dev/null +++ b/examples/big/molestie.js @@ -0,0 +1,38 @@ +module.exports.lorem = require('./lorem'); +module.exports.mi = require('./mi'); +module.exports.pellentesque = require('./pellentesque'); +module.exports.egestas = require('./egestas'); +module.exports.pulvinar = require('./pulvinar'); +module.exports.at = require('./at'); +module.exports.nisi = require('./nisi'); +module.exports.nec = require('./nec'); +module.exports.diam = require('./diam'); +module.exports.sit = require('./sit'); +module.exports.ipsum = require('./ipsum'); +module.exports.porta = require('./porta'); +module.exports.suscipit = require('./suscipit'); +module.exports.et = require('./et'); +module.exports.viverra = require('./viverra'); +module.exports.ultrices = require('./ultrices'); +module.exports.at = require('./at'); +module.exports.vehicula = require('./vehicula'); +module.exports.dui = require('./dui'); +module.exports.nibh = require('./nibh'); +module.exports.mattis = require('./mattis'); +module.exports.imperdiet = require('./imperdiet'); +module.exports.integer = require('./integer'); +module.exports.varius = require('./varius'); +module.exports.in = require('./in'); +module.exports.auctor = require('./auctor'); +module.exports.urna = require('./urna'); +module.exports.auctor = require('./auctor'); +module.exports.ante = require('./ante'); +module.exports.sed = require('./sed'); +module.exports.sed = require('./sed'); +module.exports.aliquam = require('./aliquam'); +module.exports.lacus = require('./lacus'); +module.exports.tempor = require('./tempor'); +module.exports.interdum = require('./interdum'); +module.exports.id = require('./id'); +module.exports.porttitor = require('./porttitor'); +module.exports.eros = require('./eros'); diff --git a/examples/big/mollis.js b/examples/big/mollis.js new file mode 100644 index 0000000..c34c6f4 --- /dev/null +++ b/examples/big/mollis.js @@ -0,0 +1,4 @@ +this.ipsum = require('./ipsum'); +this.sit = require('./sit'); +this.nullam = require('./nullam'); +this.odio = require('./odio'); diff --git a/examples/big/morbi.js b/examples/big/morbi.js new file mode 100644 index 0000000..40ed2ed --- /dev/null +++ b/examples/big/morbi.js @@ -0,0 +1,11 @@ +exports.lorem = require('./lorem'); +exports.mi = require('./mi'); +exports.pellentesque = require('./pellentesque'); +exports.egestas = require('./egestas'); +exports.pulvinar = require('./pulvinar'); +exports.at = require('./at'); +exports.nisi = require('./nisi'); +exports.nec = require('./nec'); +exports.diam = require('./diam'); +exports.sit = require('./sit'); +exports.ipsum = require('./ipsum'); diff --git a/examples/big/nam.js b/examples/big/nam.js new file mode 100644 index 0000000..30bd742 --- /dev/null +++ b/examples/big/nam.js @@ -0,0 +1,24 @@ +exports.lorem = require('./lorem'); +exports.mi = require('./mi'); +exports.pellentesque = require('./pellentesque'); +exports.egestas = require('./egestas'); +exports.pulvinar = require('./pulvinar'); +exports.at = require('./at'); +exports.nisi = require('./nisi'); +exports.nec = require('./nec'); +exports.diam = require('./diam'); +exports.sit = require('./sit'); +exports.ipsum = require('./ipsum'); +exports.porta = require('./porta'); +exports.suscipit = require('./suscipit'); +exports.et = require('./et'); +exports.viverra = require('./viverra'); +exports.ultrices = require('./ultrices'); +exports.at = require('./at'); +exports.vehicula = require('./vehicula'); +exports.dui = require('./dui'); +exports.nibh = require('./nibh'); +exports.mattis = require('./mattis'); +exports.imperdiet = require('./imperdiet'); +exports.integer = require('./integer'); +exports.varius = require('./varius'); diff --git a/examples/big/nec.js b/examples/big/nec.js new file mode 100644 index 0000000..0d46d25 --- /dev/null +++ b/examples/big/nec.js @@ -0,0 +1,10 @@ +exports.amet = require('./amet'); +exports.consectetur = require('./consectetur'); +exports.adipiscing = require('./adipiscing'); +exports.lobortis = require('./lobortis'); +exports.in = require('./in'); +exports.scelerisque = require('./scelerisque'); +exports.vulputate = require('./vulputate'); +exports.at = require('./at'); +exports.facilisis = require('./facilisis'); +exports.urna = require('./urna'); diff --git a/examples/big/neque.js b/examples/big/neque.js new file mode 100644 index 0000000..ed3a7df --- /dev/null +++ b/examples/big/neque.js @@ -0,0 +1,27 @@ +this.ipsum = require('./ipsum'); +this.sit = require('./sit'); +this.nullam = require('./nullam'); +this.odio = require('./odio'); +this.tortor = require('./tortor'); +this.ac = require('./ac'); +this.nullam = require('./nullam'); +this.pellentesque = require('./pellentesque'); +this.cursus = require('./cursus'); +this.cras = require('./cras'); +this.semper = require('./semper'); +this.malesuada = require('./malesuada'); +this.elementum = require('./elementum'); +this.pretium = require('./pretium'); +this.sodales = require('./sodales'); +this.tortor = require('./tortor'); +this.risus = require('./risus'); +this.hendrerit = require('./hendrerit'); +this.tristique = require('./tristique'); +this.vel = require('./vel'); +this.non = require('./non'); +this.mattis = require('./mattis'); +this.dolor = require('./dolor'); +this.nisi = require('./nisi'); +this.quis = require('./quis'); +this.mi = require('./mi'); +this.mauris = require('./mauris'); diff --git a/examples/big/nibh.js b/examples/big/nibh.js new file mode 100644 index 0000000..f3402c4 --- /dev/null +++ b/examples/big/nibh.js @@ -0,0 +1,20 @@ +this.amet = require('./amet'); +this.consectetur = require('./consectetur'); +this.adipiscing = require('./adipiscing'); +this.lobortis = require('./lobortis'); +this.in = require('./in'); +this.scelerisque = require('./scelerisque'); +this.vulputate = require('./vulputate'); +this.at = require('./at'); +this.facilisis = require('./facilisis'); +this.urna = require('./urna'); +this.donec = require('./donec'); +this.morbi = require('./morbi'); +this.eleifend = require('./eleifend'); +this.quisque = require('./quisque'); +this.justo = require('./justo'); +this.vehicula = require('./vehicula'); +this.nunc = require('./nunc'); +this.pharetra = require('./pharetra'); +this.lacus = require('./lacus'); +this.pulvinar = require('./pulvinar'); diff --git a/examples/big/nisi.js b/examples/big/nisi.js new file mode 100644 index 0000000..5e04b37 --- /dev/null +++ b/examples/big/nisi.js @@ -0,0 +1,6 @@ +this.amet = require('./amet'); +this.consectetur = require('./consectetur'); +this.adipiscing = require('./adipiscing'); +this.lobortis = require('./lobortis'); +this.in = require('./in'); +this.scelerisque = require('./scelerisque'); diff --git a/examples/big/non.js b/examples/big/non.js new file mode 100644 index 0000000..58fffb5 --- /dev/null +++ b/examples/big/non.js @@ -0,0 +1,24 @@ +exports.dolor = require('./dolor'); +exports.elit = require('./elit'); +exports.rutrum = require('./rutrum'); +exports.interdum = require('./interdum'); +exports.mollis = require('./mollis'); +exports.etiam = require('./etiam'); +exports.nunc = require('./nunc'); +exports.ornare = require('./ornare'); +exports.eros = require('./eros'); +exports.nulla = require('./nulla'); +exports.pulvinar = require('./pulvinar'); +exports.aliquet = require('./aliquet'); +exports.ligula = require('./ligula'); +exports.ullamcorper = require('./ullamcorper'); +exports.amet = require('./amet'); +exports.vulputate = require('./vulputate'); +exports.lorem = require('./lorem'); +exports.libero = require('./libero'); +exports.tincidunt = require('./tincidunt'); +exports.felis = require('./felis'); +exports.nisi = require('./nisi'); +exports.sed = require('./sed'); +exports.felis = require('./felis'); +exports.ligula = require('./ligula'); diff --git a/examples/big/nulla.js b/examples/big/nulla.js new file mode 100644 index 0000000..5ecde2c --- /dev/null +++ b/examples/big/nulla.js @@ -0,0 +1,7 @@ +exports.ipsum = require('./ipsum'); +exports.sit = require('./sit'); +exports.nullam = require('./nullam'); +exports.odio = require('./odio'); +exports.tortor = require('./tortor'); +exports.ac = require('./ac'); +exports.nullam = require('./nullam'); diff --git a/examples/big/nullam.js b/examples/big/nullam.js new file mode 100644 index 0000000..1aecc6f --- /dev/null +++ b/examples/big/nullam.js @@ -0,0 +1,2 @@ +this.dolor = require('./dolor'); +this.elit = require('./elit'); diff --git a/examples/big/nunc.js b/examples/big/nunc.js new file mode 100644 index 0000000..c2afc71 --- /dev/null +++ b/examples/big/nunc.js @@ -0,0 +1,6 @@ +module.exports = { + ipsum: require('./ipsum'), + sit: require('./sit'), + nullam: require('./nullam'), + odio: require('./odio') +}; diff --git a/examples/big/odio.js b/examples/big/odio.js new file mode 100644 index 0000000..068adef --- /dev/null +++ b/examples/big/odio.js @@ -0,0 +1,5 @@ +module.exports = { + dolor: require('./dolor'), + elit: require('./elit'), + rutrum: require('./rutrum') +}; diff --git a/examples/big/ornare.js b/examples/big/ornare.js new file mode 100644 index 0000000..ec7b465 --- /dev/null +++ b/examples/big/ornare.js @@ -0,0 +1,5 @@ +exports.ipsum = require('./ipsum'); +exports.sit = require('./sit'); +exports.nullam = require('./nullam'); +exports.odio = require('./odio'); +exports.tortor = require('./tortor'); diff --git a/examples/big/output.amd.js b/examples/big/output.amd.js new file mode 100644 index 0000000..d17d8f8 --- /dev/null +++ b/examples/big/output.amd.js @@ -0,0 +1,1984 @@ +define([], (function() { +var exports = {}; +var __small$_38 = (function() { +var exports = {}; +exports = { + +}; +return exports; +})(); +var __small$_39 = (function() { +var exports = {}; +exports.amet = __small$_1; +exports.consectetur = __small$_2; +exports.adipiscing = __small$_3; +exports.lobortis = __small$_4; +exports.in = __small$_5; + +return exports; +})(); +var __small$_40 = (function() { +var exports = {}; +exports.amet = __small$_1; +exports.consectetur = __small$_2; +exports.adipiscing = __small$_3; +exports.lobortis = __small$_4; +exports.in = __small$_5; + +return exports; +})(); +var __small$_41 = (function() { +var exports = {}; +exports.amet = __small$_1; +exports.consectetur = __small$_2; +exports.adipiscing = __small$_3; +exports.lobortis = __small$_4; +exports.in = __small$_5; + +return exports; +})(); +var __small$_42 = (function() { +var exports = {}; +exports.amet = __small$_1; +exports.consectetur = __small$_2; +exports.adipiscing = __small$_3; +exports.lobortis = __small$_4; +exports.in = __small$_5; +exports.scelerisque = __small$_6; + +return exports; +})(); +var __small$_43 = (function() { +var exports = {}; +exports.amet = __small$_1; +exports.consectetur = __small$_2; +exports.adipiscing = __small$_3; +exports.lobortis = __small$_4; +exports.in = __small$_5; +exports.scelerisque = __small$_6; +exports.vulputate = __small$_7; +exports.at = __small$_8; +exports.facilisis = __small$_9; +exports.urna = __small$_10; + +return exports; +})(); +var __small$_44 = (function() { +var exports = {}; +exports = { + amet: __small$_1, + consectetur: __small$_2, + adipiscing: __small$_3, + lobortis: __small$_4, + in: __small$_5, + scelerisque: __small$_6, + vulputate: __small$_7, + at: __small$_8, + facilisis: __small$_9, + urna: __small$_10, + donec: __small$_11 +}; +return exports; +})(); +var __small$_45 = (function() { +var exports = {}; + +return exports; +})(); +var __small$_53 = (function() { +var exports = {}; +exports.ipsum = __small$_45; + +return exports; +})(); +var __small$_46 = (function() { +var exports = {}; +exports.amet = __small$_1; +exports.consectetur = __small$_2; +exports.adipiscing = __small$_3; +exports.lobortis = __small$_4; +exports.in = __small$_5; +exports.scelerisque = __small$_6; +exports.vulputate = __small$_7; +exports.at = __small$_8; +exports.facilisis = __small$_9; +exports.urna = __small$_10; +exports.donec = __small$_11; +exports.morbi = __small$_12; + +return exports; +})(); +var __small$_47 = (function() { +var exports = {}; +exports.amet = __small$_1; +exports.consectetur = __small$_2; +exports.adipiscing = __small$_3; +exports.lobortis = __small$_4; +exports.in = __small$_5; +exports.scelerisque = __small$_6; +exports.vulputate = __small$_7; +exports.at = __small$_8; +exports.facilisis = __small$_9; +exports.urna = __small$_10; +exports.donec = __small$_11; +exports.morbi = __small$_12; + +return exports; +})(); +var __small$_48 = (function() { +var exports = {}; +exports = { + amet: __small$_1, + consectetur: __small$_2, + adipiscing: __small$_3, + lobortis: __small$_4, + in: __small$_5, + scelerisque: __small$_6, + vulputate: __small$_7, + at: __small$_8, + facilisis: __small$_9, + urna: __small$_10, + donec: __small$_11, + morbi: __small$_12 +}; +return exports; +})(); +var __small$_49 = (function() { +var exports = {}; +exports.amet = __small$_1; +exports.consectetur = __small$_2; +exports.adipiscing = __small$_3; +exports.lobortis = __small$_4; +exports.in = __small$_5; +exports.scelerisque = __small$_6; +exports.vulputate = __small$_7; +exports.at = __small$_8; +exports.facilisis = __small$_9; +exports.urna = __small$_10; +exports.donec = __small$_11; +exports.morbi = __small$_12; +exports.eleifend = __small$_13; +exports.quisque = __small$_14; + +return exports; +})(); +var __small$_54 = (function() { +var exports = {}; +exports.ipsum = __small$_45; +exports.sit = __small$_37; + +return exports; +})(); +var __small$_50 = (function() { +var exports = {}; +exports.dolor = __small$_53; +exports.elit = __small$_54; + +return exports; +})(); +var __small$_55 = (function() { +var exports = {}; +exports.ipsum = __small$_45; +exports.sit = __small$_37; +exports.nullam = __small$_50; + +return exports; +})(); +var __small$_51 = (function() { +var exports = {}; +exports = { + amet: __small$_1, + consectetur: __small$_2, + adipiscing: __small$_3, + lobortis: __small$_4, + in: __small$_5, + scelerisque: __small$_6, + vulputate: __small$_7, + at: __small$_8, + facilisis: __small$_9, + urna: __small$_10, + donec: __small$_11, + morbi: __small$_12, + eleifend: __small$_13, + quisque: __small$_14, + justo: __small$_15, + vehicula: __small$_16, + nunc: __small$_17 +}; +return exports; +})(); +var __small$_52 = (function() { +var exports = {}; +exports = { + amet: __small$_1, + consectetur: __small$_2, + adipiscing: __small$_3, + lobortis: __small$_4, + in: __small$_5, + scelerisque: __small$_6, + vulputate: __small$_7, + at: __small$_8, + facilisis: __small$_9, + urna: __small$_10, + donec: __small$_11, + morbi: __small$_12, + eleifend: __small$_13, + quisque: __small$_14, + justo: __small$_15, + vehicula: __small$_16, + nunc: __small$_17, + pharetra: __small$_18 +}; +return exports; +})(); +var __small$_56 = (function() { +var exports = {}; +exports.ipsum = __small$_45; +exports.sit = __small$_37; +exports.nullam = __small$_50; +exports.odio = __small$_23; + +return exports; +})(); +var __small$_57 = (function() { +var exports = {}; +exports.ipsum = __small$_45; +exports.sit = __small$_37; +exports.nullam = __small$_50; +exports.odio = __small$_23; + +return exports; +})(); +var __small$_58 = (function() { +var exports = {}; +exports.ipsum = __small$_45; +exports.sit = __small$_37; +exports.nullam = __small$_50; +exports.odio = __small$_23; + +return exports; +})(); +var __small$_60 = (function() { +var exports = {}; +exports.amet = __small$_1; +exports.consectetur = __small$_2; +exports.adipiscing = __small$_3; +exports.lobortis = __small$_4; +exports.in = __small$_5; +exports.scelerisque = __small$_6; +exports.vulputate = __small$_7; +exports.at = __small$_8; +exports.facilisis = __small$_9; +exports.urna = __small$_10; +exports.donec = __small$_11; +exports.morbi = __small$_12; +exports.eleifend = __small$_13; +exports.quisque = __small$_14; +exports.justo = __small$_15; +exports.vehicula = __small$_16; +exports.nunc = __small$_17; +exports.pharetra = __small$_18; +exports.lacus = __small$_19; +exports.pulvinar = __small$_20; + +return exports; +})(); +var __small$_64 = (function() { +var exports = {}; +exports.dolor = __small$_53; +exports.elit = __small$_54; +exports.rutrum = __small$_55; +exports.interdum = __small$_56; +exports.mollis = __small$_57; +exports.etiam = __small$_58; +exports.nunc = __small$_17; + +return exports; +})(); +var __small$_59 = (function() { +var exports = {}; +exports.ipsum = __small$_45; +exports.sit = __small$_37; +exports.nullam = __small$_50; +exports.odio = __small$_23; +exports.tortor = __small$_64; + +return exports; +})(); +var __small$_61 = (function() { +var exports = {}; +exports.amet = __small$_1; +exports.consectetur = __small$_2; +exports.adipiscing = __small$_3; +exports.lobortis = __small$_4; +exports.in = __small$_5; +exports.scelerisque = __small$_6; +exports.vulputate = __small$_7; +exports.at = __small$_8; +exports.facilisis = __small$_9; +exports.urna = __small$_10; +exports.donec = __small$_11; +exports.morbi = __small$_12; +exports.eleifend = __small$_13; +exports.quisque = __small$_14; +exports.justo = __small$_15; +exports.vehicula = __small$_16; +exports.nunc = __small$_17; +exports.pharetra = __small$_18; +exports.lacus = __small$_19; +exports.pulvinar = __small$_20; +exports.ac = __small$_21; +exports.at = __small$_8; + +return exports; +})(); +var __small$_62 = (function() { +var exports = {}; +exports.amet = __small$_1; +exports.consectetur = __small$_2; +exports.adipiscing = __small$_3; +exports.lobortis = __small$_4; +exports.in = __small$_5; +exports.scelerisque = __small$_6; +exports.vulputate = __small$_7; +exports.at = __small$_8; +exports.facilisis = __small$_9; +exports.urna = __small$_10; +exports.donec = __small$_11; +exports.morbi = __small$_12; +exports.eleifend = __small$_13; +exports.quisque = __small$_14; +exports.justo = __small$_15; +exports.vehicula = __small$_16; +exports.nunc = __small$_17; +exports.pharetra = __small$_18; +exports.lacus = __small$_19; +exports.pulvinar = __small$_20; +exports.ac = __small$_21; +exports.at = __small$_8; + +return exports; +})(); +var __small$_63 = (function() { +var exports = {}; +exports = { + amet: __small$_1, + consectetur: __small$_2, + adipiscing: __small$_3, + lobortis: __small$_4, + in: __small$_5, + scelerisque: __small$_6, + vulputate: __small$_7, + at: __small$_8, + facilisis: __small$_9, + urna: __small$_10, + donec: __small$_11, + morbi: __small$_12, + eleifend: __small$_13, + quisque: __small$_14, + justo: __small$_15, + vehicula: __small$_16, + nunc: __small$_17, + pharetra: __small$_18, + lacus: __small$_19, + pulvinar: __small$_20, + ac: __small$_21, + at: __small$_8, + aenean: __small$_22, + odio: __small$_23 +}; +return exports; +})(); +var __small$_79 = (function() { +var exports = {}; +exports.ipsum = __small$_45; +exports.sit = __small$_37; +exports.nullam = __small$_50; +exports.odio = __small$_23; +exports.tortor = __small$_64; +exports.ac = __small$_21; + +return exports; +})(); +var __small$_80 = (function() { +var exports = {}; +exports.ipsum = __small$_45; +exports.sit = __small$_37; +exports.nullam = __small$_50; +exports.odio = __small$_23; +exports.tortor = __small$_64; +exports.ac = __small$_21; +exports.nullam = __small$_50; + +return exports; +})(); +var __small$_65 = (function() { +var exports = {}; +exports.dolor = __small$_53; +exports.elit = __small$_54; +exports.rutrum = __small$_55; +exports.interdum = __small$_56; +exports.mollis = __small$_57; +exports.etiam = __small$_58; +exports.nunc = __small$_17; +exports.ornare = __small$_59; +exports.eros = __small$_79; +exports.nulla = __small$_80; +exports.pulvinar = __small$_20; +exports.aliquet = __small$_26; + +return exports; +})(); +var __small$_66 = (function() { +var exports = {}; +exports.dolor = __small$_53; +exports.elit = __small$_54; +exports.rutrum = __small$_55; +exports.interdum = __small$_56; +exports.mollis = __small$_57; +exports.etiam = __small$_58; +exports.nunc = __small$_17; +exports.ornare = __small$_59; +exports.eros = __small$_79; +exports.nulla = __small$_80; +exports.pulvinar = __small$_20; +exports.aliquet = __small$_26; + +return exports; +})(); +var __small$_67 = (function() { +var exports = {}; +exports.dolor = __small$_53; +exports.elit = __small$_54; +exports.rutrum = __small$_55; +exports.interdum = __small$_56; +exports.mollis = __small$_57; +exports.etiam = __small$_58; +exports.nunc = __small$_17; +exports.ornare = __small$_59; +exports.eros = __small$_79; +exports.nulla = __small$_80; +exports.pulvinar = __small$_20; +exports.aliquet = __small$_26; + +return exports; +})(); +var __small$_81 = (function() { +var exports = {}; +exports.ipsum = __small$_45; +exports.sit = __small$_37; +exports.nullam = __small$_50; +exports.odio = __small$_23; +exports.tortor = __small$_64; +exports.ac = __small$_21; +exports.nullam = __small$_50; +exports.pellentesque = __small$_40; +exports.cursus = __small$_65; +exports.cras = __small$_66; +exports.semper = __small$_67; + +return exports; +})(); +var __small$_68 = (function() { +var exports = {}; +exports.dolor = __small$_53; +exports.elit = __small$_54; +exports.rutrum = __small$_55; +exports.interdum = __small$_56; +exports.mollis = __small$_57; +exports.etiam = __small$_58; +exports.nunc = __small$_17; +exports.ornare = __small$_59; +exports.eros = __small$_79; +exports.nulla = __small$_80; +exports.pulvinar = __small$_20; +exports.aliquet = __small$_26; +exports.ligula = __small$_81; + +return exports; +})(); +var __small$_82 = (function() { +var exports = {}; +exports.ipsum = __small$_45; +exports.sit = __small$_37; +exports.nullam = __small$_50; +exports.odio = __small$_23; +exports.tortor = __small$_64; +exports.ac = __small$_21; +exports.nullam = __small$_50; +exports.pellentesque = __small$_40; +exports.cursus = __small$_65; +exports.cras = __small$_66; +exports.semper = __small$_67; +exports.malesuada = __small$_68; + +return exports; +})(); +var __small$_69 = (function() { +var exports = {}; +exports.dolor = __small$_53; +exports.elit = __small$_54; +exports.rutrum = __small$_55; +exports.interdum = __small$_56; +exports.mollis = __small$_57; +exports.etiam = __small$_58; +exports.nunc = __small$_17; +exports.ornare = __small$_59; +exports.eros = __small$_79; +exports.nulla = __small$_80; +exports.pulvinar = __small$_20; +exports.aliquet = __small$_26; +exports.ligula = __small$_81; +exports.ullamcorper = __small$_82; +exports.amet = __small$_1; + +return exports; +})(); +var __small$_83 = (function() { +var exports = {}; +exports.ipsum = __small$_45; +exports.sit = __small$_37; +exports.nullam = __small$_50; +exports.odio = __small$_23; +exports.tortor = __small$_64; +exports.ac = __small$_21; +exports.nullam = __small$_50; +exports.pellentesque = __small$_40; +exports.cursus = __small$_65; +exports.cras = __small$_66; +exports.semper = __small$_67; +exports.malesuada = __small$_68; +exports.elementum = __small$_69; + +return exports; +})(); +var __small$_84 = (function() { +var exports = {}; +exports.ipsum = __small$_45; +exports.sit = __small$_37; +exports.nullam = __small$_50; +exports.odio = __small$_23; +exports.tortor = __small$_64; +exports.ac = __small$_21; +exports.nullam = __small$_50; +exports.pellentesque = __small$_40; +exports.cursus = __small$_65; +exports.cras = __small$_66; +exports.semper = __small$_67; +exports.malesuada = __small$_68; +exports.elementum = __small$_69; + +return exports; +})(); +var __small$_70 = (function() { +var exports = {}; +exports.dolor = __small$_53; +exports.elit = __small$_54; +exports.rutrum = __small$_55; +exports.interdum = __small$_56; +exports.mollis = __small$_57; +exports.etiam = __small$_58; +exports.nunc = __small$_17; +exports.ornare = __small$_59; +exports.eros = __small$_79; +exports.nulla = __small$_80; +exports.pulvinar = __small$_20; +exports.aliquet = __small$_26; +exports.ligula = __small$_81; +exports.ullamcorper = __small$_82; +exports.amet = __small$_1; +exports.vulputate = __small$_7; +exports.lorem = __small$_38; +exports.libero = __small$_83; +exports.tincidunt = __small$_84; + +return exports; +})(); +var __small$_85 = (function() { +var exports = {}; +exports.ipsum = __small$_45; +exports.sit = __small$_37; +exports.nullam = __small$_50; +exports.odio = __small$_23; +exports.tortor = __small$_64; +exports.ac = __small$_21; +exports.nullam = __small$_50; +exports.pellentesque = __small$_40; +exports.cursus = __small$_65; +exports.cras = __small$_66; +exports.semper = __small$_67; +exports.malesuada = __small$_68; +exports.elementum = __small$_69; +exports.pretium = __small$_70; + +return exports; +})(); +var __small$_71 = (function() { +var exports = {}; +exports = { + dolor: __small$_53, + elit: __small$_54, + rutrum: __small$_55, + interdum: __small$_56, + mollis: __small$_57, + etiam: __small$_58, + nunc: __small$_17, + ornare: __small$_59, + eros: __small$_79, + nulla: __small$_80, + pulvinar: __small$_20, + aliquet: __small$_26, + ligula: __small$_81, + ullamcorper: __small$_82, + amet: __small$_1, + vulputate: __small$_7, + lorem: __small$_38, + libero: __small$_83, + tincidunt: __small$_84, + felis: __small$_85 +}; +return exports; +})(); +var __small$_72 = (function() { +var exports = {}; +exports.dolor = __small$_53; +exports.elit = __small$_54; +exports.rutrum = __small$_55; +exports.interdum = __small$_56; +exports.mollis = __small$_57; +exports.etiam = __small$_58; +exports.nunc = __small$_17; +exports.ornare = __small$_59; +exports.eros = __small$_79; +exports.nulla = __small$_80; +exports.pulvinar = __small$_20; +exports.aliquet = __small$_26; +exports.ligula = __small$_81; +exports.ullamcorper = __small$_82; +exports.amet = __small$_1; +exports.vulputate = __small$_7; +exports.lorem = __small$_38; +exports.libero = __small$_83; +exports.tincidunt = __small$_84; +exports.felis = __small$_85; + +return exports; +})(); +var __small$_73 = (function() { +var exports = {}; +exports.dolor = __small$_53; +exports.elit = __small$_54; +exports.rutrum = __small$_55; +exports.interdum = __small$_56; +exports.mollis = __small$_57; +exports.etiam = __small$_58; +exports.nunc = __small$_17; +exports.ornare = __small$_59; +exports.eros = __small$_79; +exports.nulla = __small$_80; +exports.pulvinar = __small$_20; +exports.aliquet = __small$_26; +exports.ligula = __small$_81; +exports.ullamcorper = __small$_82; +exports.amet = __small$_1; +exports.vulputate = __small$_7; +exports.lorem = __small$_38; +exports.libero = __small$_83; +exports.tincidunt = __small$_84; +exports.felis = __small$_85; +exports.nisi = __small$_42; +exports.sed = __small$_35; + +return exports; +})(); +var __small$_74 = (function() { +var exports = {}; +exports = { + dolor: __small$_53, + elit: __small$_54, + rutrum: __small$_55, + interdum: __small$_56, + mollis: __small$_57, + etiam: __small$_58, + nunc: __small$_17, + ornare: __small$_59, + eros: __small$_79, + nulla: __small$_80, + pulvinar: __small$_20, + aliquet: __small$_26, + ligula: __small$_81, + ullamcorper: __small$_82, + amet: __small$_1, + vulputate: __small$_7, + lorem: __small$_38, + libero: __small$_83, + tincidunt: __small$_84, + felis: __small$_85, + nisi: __small$_42, + sed: __small$_35, + felis: __small$_85 +}; +return exports; +})(); +var __small$_75 = (function() { +var exports = {}; +exports.dolor = __small$_53; +exports.elit = __small$_54; +exports.rutrum = __small$_55; +exports.interdum = __small$_56; +exports.mollis = __small$_57; +exports.etiam = __small$_58; +exports.nunc = __small$_17; +exports.ornare = __small$_59; +exports.eros = __small$_79; +exports.nulla = __small$_80; +exports.pulvinar = __small$_20; +exports.aliquet = __small$_26; +exports.ligula = __small$_81; +exports.ullamcorper = __small$_82; +exports.amet = __small$_1; +exports.vulputate = __small$_7; +exports.lorem = __small$_38; +exports.libero = __small$_83; +exports.tincidunt = __small$_84; +exports.felis = __small$_85; +exports.nisi = __small$_42; +exports.sed = __small$_35; +exports.felis = __small$_85; + +return exports; +})(); +var __small$_76 = (function() { +var exports = {}; +exports.dolor = __small$_53; +exports.elit = __small$_54; +exports.rutrum = __small$_55; +exports.interdum = __small$_56; +exports.mollis = __small$_57; +exports.etiam = __small$_58; +exports.nunc = __small$_17; +exports.ornare = __small$_59; +exports.eros = __small$_79; +exports.nulla = __small$_80; +exports.pulvinar = __small$_20; +exports.aliquet = __small$_26; +exports.ligula = __small$_81; +exports.ullamcorper = __small$_82; +exports.amet = __small$_1; +exports.vulputate = __small$_7; +exports.lorem = __small$_38; +exports.libero = __small$_83; +exports.tincidunt = __small$_84; +exports.felis = __small$_85; +exports.nisi = __small$_42; +exports.sed = __small$_35; +exports.felis = __small$_85; +exports.ligula = __small$_81; + +return exports; +})(); +var __small$_77 = (function() { +var exports = {}; +exports.amet = __small$_1; +exports.consectetur = __small$_2; +exports.adipiscing = __small$_3; +exports.lobortis = __small$_4; +exports.in = __small$_5; +exports.scelerisque = __small$_6; +exports.vulputate = __small$_7; +exports.at = __small$_8; +exports.facilisis = __small$_9; +exports.urna = __small$_10; +exports.donec = __small$_11; +exports.morbi = __small$_12; +exports.eleifend = __small$_13; +exports.quisque = __small$_14; +exports.justo = __small$_15; +exports.vehicula = __small$_16; +exports.nunc = __small$_17; +exports.pharetra = __small$_18; +exports.lacus = __small$_19; +exports.pulvinar = __small$_20; +exports.ac = __small$_21; +exports.at = __small$_8; +exports.aenean = __small$_22; +exports.odio = __small$_23; +exports.ac = __small$_21; +exports.erat = __small$_24; +exports.nam = __small$_25; +exports.justo = __small$_15; +exports.aliquet = __small$_26; +exports.scelerisque = __small$_6; +exports.metus = __small$_27; +exports.volutpat = __small$_28; + +return exports; +})(); +var __small$_78 = (function() { +var exports = {}; +exports = { + amet: __small$_1, + consectetur: __small$_2, + adipiscing: __small$_3, + lobortis: __small$_4, + in: __small$_5, + scelerisque: __small$_6, + vulputate: __small$_7, + at: __small$_8, + facilisis: __small$_9, + urna: __small$_10, + donec: __small$_11, + morbi: __small$_12, + eleifend: __small$_13, + quisque: __small$_14, + justo: __small$_15, + vehicula: __small$_16, + nunc: __small$_17, + pharetra: __small$_18, + lacus: __small$_19, + pulvinar: __small$_20, + ac: __small$_21, + at: __small$_8, + aenean: __small$_22, + odio: __small$_23, + ac: __small$_21, + erat: __small$_24, + nam: __small$_25, + justo: __small$_15, + aliquet: __small$_26, + scelerisque: __small$_6, + metus: __small$_27, + volutpat: __small$_28, + ac: __small$_21, + venenatis: __small$_29 +}; +return exports; +})(); +var __small$_86 = (function() { +var exports = {}; +exports.ipsum = __small$_45; +exports.sit = __small$_37; +exports.nullam = __small$_50; +exports.odio = __small$_23; +exports.tortor = __small$_64; +exports.ac = __small$_21; +exports.nullam = __small$_50; +exports.pellentesque = __small$_40; +exports.cursus = __small$_65; +exports.cras = __small$_66; +exports.semper = __small$_67; +exports.malesuada = __small$_68; +exports.elementum = __small$_69; +exports.pretium = __small$_70; +exports.sodales = __small$_71; +exports.tortor = __small$_64; +exports.risus = __small$_72; +exports.hendrerit = __small$_73; +exports.tristique = __small$_74; +exports.vel = __small$_75; +exports.non = __small$_76; +exports.mattis = __small$_61; +exports.dolor = __small$_53; +exports.nisi = __small$_42; + +return exports; +})(); +exports.amet = (__small$_1 = (function() { +var exports = {}; +exports.lorem = __small$_38; + +return exports; +})()); +exports.consectetur = (__small$_2 = (function() { +var exports = {}; +exports = { + lorem: __small$_38 +}; +return exports; +})()); +exports.adipiscing = (__small$_3 = (function() { +var exports = {}; +exports.lorem = __small$_38; + +return exports; +})()); +exports.lobortis = (__small$_4 = (function() { +var exports = {}; +exports.lorem = __small$_38; + +return exports; +})()); +exports.in = (__small$_5 = (function() { +var exports = {}; +exports.lorem = __small$_38; + +return exports; +})()); +exports.scelerisque = (__small$_6 = (function() { +var exports = {}; +exports.lorem = __small$_38; +exports.mi = __small$_39; +exports.pellentesque = __small$_40; +exports.egestas = __small$_41; +exports.pulvinar = __small$_20; + +return exports; +})()); +exports.vulputate = (__small$_7 = (function() { +var exports = {}; +exports = { + lorem: __small$_38, + mi: __small$_39, + pellentesque: __small$_40, + egestas: __small$_41, + pulvinar: __small$_20, + at: __small$_8, + nisi: __small$_42 +}; +return exports; +})()); +exports.at = (__small$_8 = (function() { +var exports = {}; +exports.amet = __small$_1; +exports.consectetur = __small$_2; +exports.adipiscing = __small$_3; +exports.lobortis = __small$_4; +exports.in = __small$_5; +exports.scelerisque = __small$_6; + +return exports; +})()); +exports.facilisis = (__small$_9 = (function() { +var exports = {}; +exports.lorem = __small$_38; +exports.mi = __small$_39; +exports.pellentesque = __small$_40; +exports.egestas = __small$_41; +exports.pulvinar = __small$_20; +exports.at = __small$_8; +exports.nisi = __small$_42; + +return exports; +})()); +exports.urna = (__small$_10 = (function() { +var exports = {}; +exports = { + lorem: __small$_38, + mi: __small$_39, + pellentesque: __small$_40, + egestas: __small$_41, + pulvinar: __small$_20, + at: __small$_8, + nisi: __small$_42 +}; +return exports; +})()); +exports.donec = (__small$_11 = (function() { +var exports = {}; +exports.lorem = __small$_38; +exports.mi = __small$_39; +exports.pellentesque = __small$_40; +exports.egestas = __small$_41; +exports.pulvinar = __small$_20; +exports.at = __small$_8; +exports.nisi = __small$_42; +exports.nec = __small$_43; + +return exports; +})()); +exports.morbi = (__small$_12 = (function() { +var exports = {}; +exports.lorem = __small$_38; +exports.mi = __small$_39; +exports.pellentesque = __small$_40; +exports.egestas = __small$_41; +exports.pulvinar = __small$_20; +exports.at = __small$_8; +exports.nisi = __small$_42; +exports.nec = __small$_43; +exports.diam = __small$_44; +exports.sit = __small$_37; +exports.ipsum = __small$_45; + +return exports; +})()); +exports.eleifend = (__small$_13 = (function() { +var exports = {}; +exports.lorem = __small$_38; +exports.mi = __small$_39; +exports.pellentesque = __small$_40; +exports.egestas = __small$_41; +exports.pulvinar = __small$_20; +exports.at = __small$_8; +exports.nisi = __small$_42; +exports.nec = __small$_43; +exports.diam = __small$_44; +exports.sit = __small$_37; +exports.ipsum = __small$_45; +exports.porta = __small$_46; +exports.suscipit = __small$_47; +exports.et = __small$_48; + +return exports; +})()); +exports.quisque = (__small$_14 = (function() { +var exports = {}; +exports.lorem = __small$_38; +exports.mi = __small$_39; +exports.pellentesque = __small$_40; +exports.egestas = __small$_41; +exports.pulvinar = __small$_20; +exports.at = __small$_8; +exports.nisi = __small$_42; +exports.nec = __small$_43; +exports.diam = __small$_44; +exports.sit = __small$_37; +exports.ipsum = __small$_45; +exports.porta = __small$_46; +exports.suscipit = __small$_47; +exports.et = __small$_48; + +return exports; +})()); +exports.justo = (__small$_15 = (function() { +var exports = {}; +exports.lorem = __small$_38; +exports.mi = __small$_39; +exports.pellentesque = __small$_40; +exports.egestas = __small$_41; +exports.pulvinar = __small$_20; +exports.at = __small$_8; +exports.nisi = __small$_42; +exports.nec = __small$_43; +exports.diam = __small$_44; +exports.sit = __small$_37; +exports.ipsum = __small$_45; +exports.porta = __small$_46; +exports.suscipit = __small$_47; +exports.et = __small$_48; +exports.viverra = __small$_49; + +return exports; +})()); +exports.vehicula = (__small$_16 = (function() { +var exports = {}; +exports = { + lorem: __small$_38, + mi: __small$_39, + pellentesque: __small$_40, + egestas: __small$_41, + pulvinar: __small$_20, + at: __small$_8, + nisi: __small$_42, + nec: __small$_43, + diam: __small$_44, + sit: __small$_37, + ipsum: __small$_45, + porta: __small$_46, + suscipit: __small$_47, + et: __small$_48, + viverra: __small$_49 +}; +return exports; +})()); +exports.nunc = (__small$_17 = (function() { +var exports = {}; +exports = { + ipsum: __small$_45, + sit: __small$_37, + nullam: __small$_50, + odio: __small$_23 +}; +return exports; +})()); +exports.pharetra = (__small$_18 = (function() { +var exports = {}; +exports.lorem = __small$_38; +exports.mi = __small$_39; +exports.pellentesque = __small$_40; +exports.egestas = __small$_41; +exports.pulvinar = __small$_20; +exports.at = __small$_8; +exports.nisi = __small$_42; +exports.nec = __small$_43; +exports.diam = __small$_44; +exports.sit = __small$_37; +exports.ipsum = __small$_45; +exports.porta = __small$_46; +exports.suscipit = __small$_47; +exports.et = __small$_48; +exports.viverra = __small$_49; +exports.ultrices = __small$_51; +exports.at = __small$_8; + +return exports; +})()); +exports.lacus = (__small$_19 = (function() { +var exports = {}; +exports.lorem = __small$_38; +exports.mi = __small$_39; +exports.pellentesque = __small$_40; +exports.egestas = __small$_41; +exports.pulvinar = __small$_20; +exports.at = __small$_8; +exports.nisi = __small$_42; +exports.nec = __small$_43; +exports.diam = __small$_44; +exports.sit = __small$_37; +exports.ipsum = __small$_45; +exports.porta = __small$_46; +exports.suscipit = __small$_47; +exports.et = __small$_48; +exports.viverra = __small$_49; +exports.ultrices = __small$_51; +exports.at = __small$_8; +exports.vehicula = __small$_16; +exports.dui = __small$_52; + +return exports; +})()); +exports.pulvinar = (__small$_20 = (function() { +var exports = {}; +exports = { + amet: __small$_1, + consectetur: __small$_2, + adipiscing: __small$_3, + lobortis: __small$_4, + in: __small$_5 +}; +return exports; +})()); +exports.ac = (__small$_21 = (function() { +var exports = {}; +exports = { + dolor: __small$_53, + elit: __small$_54, + rutrum: __small$_55, + interdum: __small$_56, + mollis: __small$_57, + etiam: __small$_58, + nunc: __small$_17, + ornare: __small$_59 +}; +return exports; +})()); +exports.at = __small$_8; +exports.aenean = (__small$_22 = (function() { +var exports = {}; +exports.lorem = __small$_38; +exports.mi = __small$_39; +exports.pellentesque = __small$_40; +exports.egestas = __small$_41; +exports.pulvinar = __small$_20; +exports.at = __small$_8; +exports.nisi = __small$_42; +exports.nec = __small$_43; +exports.diam = __small$_44; +exports.sit = __small$_37; +exports.ipsum = __small$_45; +exports.porta = __small$_46; +exports.suscipit = __small$_47; +exports.et = __small$_48; +exports.viverra = __small$_49; +exports.ultrices = __small$_51; +exports.at = __small$_8; +exports.vehicula = __small$_16; +exports.dui = __small$_52; +exports.nibh = __small$_60; +exports.mattis = __small$_61; +exports.imperdiet = __small$_62; + +return exports; +})()); +exports.odio = (__small$_23 = (function() { +var exports = {}; +exports = { + dolor: __small$_53, + elit: __small$_54, + rutrum: __small$_55 +}; +return exports; +})()); +exports.ac = __small$_21; +exports.erat = (__small$_24 = (function() { +var exports = {}; +exports.lorem = __small$_38; +exports.mi = __small$_39; +exports.pellentesque = __small$_40; +exports.egestas = __small$_41; +exports.pulvinar = __small$_20; +exports.at = __small$_8; +exports.nisi = __small$_42; +exports.nec = __small$_43; +exports.diam = __small$_44; +exports.sit = __small$_37; +exports.ipsum = __small$_45; +exports.porta = __small$_46; +exports.suscipit = __small$_47; +exports.et = __small$_48; +exports.viverra = __small$_49; +exports.ultrices = __small$_51; +exports.at = __small$_8; +exports.vehicula = __small$_16; +exports.dui = __small$_52; +exports.nibh = __small$_60; +exports.mattis = __small$_61; +exports.imperdiet = __small$_62; +exports.integer = __small$_63; +exports.varius = __small$_36; + +return exports; +})()); +exports.nam = (__small$_25 = (function() { +var exports = {}; +exports.lorem = __small$_38; +exports.mi = __small$_39; +exports.pellentesque = __small$_40; +exports.egestas = __small$_41; +exports.pulvinar = __small$_20; +exports.at = __small$_8; +exports.nisi = __small$_42; +exports.nec = __small$_43; +exports.diam = __small$_44; +exports.sit = __small$_37; +exports.ipsum = __small$_45; +exports.porta = __small$_46; +exports.suscipit = __small$_47; +exports.et = __small$_48; +exports.viverra = __small$_49; +exports.ultrices = __small$_51; +exports.at = __small$_8; +exports.vehicula = __small$_16; +exports.dui = __small$_52; +exports.nibh = __small$_60; +exports.mattis = __small$_61; +exports.imperdiet = __small$_62; +exports.integer = __small$_63; +exports.varius = __small$_36; + +return exports; +})()); +exports.justo = __small$_15; +exports.aliquet = (__small$_26 = (function() { +var exports = {}; +exports.ipsum = __small$_45; +exports.sit = __small$_37; +exports.nullam = __small$_50; +exports.odio = __small$_23; +exports.tortor = __small$_64; +exports.ac = __small$_21; +exports.nullam = __small$_50; + +return exports; +})()); +exports.scelerisque = __small$_6; +exports.metus = (__small$_27 = (function() { +var exports = {}; +exports.ipsum = __small$_45; +exports.sit = __small$_37; +exports.nullam = __small$_50; +exports.odio = __small$_23; +exports.tortor = __small$_64; +exports.ac = __small$_21; +exports.nullam = __small$_50; +exports.pellentesque = __small$_40; +exports.cursus = __small$_65; +exports.cras = __small$_66; +exports.semper = __small$_67; +exports.malesuada = __small$_68; +exports.elementum = __small$_69; +exports.pretium = __small$_70; +exports.sodales = __small$_71; +exports.tortor = __small$_64; +exports.risus = __small$_72; +exports.hendrerit = __small$_73; +exports.tristique = __small$_74; +exports.vel = __small$_75; +exports.non = __small$_76; +exports.mattis = __small$_61; +exports.dolor = __small$_53; +exports.nisi = __small$_42; + +return exports; +})()); +exports.volutpat = (__small$_28 = (function() { +var exports = {}; +exports.lorem = __small$_38; +exports.mi = __small$_39; +exports.pellentesque = __small$_40; +exports.egestas = __small$_41; +exports.pulvinar = __small$_20; +exports.at = __small$_8; +exports.nisi = __small$_42; +exports.nec = __small$_43; +exports.diam = __small$_44; +exports.sit = __small$_37; +exports.ipsum = __small$_45; +exports.porta = __small$_46; +exports.suscipit = __small$_47; +exports.et = __small$_48; +exports.viverra = __small$_49; +exports.ultrices = __small$_51; +exports.at = __small$_8; +exports.vehicula = __small$_16; +exports.dui = __small$_52; +exports.nibh = __small$_60; +exports.mattis = __small$_61; +exports.imperdiet = __small$_62; +exports.integer = __small$_63; +exports.varius = __small$_36; +exports.in = __small$_5; + +return exports; +})()); +exports.ac = __small$_21; +exports.venenatis = (__small$_29 = (function() { +var exports = {}; +exports.lorem = __small$_38; +exports.mi = __small$_39; +exports.pellentesque = __small$_40; +exports.egestas = __small$_41; +exports.pulvinar = __small$_20; +exports.at = __small$_8; +exports.nisi = __small$_42; +exports.nec = __small$_43; +exports.diam = __small$_44; +exports.sit = __small$_37; +exports.ipsum = __small$_45; +exports.porta = __small$_46; +exports.suscipit = __small$_47; +exports.et = __small$_48; +exports.viverra = __small$_49; +exports.ultrices = __small$_51; +exports.at = __small$_8; +exports.vehicula = __small$_16; +exports.dui = __small$_52; +exports.nibh = __small$_60; +exports.mattis = __small$_61; +exports.imperdiet = __small$_62; +exports.integer = __small$_63; +exports.varius = __small$_36; +exports.in = __small$_5; +exports.auctor = __small$_77; +exports.urna = __small$_10; + +return exports; +})()); +exports.justo = __small$_15; +exports.quam = (__small$_30 = (function() { +var exports = {}; +exports.lorem = __small$_38; +exports.mi = __small$_39; +exports.pellentesque = __small$_40; +exports.egestas = __small$_41; +exports.pulvinar = __small$_20; +exports.at = __small$_8; +exports.nisi = __small$_42; +exports.nec = __small$_43; +exports.diam = __small$_44; +exports.sit = __small$_37; +exports.ipsum = __small$_45; +exports.porta = __small$_46; +exports.suscipit = __small$_47; +exports.et = __small$_48; +exports.viverra = __small$_49; +exports.ultrices = __small$_51; +exports.at = __small$_8; +exports.vehicula = __small$_16; +exports.dui = __small$_52; +exports.nibh = __small$_60; +exports.mattis = __small$_61; +exports.imperdiet = __small$_62; +exports.integer = __small$_63; +exports.varius = __small$_36; +exports.in = __small$_5; +exports.auctor = __small$_77; +exports.urna = __small$_10; +exports.auctor = __small$_77; +exports.ante = __small$_78; +exports.sed = __small$_35; + +return exports; +})()); +exports.quis = (__small$_31 = (function() { +var exports = {}; +exports = { + dolor: __small$_53, + elit: __small$_54, + rutrum: __small$_55, + interdum: __small$_56, + mollis: __small$_57, + etiam: __small$_58, + nunc: __small$_17, + ornare: __small$_59, + eros: __small$_79, + nulla: __small$_80, + pulvinar: __small$_20, + aliquet: __small$_26, + ligula: __small$_81, + ullamcorper: __small$_82, + amet: __small$_1, + vulputate: __small$_7, + lorem: __small$_38, + libero: __small$_83, + tincidunt: __small$_84, + felis: __small$_85, + nisi: __small$_42, + sed: __small$_35, + felis: __small$_85, + ligula: __small$_81, + vulputate: __small$_7, + nam: __small$_25, + viverra: __small$_49, + metus: __small$_27, + tellus: __small$_86 +}; +return exports; +})()); +exports.augue = (__small$_32 = (function() { +var exports = {}; +exports = { + lorem: __small$_38, + mi: __small$_39, + pellentesque: __small$_40, + egestas: __small$_41, + pulvinar: __small$_20, + at: __small$_8, + nisi: __small$_42, + nec: __small$_43, + diam: __small$_44, + sit: __small$_37, + ipsum: __small$_45, + porta: __small$_46, + suscipit: __small$_47, + et: __small$_48, + viverra: __small$_49, + ultrices: __small$_51, + at: __small$_8, + vehicula: __small$_16, + dui: __small$_52, + nibh: __small$_60, + mattis: __small$_61, + imperdiet: __small$_62, + integer: __small$_63, + varius: __small$_36, + in: __small$_5, + auctor: __small$_77, + urna: __small$_10, + auctor: __small$_77, + ante: __small$_78, + sed: __small$_35, + sed: __small$_35 +}; +return exports; +})()); +exports.euismod = (__small$_33 = (function() { +var exports = {}; +exports.lorem = __small$_38; +exports.mi = __small$_39; +exports.pellentesque = __small$_40; +exports.egestas = __small$_41; +exports.pulvinar = __small$_20; +exports.at = __small$_8; +exports.nisi = __small$_42; +exports.nec = __small$_43; +exports.diam = __small$_44; +exports.sit = __small$_37; +exports.ipsum = __small$_45; +exports.porta = __small$_46; +exports.suscipit = __small$_47; +exports.et = __small$_48; +exports.viverra = __small$_49; +exports.ultrices = __small$_51; +exports.at = __small$_8; +exports.vehicula = __small$_16; +exports.dui = __small$_52; +exports.nibh = __small$_60; +exports.mattis = __small$_61; +exports.imperdiet = __small$_62; +exports.integer = __small$_63; +exports.varius = __small$_36; +exports.in = __small$_5; +exports.auctor = __small$_77; +exports.urna = __small$_10; +exports.auctor = __small$_77; +exports.ante = __small$_78; +exports.sed = __small$_35; +exports.sed = __small$_35; + +return exports; +})()); +exports.nunc = __small$_17; +exports.molestie = ((function() { +var exports = {}; +var __small$_93 = (function() { +var exports = {}; +exports.ipsum = __small$_45; +exports.sit = __small$_37; +exports.nullam = __small$_50; +exports.odio = __small$_23; +exports.tortor = __small$_64; +exports.ac = __small$_21; +exports.nullam = __small$_50; +exports.pellentesque = __small$_40; +exports.cursus = __small$_65; +exports.cras = __small$_66; +exports.semper = __small$_67; +exports.malesuada = __small$_68; +exports.elementum = __small$_69; +exports.pretium = __small$_70; +exports.sodales = __small$_71; +exports.tortor = __small$_64; +exports.risus = __small$_72; +exports.hendrerit = __small$_73; +exports.tristique = __small$_74; +exports.vel = __small$_75; +exports.non = __small$_76; +exports.mattis = __small$_61; +exports.dolor = __small$_53; +exports.nisi = __small$_42; +exports.quis = __small$_31; +exports.mi = __small$_39; + +return exports; +})(); +var __small$_91 = (function() { +var exports = {}; +exports.dolor = __small$_53; +exports.elit = __small$_54; +exports.rutrum = __small$_55; +exports.interdum = __small$_56; +exports.mollis = __small$_57; +exports.etiam = __small$_58; +exports.nunc = __small$_17; +exports.ornare = __small$_59; +exports.eros = __small$_79; +exports.nulla = __small$_80; +exports.pulvinar = __small$_20; +exports.aliquet = __small$_26; +exports.ligula = __small$_81; +exports.ullamcorper = __small$_82; +exports.amet = __small$_1; +exports.vulputate = __small$_7; +exports.lorem = __small$_38; +exports.libero = __small$_83; +exports.tincidunt = __small$_84; +exports.felis = __small$_85; +exports.nisi = __small$_42; +exports.sed = __small$_35; +exports.felis = __small$_85; +exports.ligula = __small$_81; +exports.vulputate = __small$_7; +exports.nam = __small$_25; +exports.viverra = __small$_49; +exports.metus = __small$_27; +exports.tellus = __small$_86; +exports.lectus = __small$_93; +exports.urna = __small$_10; + +return exports; +})(); +var __small$_94 = (function() { +var exports = {}; +exports.ipsum = __small$_45; +exports.sit = __small$_37; +exports.nullam = __small$_50; +exports.odio = __small$_23; +exports.tortor = __small$_64; +exports.ac = __small$_21; +exports.nullam = __small$_50; +exports.pellentesque = __small$_40; +exports.cursus = __small$_65; +exports.cras = __small$_66; +exports.semper = __small$_67; +exports.malesuada = __small$_68; +exports.elementum = __small$_69; +exports.pretium = __small$_70; +exports.sodales = __small$_71; +exports.tortor = __small$_64; +exports.risus = __small$_72; +exports.hendrerit = __small$_73; +exports.tristique = __small$_74; +exports.vel = __small$_75; +exports.non = __small$_76; +exports.mattis = __small$_61; +exports.dolor = __small$_53; +exports.nisi = __small$_42; +exports.quis = __small$_31; +exports.mi = __small$_39; +exports.mauris = __small$_91; + +return exports; +})(); +var __small$_95 = (function() { +var exports = {}; +exports.ipsum = __small$_45; +exports.sit = __small$_37; +exports.nullam = __small$_50; +exports.odio = __small$_23; +exports.tortor = __small$_64; +exports.ac = __small$_21; +exports.nullam = __small$_50; +exports.pellentesque = __small$_40; +exports.cursus = __small$_65; +exports.cras = __small$_66; +exports.semper = __small$_67; +exports.malesuada = __small$_68; +exports.elementum = __small$_69; +exports.pretium = __small$_70; +exports.sodales = __small$_71; +exports.tortor = __small$_64; +exports.risus = __small$_72; +exports.hendrerit = __small$_73; +exports.tristique = __small$_74; +exports.vel = __small$_75; +exports.non = __small$_76; +exports.mattis = __small$_61; +exports.dolor = __small$_53; +exports.nisi = __small$_42; +exports.quis = __small$_31; +exports.mi = __small$_39; +exports.mauris = __small$_91; +exports.in = __small$_5; + +return exports; +})(); +var __small$_96 = (function() { +var exports = {}; +exports.ipsum = __small$_45; +exports.sit = __small$_37; +exports.nullam = __small$_50; +exports.odio = __small$_23; +exports.tortor = __small$_64; +exports.ac = __small$_21; +exports.nullam = __small$_50; +exports.pellentesque = __small$_40; +exports.cursus = __small$_65; +exports.cras = __small$_66; +exports.semper = __small$_67; +exports.malesuada = __small$_68; +exports.elementum = __small$_69; +exports.pretium = __small$_70; +exports.sodales = __small$_71; +exports.tortor = __small$_64; +exports.risus = __small$_72; +exports.hendrerit = __small$_73; +exports.tristique = __small$_74; +exports.vel = __small$_75; +exports.non = __small$_76; +exports.mattis = __small$_61; +exports.dolor = __small$_53; +exports.nisi = __small$_42; +exports.quis = __small$_31; +exports.mi = __small$_39; +exports.mauris = __small$_91; +exports.in = __small$_5; + +return exports; +})(); +exports.lorem = __small$_38; +exports.mi = __small$_39; +exports.pellentesque = __small$_40; +exports.egestas = __small$_41; +exports.pulvinar = __small$_20; +exports.at = __small$_8; +exports.nisi = __small$_42; +exports.nec = __small$_43; +exports.diam = __small$_44; +exports.sit = __small$_37; +exports.ipsum = __small$_45; +exports.porta = __small$_46; +exports.suscipit = __small$_47; +exports.et = __small$_48; +exports.viverra = __small$_49; +exports.ultrices = __small$_51; +exports.at = __small$_8; +exports.vehicula = __small$_16; +exports.dui = __small$_52; +exports.nibh = __small$_60; +exports.mattis = __small$_61; +exports.imperdiet = __small$_62; +exports.integer = __small$_63; +exports.varius = __small$_36; +exports.in = __small$_5; +exports.auctor = __small$_77; +exports.urna = __small$_10; +exports.auctor = __small$_77; +exports.ante = __small$_78; +exports.sed = __small$_35; +exports.sed = __small$_35; +exports.aliquam = ((function() { +var exports = {}; +exports.amet = __small$_1; +exports.consectetur = __small$_2; +exports.adipiscing = __small$_3; +exports.lobortis = __small$_4; +exports.in = __small$_5; +exports.scelerisque = __small$_6; +exports.vulputate = __small$_7; +exports.at = __small$_8; +exports.facilisis = __small$_9; +exports.urna = __small$_10; +exports.donec = __small$_11; +exports.morbi = __small$_12; +exports.eleifend = __small$_13; +exports.quisque = __small$_14; +exports.justo = __small$_15; +exports.vehicula = __small$_16; +exports.nunc = __small$_17; +exports.pharetra = __small$_18; +exports.lacus = __small$_19; +exports.pulvinar = __small$_20; +exports.ac = __small$_21; +exports.at = __small$_8; +exports.aenean = __small$_22; +exports.odio = __small$_23; +exports.ac = __small$_21; +exports.erat = __small$_24; +exports.nam = __small$_25; +exports.justo = __small$_15; +exports.aliquet = __small$_26; +exports.scelerisque = __small$_6; +exports.metus = __small$_27; +exports.volutpat = __small$_28; +exports.ac = __small$_21; +exports.venenatis = __small$_29; +exports.justo = __small$_15; +exports.quam = __small$_30; +exports.quis = __small$_31; +exports.augue = __small$_32; +exports.euismod = __small$_33; + +return exports; +})()); +exports.lacus = __small$_19; +exports.tempor = ((function() { +var exports = {}; +exports.amet = __small$_1; +exports.consectetur = __small$_2; +exports.adipiscing = __small$_3; +exports.lobortis = __small$_4; +exports.in = __small$_5; +exports.scelerisque = __small$_6; +exports.vulputate = __small$_7; +exports.at = __small$_8; +exports.facilisis = __small$_9; +exports.urna = __small$_10; +exports.donec = __small$_11; +exports.morbi = __small$_12; +exports.eleifend = __small$_13; +exports.quisque = __small$_14; +exports.justo = __small$_15; +exports.vehicula = __small$_16; +exports.nunc = __small$_17; +exports.pharetra = __small$_18; +exports.lacus = __small$_19; +exports.pulvinar = __small$_20; +exports.ac = __small$_21; +exports.at = __small$_8; +exports.aenean = __small$_22; +exports.odio = __small$_23; +exports.ac = __small$_21; +exports.erat = __small$_24; +exports.nam = __small$_25; +exports.justo = __small$_15; +exports.aliquet = __small$_26; +exports.scelerisque = __small$_6; +exports.metus = __small$_27; +exports.volutpat = __small$_28; +exports.ac = __small$_21; +exports.venenatis = __small$_29; +exports.justo = __small$_15; +exports.quam = __small$_30; +exports.quis = __small$_31; +exports.augue = __small$_32; +exports.euismod = __small$_33; + +return exports; +})()); +exports.interdum = __small$_56; +exports.id = ((function() { +var exports = {}; +exports = { + ipsum: __small$_45, + sit: __small$_37, + nullam: __small$_50, + odio: __small$_23, + tortor: __small$_64, + ac: __small$_21, + nullam: __small$_50, + pellentesque: __small$_40, + cursus: __small$_65, + cras: __small$_66, + semper: __small$_67, + malesuada: __small$_68, + elementum: __small$_69, + pretium: __small$_70, + sodales: __small$_71, + tortor: __small$_64, + risus: __small$_72, + hendrerit: __small$_73, + tristique: __small$_74, + vel: __small$_75, + non: __small$_76, + mattis: __small$_61, + dolor: __small$_53, + nisi: __small$_42, + quis: __small$_31, + mi: __small$_39, + mauris: __small$_91, + in: __small$_5, + porttitor: __small$_90, + commodo: ((function() { +var exports = {}; +exports.dolor = __small$_53; +exports.elit = __small$_54; +exports.rutrum = __small$_55; +exports.interdum = __small$_56; +exports.mollis = __small$_57; +exports.etiam = __small$_58; +exports.nunc = __small$_17; +exports.ornare = __small$_59; +exports.eros = __small$_79; +exports.nulla = __small$_80; +exports.pulvinar = __small$_20; +exports.aliquet = __small$_26; +exports.ligula = __small$_81; +exports.ullamcorper = __small$_82; +exports.amet = __small$_1; +exports.vulputate = __small$_7; +exports.lorem = __small$_38; +exports.libero = __small$_83; +exports.tincidunt = __small$_84; +exports.felis = __small$_85; +exports.nisi = __small$_42; +exports.sed = __small$_35; +exports.felis = __small$_85; +exports.ligula = __small$_81; +exports.vulputate = __small$_7; +exports.nam = __small$_25; +exports.viverra = __small$_49; +exports.metus = __small$_27; +exports.tellus = __small$_86; +exports.lectus = __small$_93; +exports.urna = __small$_10; +exports.neque = __small$_94; +exports.mauris = __small$_91; +exports.a = __small$_95; +exports.posuere = __small$_96; + +return exports; +})()), + vel: __small$_75, + porta: __small$_46, + vel: __small$_75 +}; +return exports; +})()); +exports.porttitor = (__small$_90 = (function() { +var exports = {}; +exports.dolor = __small$_53; +exports.elit = __small$_54; +exports.rutrum = __small$_55; +exports.interdum = __small$_56; +exports.mollis = __small$_57; +exports.etiam = __small$_58; +exports.nunc = __small$_17; +exports.ornare = __small$_59; +exports.eros = __small$_79; +exports.nulla = __small$_80; +exports.pulvinar = __small$_20; +exports.aliquet = __small$_26; +exports.ligula = __small$_81; +exports.ullamcorper = __small$_82; +exports.amet = __small$_1; +exports.vulputate = __small$_7; +exports.lorem = __small$_38; +exports.libero = __small$_83; +exports.tincidunt = __small$_84; +exports.felis = __small$_85; +exports.nisi = __small$_42; +exports.sed = __small$_35; +exports.felis = __small$_85; +exports.ligula = __small$_81; +exports.vulputate = __small$_7; +exports.nam = __small$_25; +exports.viverra = __small$_49; +exports.metus = __small$_27; +exports.tellus = __small$_86; +exports.lectus = __small$_93; +exports.urna = __small$_10; +exports.neque = __small$_94; +exports.mauris = __small$_91; +exports.a = __small$_95; +exports.posuere = __small$_96; + +return exports; +})()); +exports.eros = __small$_79; + +return exports; +})()); +exports.sed = (__small$_35 = (function() { +var exports = {}; +exports = { + ipsum: __small$_45, + sit: __small$_37, + nullam: __small$_50, + odio: __small$_23, + tortor: __small$_64, + ac: __small$_21, + nullam: __small$_50, + pellentesque: __small$_40, + cursus: __small$_65, + cras: __small$_66, + semper: __small$_67, + malesuada: __small$_68, + elementum: __small$_69, + pretium: __small$_70, + sodales: __small$_71, + tortor: __small$_64, + risus: __small$_72 +}; +return exports; +})()); +exports.varius = (__small$_36 = (function() { +var exports = {}; +exports = { + amet: __small$_1, + consectetur: __small$_2, + adipiscing: __small$_3, + lobortis: __small$_4, + in: __small$_5, + scelerisque: __small$_6, + vulputate: __small$_7, + at: __small$_8, + facilisis: __small$_9, + urna: __small$_10, + donec: __small$_11, + morbi: __small$_12, + eleifend: __small$_13, + quisque: __small$_14, + justo: __small$_15, + vehicula: __small$_16, + nunc: __small$_17, + pharetra: __small$_18, + lacus: __small$_19, + pulvinar: __small$_20, + ac: __small$_21, + at: __small$_8, + aenean: __small$_22, + odio: __small$_23, + ac: __small$_21 +}; +return exports; +})()); +exports.sit = (__small$_37 = (function() { +var exports = {}; +exports.dolor = __small$_53; + +return exports; +})()); + +return exports; +})); diff --git a/examples/big/output.common.js b/examples/big/output.common.js new file mode 100644 index 0000000..6f1009c --- /dev/null +++ b/examples/big/output.common.js @@ -0,0 +1,1984 @@ +module.exports = (function() { +var exports = {}; +var __small$_38 = (function() { +var exports = {}; +exports = { + +}; +return exports; +})(); +var __small$_39 = (function() { +var exports = {}; +exports.amet = __small$_1; +exports.consectetur = __small$_2; +exports.adipiscing = __small$_3; +exports.lobortis = __small$_4; +exports.in = __small$_5; + +return exports; +})(); +var __small$_40 = (function() { +var exports = {}; +exports.amet = __small$_1; +exports.consectetur = __small$_2; +exports.adipiscing = __small$_3; +exports.lobortis = __small$_4; +exports.in = __small$_5; + +return exports; +})(); +var __small$_41 = (function() { +var exports = {}; +exports.amet = __small$_1; +exports.consectetur = __small$_2; +exports.adipiscing = __small$_3; +exports.lobortis = __small$_4; +exports.in = __small$_5; + +return exports; +})(); +var __small$_42 = (function() { +var exports = {}; +exports.amet = __small$_1; +exports.consectetur = __small$_2; +exports.adipiscing = __small$_3; +exports.lobortis = __small$_4; +exports.in = __small$_5; +exports.scelerisque = __small$_6; + +return exports; +})(); +var __small$_43 = (function() { +var exports = {}; +exports.amet = __small$_1; +exports.consectetur = __small$_2; +exports.adipiscing = __small$_3; +exports.lobortis = __small$_4; +exports.in = __small$_5; +exports.scelerisque = __small$_6; +exports.vulputate = __small$_7; +exports.at = __small$_8; +exports.facilisis = __small$_9; +exports.urna = __small$_10; + +return exports; +})(); +var __small$_44 = (function() { +var exports = {}; +exports = { + amet: __small$_1, + consectetur: __small$_2, + adipiscing: __small$_3, + lobortis: __small$_4, + in: __small$_5, + scelerisque: __small$_6, + vulputate: __small$_7, + at: __small$_8, + facilisis: __small$_9, + urna: __small$_10, + donec: __small$_11 +}; +return exports; +})(); +var __small$_45 = (function() { +var exports = {}; + +return exports; +})(); +var __small$_53 = (function() { +var exports = {}; +exports.ipsum = __small$_45; + +return exports; +})(); +var __small$_46 = (function() { +var exports = {}; +exports.amet = __small$_1; +exports.consectetur = __small$_2; +exports.adipiscing = __small$_3; +exports.lobortis = __small$_4; +exports.in = __small$_5; +exports.scelerisque = __small$_6; +exports.vulputate = __small$_7; +exports.at = __small$_8; +exports.facilisis = __small$_9; +exports.urna = __small$_10; +exports.donec = __small$_11; +exports.morbi = __small$_12; + +return exports; +})(); +var __small$_47 = (function() { +var exports = {}; +exports.amet = __small$_1; +exports.consectetur = __small$_2; +exports.adipiscing = __small$_3; +exports.lobortis = __small$_4; +exports.in = __small$_5; +exports.scelerisque = __small$_6; +exports.vulputate = __small$_7; +exports.at = __small$_8; +exports.facilisis = __small$_9; +exports.urna = __small$_10; +exports.donec = __small$_11; +exports.morbi = __small$_12; + +return exports; +})(); +var __small$_48 = (function() { +var exports = {}; +exports = { + amet: __small$_1, + consectetur: __small$_2, + adipiscing: __small$_3, + lobortis: __small$_4, + in: __small$_5, + scelerisque: __small$_6, + vulputate: __small$_7, + at: __small$_8, + facilisis: __small$_9, + urna: __small$_10, + donec: __small$_11, + morbi: __small$_12 +}; +return exports; +})(); +var __small$_49 = (function() { +var exports = {}; +exports.amet = __small$_1; +exports.consectetur = __small$_2; +exports.adipiscing = __small$_3; +exports.lobortis = __small$_4; +exports.in = __small$_5; +exports.scelerisque = __small$_6; +exports.vulputate = __small$_7; +exports.at = __small$_8; +exports.facilisis = __small$_9; +exports.urna = __small$_10; +exports.donec = __small$_11; +exports.morbi = __small$_12; +exports.eleifend = __small$_13; +exports.quisque = __small$_14; + +return exports; +})(); +var __small$_54 = (function() { +var exports = {}; +exports.ipsum = __small$_45; +exports.sit = __small$_37; + +return exports; +})(); +var __small$_50 = (function() { +var exports = {}; +exports.dolor = __small$_53; +exports.elit = __small$_54; + +return exports; +})(); +var __small$_55 = (function() { +var exports = {}; +exports.ipsum = __small$_45; +exports.sit = __small$_37; +exports.nullam = __small$_50; + +return exports; +})(); +var __small$_51 = (function() { +var exports = {}; +exports = { + amet: __small$_1, + consectetur: __small$_2, + adipiscing: __small$_3, + lobortis: __small$_4, + in: __small$_5, + scelerisque: __small$_6, + vulputate: __small$_7, + at: __small$_8, + facilisis: __small$_9, + urna: __small$_10, + donec: __small$_11, + morbi: __small$_12, + eleifend: __small$_13, + quisque: __small$_14, + justo: __small$_15, + vehicula: __small$_16, + nunc: __small$_17 +}; +return exports; +})(); +var __small$_52 = (function() { +var exports = {}; +exports = { + amet: __small$_1, + consectetur: __small$_2, + adipiscing: __small$_3, + lobortis: __small$_4, + in: __small$_5, + scelerisque: __small$_6, + vulputate: __small$_7, + at: __small$_8, + facilisis: __small$_9, + urna: __small$_10, + donec: __small$_11, + morbi: __small$_12, + eleifend: __small$_13, + quisque: __small$_14, + justo: __small$_15, + vehicula: __small$_16, + nunc: __small$_17, + pharetra: __small$_18 +}; +return exports; +})(); +var __small$_56 = (function() { +var exports = {}; +exports.ipsum = __small$_45; +exports.sit = __small$_37; +exports.nullam = __small$_50; +exports.odio = __small$_23; + +return exports; +})(); +var __small$_57 = (function() { +var exports = {}; +exports.ipsum = __small$_45; +exports.sit = __small$_37; +exports.nullam = __small$_50; +exports.odio = __small$_23; + +return exports; +})(); +var __small$_58 = (function() { +var exports = {}; +exports.ipsum = __small$_45; +exports.sit = __small$_37; +exports.nullam = __small$_50; +exports.odio = __small$_23; + +return exports; +})(); +var __small$_60 = (function() { +var exports = {}; +exports.amet = __small$_1; +exports.consectetur = __small$_2; +exports.adipiscing = __small$_3; +exports.lobortis = __small$_4; +exports.in = __small$_5; +exports.scelerisque = __small$_6; +exports.vulputate = __small$_7; +exports.at = __small$_8; +exports.facilisis = __small$_9; +exports.urna = __small$_10; +exports.donec = __small$_11; +exports.morbi = __small$_12; +exports.eleifend = __small$_13; +exports.quisque = __small$_14; +exports.justo = __small$_15; +exports.vehicula = __small$_16; +exports.nunc = __small$_17; +exports.pharetra = __small$_18; +exports.lacus = __small$_19; +exports.pulvinar = __small$_20; + +return exports; +})(); +var __small$_64 = (function() { +var exports = {}; +exports.dolor = __small$_53; +exports.elit = __small$_54; +exports.rutrum = __small$_55; +exports.interdum = __small$_56; +exports.mollis = __small$_57; +exports.etiam = __small$_58; +exports.nunc = __small$_17; + +return exports; +})(); +var __small$_59 = (function() { +var exports = {}; +exports.ipsum = __small$_45; +exports.sit = __small$_37; +exports.nullam = __small$_50; +exports.odio = __small$_23; +exports.tortor = __small$_64; + +return exports; +})(); +var __small$_61 = (function() { +var exports = {}; +exports.amet = __small$_1; +exports.consectetur = __small$_2; +exports.adipiscing = __small$_3; +exports.lobortis = __small$_4; +exports.in = __small$_5; +exports.scelerisque = __small$_6; +exports.vulputate = __small$_7; +exports.at = __small$_8; +exports.facilisis = __small$_9; +exports.urna = __small$_10; +exports.donec = __small$_11; +exports.morbi = __small$_12; +exports.eleifend = __small$_13; +exports.quisque = __small$_14; +exports.justo = __small$_15; +exports.vehicula = __small$_16; +exports.nunc = __small$_17; +exports.pharetra = __small$_18; +exports.lacus = __small$_19; +exports.pulvinar = __small$_20; +exports.ac = __small$_21; +exports.at = __small$_8; + +return exports; +})(); +var __small$_62 = (function() { +var exports = {}; +exports.amet = __small$_1; +exports.consectetur = __small$_2; +exports.adipiscing = __small$_3; +exports.lobortis = __small$_4; +exports.in = __small$_5; +exports.scelerisque = __small$_6; +exports.vulputate = __small$_7; +exports.at = __small$_8; +exports.facilisis = __small$_9; +exports.urna = __small$_10; +exports.donec = __small$_11; +exports.morbi = __small$_12; +exports.eleifend = __small$_13; +exports.quisque = __small$_14; +exports.justo = __small$_15; +exports.vehicula = __small$_16; +exports.nunc = __small$_17; +exports.pharetra = __small$_18; +exports.lacus = __small$_19; +exports.pulvinar = __small$_20; +exports.ac = __small$_21; +exports.at = __small$_8; + +return exports; +})(); +var __small$_63 = (function() { +var exports = {}; +exports = { + amet: __small$_1, + consectetur: __small$_2, + adipiscing: __small$_3, + lobortis: __small$_4, + in: __small$_5, + scelerisque: __small$_6, + vulputate: __small$_7, + at: __small$_8, + facilisis: __small$_9, + urna: __small$_10, + donec: __small$_11, + morbi: __small$_12, + eleifend: __small$_13, + quisque: __small$_14, + justo: __small$_15, + vehicula: __small$_16, + nunc: __small$_17, + pharetra: __small$_18, + lacus: __small$_19, + pulvinar: __small$_20, + ac: __small$_21, + at: __small$_8, + aenean: __small$_22, + odio: __small$_23 +}; +return exports; +})(); +var __small$_79 = (function() { +var exports = {}; +exports.ipsum = __small$_45; +exports.sit = __small$_37; +exports.nullam = __small$_50; +exports.odio = __small$_23; +exports.tortor = __small$_64; +exports.ac = __small$_21; + +return exports; +})(); +var __small$_80 = (function() { +var exports = {}; +exports.ipsum = __small$_45; +exports.sit = __small$_37; +exports.nullam = __small$_50; +exports.odio = __small$_23; +exports.tortor = __small$_64; +exports.ac = __small$_21; +exports.nullam = __small$_50; + +return exports; +})(); +var __small$_65 = (function() { +var exports = {}; +exports.dolor = __small$_53; +exports.elit = __small$_54; +exports.rutrum = __small$_55; +exports.interdum = __small$_56; +exports.mollis = __small$_57; +exports.etiam = __small$_58; +exports.nunc = __small$_17; +exports.ornare = __small$_59; +exports.eros = __small$_79; +exports.nulla = __small$_80; +exports.pulvinar = __small$_20; +exports.aliquet = __small$_26; + +return exports; +})(); +var __small$_66 = (function() { +var exports = {}; +exports.dolor = __small$_53; +exports.elit = __small$_54; +exports.rutrum = __small$_55; +exports.interdum = __small$_56; +exports.mollis = __small$_57; +exports.etiam = __small$_58; +exports.nunc = __small$_17; +exports.ornare = __small$_59; +exports.eros = __small$_79; +exports.nulla = __small$_80; +exports.pulvinar = __small$_20; +exports.aliquet = __small$_26; + +return exports; +})(); +var __small$_67 = (function() { +var exports = {}; +exports.dolor = __small$_53; +exports.elit = __small$_54; +exports.rutrum = __small$_55; +exports.interdum = __small$_56; +exports.mollis = __small$_57; +exports.etiam = __small$_58; +exports.nunc = __small$_17; +exports.ornare = __small$_59; +exports.eros = __small$_79; +exports.nulla = __small$_80; +exports.pulvinar = __small$_20; +exports.aliquet = __small$_26; + +return exports; +})(); +var __small$_81 = (function() { +var exports = {}; +exports.ipsum = __small$_45; +exports.sit = __small$_37; +exports.nullam = __small$_50; +exports.odio = __small$_23; +exports.tortor = __small$_64; +exports.ac = __small$_21; +exports.nullam = __small$_50; +exports.pellentesque = __small$_40; +exports.cursus = __small$_65; +exports.cras = __small$_66; +exports.semper = __small$_67; + +return exports; +})(); +var __small$_68 = (function() { +var exports = {}; +exports.dolor = __small$_53; +exports.elit = __small$_54; +exports.rutrum = __small$_55; +exports.interdum = __small$_56; +exports.mollis = __small$_57; +exports.etiam = __small$_58; +exports.nunc = __small$_17; +exports.ornare = __small$_59; +exports.eros = __small$_79; +exports.nulla = __small$_80; +exports.pulvinar = __small$_20; +exports.aliquet = __small$_26; +exports.ligula = __small$_81; + +return exports; +})(); +var __small$_82 = (function() { +var exports = {}; +exports.ipsum = __small$_45; +exports.sit = __small$_37; +exports.nullam = __small$_50; +exports.odio = __small$_23; +exports.tortor = __small$_64; +exports.ac = __small$_21; +exports.nullam = __small$_50; +exports.pellentesque = __small$_40; +exports.cursus = __small$_65; +exports.cras = __small$_66; +exports.semper = __small$_67; +exports.malesuada = __small$_68; + +return exports; +})(); +var __small$_69 = (function() { +var exports = {}; +exports.dolor = __small$_53; +exports.elit = __small$_54; +exports.rutrum = __small$_55; +exports.interdum = __small$_56; +exports.mollis = __small$_57; +exports.etiam = __small$_58; +exports.nunc = __small$_17; +exports.ornare = __small$_59; +exports.eros = __small$_79; +exports.nulla = __small$_80; +exports.pulvinar = __small$_20; +exports.aliquet = __small$_26; +exports.ligula = __small$_81; +exports.ullamcorper = __small$_82; +exports.amet = __small$_1; + +return exports; +})(); +var __small$_83 = (function() { +var exports = {}; +exports.ipsum = __small$_45; +exports.sit = __small$_37; +exports.nullam = __small$_50; +exports.odio = __small$_23; +exports.tortor = __small$_64; +exports.ac = __small$_21; +exports.nullam = __small$_50; +exports.pellentesque = __small$_40; +exports.cursus = __small$_65; +exports.cras = __small$_66; +exports.semper = __small$_67; +exports.malesuada = __small$_68; +exports.elementum = __small$_69; + +return exports; +})(); +var __small$_84 = (function() { +var exports = {}; +exports.ipsum = __small$_45; +exports.sit = __small$_37; +exports.nullam = __small$_50; +exports.odio = __small$_23; +exports.tortor = __small$_64; +exports.ac = __small$_21; +exports.nullam = __small$_50; +exports.pellentesque = __small$_40; +exports.cursus = __small$_65; +exports.cras = __small$_66; +exports.semper = __small$_67; +exports.malesuada = __small$_68; +exports.elementum = __small$_69; + +return exports; +})(); +var __small$_70 = (function() { +var exports = {}; +exports.dolor = __small$_53; +exports.elit = __small$_54; +exports.rutrum = __small$_55; +exports.interdum = __small$_56; +exports.mollis = __small$_57; +exports.etiam = __small$_58; +exports.nunc = __small$_17; +exports.ornare = __small$_59; +exports.eros = __small$_79; +exports.nulla = __small$_80; +exports.pulvinar = __small$_20; +exports.aliquet = __small$_26; +exports.ligula = __small$_81; +exports.ullamcorper = __small$_82; +exports.amet = __small$_1; +exports.vulputate = __small$_7; +exports.lorem = __small$_38; +exports.libero = __small$_83; +exports.tincidunt = __small$_84; + +return exports; +})(); +var __small$_85 = (function() { +var exports = {}; +exports.ipsum = __small$_45; +exports.sit = __small$_37; +exports.nullam = __small$_50; +exports.odio = __small$_23; +exports.tortor = __small$_64; +exports.ac = __small$_21; +exports.nullam = __small$_50; +exports.pellentesque = __small$_40; +exports.cursus = __small$_65; +exports.cras = __small$_66; +exports.semper = __small$_67; +exports.malesuada = __small$_68; +exports.elementum = __small$_69; +exports.pretium = __small$_70; + +return exports; +})(); +var __small$_71 = (function() { +var exports = {}; +exports = { + dolor: __small$_53, + elit: __small$_54, + rutrum: __small$_55, + interdum: __small$_56, + mollis: __small$_57, + etiam: __small$_58, + nunc: __small$_17, + ornare: __small$_59, + eros: __small$_79, + nulla: __small$_80, + pulvinar: __small$_20, + aliquet: __small$_26, + ligula: __small$_81, + ullamcorper: __small$_82, + amet: __small$_1, + vulputate: __small$_7, + lorem: __small$_38, + libero: __small$_83, + tincidunt: __small$_84, + felis: __small$_85 +}; +return exports; +})(); +var __small$_72 = (function() { +var exports = {}; +exports.dolor = __small$_53; +exports.elit = __small$_54; +exports.rutrum = __small$_55; +exports.interdum = __small$_56; +exports.mollis = __small$_57; +exports.etiam = __small$_58; +exports.nunc = __small$_17; +exports.ornare = __small$_59; +exports.eros = __small$_79; +exports.nulla = __small$_80; +exports.pulvinar = __small$_20; +exports.aliquet = __small$_26; +exports.ligula = __small$_81; +exports.ullamcorper = __small$_82; +exports.amet = __small$_1; +exports.vulputate = __small$_7; +exports.lorem = __small$_38; +exports.libero = __small$_83; +exports.tincidunt = __small$_84; +exports.felis = __small$_85; + +return exports; +})(); +var __small$_73 = (function() { +var exports = {}; +exports.dolor = __small$_53; +exports.elit = __small$_54; +exports.rutrum = __small$_55; +exports.interdum = __small$_56; +exports.mollis = __small$_57; +exports.etiam = __small$_58; +exports.nunc = __small$_17; +exports.ornare = __small$_59; +exports.eros = __small$_79; +exports.nulla = __small$_80; +exports.pulvinar = __small$_20; +exports.aliquet = __small$_26; +exports.ligula = __small$_81; +exports.ullamcorper = __small$_82; +exports.amet = __small$_1; +exports.vulputate = __small$_7; +exports.lorem = __small$_38; +exports.libero = __small$_83; +exports.tincidunt = __small$_84; +exports.felis = __small$_85; +exports.nisi = __small$_42; +exports.sed = __small$_35; + +return exports; +})(); +var __small$_74 = (function() { +var exports = {}; +exports = { + dolor: __small$_53, + elit: __small$_54, + rutrum: __small$_55, + interdum: __small$_56, + mollis: __small$_57, + etiam: __small$_58, + nunc: __small$_17, + ornare: __small$_59, + eros: __small$_79, + nulla: __small$_80, + pulvinar: __small$_20, + aliquet: __small$_26, + ligula: __small$_81, + ullamcorper: __small$_82, + amet: __small$_1, + vulputate: __small$_7, + lorem: __small$_38, + libero: __small$_83, + tincidunt: __small$_84, + felis: __small$_85, + nisi: __small$_42, + sed: __small$_35, + felis: __small$_85 +}; +return exports; +})(); +var __small$_75 = (function() { +var exports = {}; +exports.dolor = __small$_53; +exports.elit = __small$_54; +exports.rutrum = __small$_55; +exports.interdum = __small$_56; +exports.mollis = __small$_57; +exports.etiam = __small$_58; +exports.nunc = __small$_17; +exports.ornare = __small$_59; +exports.eros = __small$_79; +exports.nulla = __small$_80; +exports.pulvinar = __small$_20; +exports.aliquet = __small$_26; +exports.ligula = __small$_81; +exports.ullamcorper = __small$_82; +exports.amet = __small$_1; +exports.vulputate = __small$_7; +exports.lorem = __small$_38; +exports.libero = __small$_83; +exports.tincidunt = __small$_84; +exports.felis = __small$_85; +exports.nisi = __small$_42; +exports.sed = __small$_35; +exports.felis = __small$_85; + +return exports; +})(); +var __small$_76 = (function() { +var exports = {}; +exports.dolor = __small$_53; +exports.elit = __small$_54; +exports.rutrum = __small$_55; +exports.interdum = __small$_56; +exports.mollis = __small$_57; +exports.etiam = __small$_58; +exports.nunc = __small$_17; +exports.ornare = __small$_59; +exports.eros = __small$_79; +exports.nulla = __small$_80; +exports.pulvinar = __small$_20; +exports.aliquet = __small$_26; +exports.ligula = __small$_81; +exports.ullamcorper = __small$_82; +exports.amet = __small$_1; +exports.vulputate = __small$_7; +exports.lorem = __small$_38; +exports.libero = __small$_83; +exports.tincidunt = __small$_84; +exports.felis = __small$_85; +exports.nisi = __small$_42; +exports.sed = __small$_35; +exports.felis = __small$_85; +exports.ligula = __small$_81; + +return exports; +})(); +var __small$_77 = (function() { +var exports = {}; +exports.amet = __small$_1; +exports.consectetur = __small$_2; +exports.adipiscing = __small$_3; +exports.lobortis = __small$_4; +exports.in = __small$_5; +exports.scelerisque = __small$_6; +exports.vulputate = __small$_7; +exports.at = __small$_8; +exports.facilisis = __small$_9; +exports.urna = __small$_10; +exports.donec = __small$_11; +exports.morbi = __small$_12; +exports.eleifend = __small$_13; +exports.quisque = __small$_14; +exports.justo = __small$_15; +exports.vehicula = __small$_16; +exports.nunc = __small$_17; +exports.pharetra = __small$_18; +exports.lacus = __small$_19; +exports.pulvinar = __small$_20; +exports.ac = __small$_21; +exports.at = __small$_8; +exports.aenean = __small$_22; +exports.odio = __small$_23; +exports.ac = __small$_21; +exports.erat = __small$_24; +exports.nam = __small$_25; +exports.justo = __small$_15; +exports.aliquet = __small$_26; +exports.scelerisque = __small$_6; +exports.metus = __small$_27; +exports.volutpat = __small$_28; + +return exports; +})(); +var __small$_78 = (function() { +var exports = {}; +exports = { + amet: __small$_1, + consectetur: __small$_2, + adipiscing: __small$_3, + lobortis: __small$_4, + in: __small$_5, + scelerisque: __small$_6, + vulputate: __small$_7, + at: __small$_8, + facilisis: __small$_9, + urna: __small$_10, + donec: __small$_11, + morbi: __small$_12, + eleifend: __small$_13, + quisque: __small$_14, + justo: __small$_15, + vehicula: __small$_16, + nunc: __small$_17, + pharetra: __small$_18, + lacus: __small$_19, + pulvinar: __small$_20, + ac: __small$_21, + at: __small$_8, + aenean: __small$_22, + odio: __small$_23, + ac: __small$_21, + erat: __small$_24, + nam: __small$_25, + justo: __small$_15, + aliquet: __small$_26, + scelerisque: __small$_6, + metus: __small$_27, + volutpat: __small$_28, + ac: __small$_21, + venenatis: __small$_29 +}; +return exports; +})(); +var __small$_86 = (function() { +var exports = {}; +exports.ipsum = __small$_45; +exports.sit = __small$_37; +exports.nullam = __small$_50; +exports.odio = __small$_23; +exports.tortor = __small$_64; +exports.ac = __small$_21; +exports.nullam = __small$_50; +exports.pellentesque = __small$_40; +exports.cursus = __small$_65; +exports.cras = __small$_66; +exports.semper = __small$_67; +exports.malesuada = __small$_68; +exports.elementum = __small$_69; +exports.pretium = __small$_70; +exports.sodales = __small$_71; +exports.tortor = __small$_64; +exports.risus = __small$_72; +exports.hendrerit = __small$_73; +exports.tristique = __small$_74; +exports.vel = __small$_75; +exports.non = __small$_76; +exports.mattis = __small$_61; +exports.dolor = __small$_53; +exports.nisi = __small$_42; + +return exports; +})(); +exports.amet = (__small$_1 = (function() { +var exports = {}; +exports.lorem = __small$_38; + +return exports; +})()); +exports.consectetur = (__small$_2 = (function() { +var exports = {}; +exports = { + lorem: __small$_38 +}; +return exports; +})()); +exports.adipiscing = (__small$_3 = (function() { +var exports = {}; +exports.lorem = __small$_38; + +return exports; +})()); +exports.lobortis = (__small$_4 = (function() { +var exports = {}; +exports.lorem = __small$_38; + +return exports; +})()); +exports.in = (__small$_5 = (function() { +var exports = {}; +exports.lorem = __small$_38; + +return exports; +})()); +exports.scelerisque = (__small$_6 = (function() { +var exports = {}; +exports.lorem = __small$_38; +exports.mi = __small$_39; +exports.pellentesque = __small$_40; +exports.egestas = __small$_41; +exports.pulvinar = __small$_20; + +return exports; +})()); +exports.vulputate = (__small$_7 = (function() { +var exports = {}; +exports = { + lorem: __small$_38, + mi: __small$_39, + pellentesque: __small$_40, + egestas: __small$_41, + pulvinar: __small$_20, + at: __small$_8, + nisi: __small$_42 +}; +return exports; +})()); +exports.at = (__small$_8 = (function() { +var exports = {}; +exports.amet = __small$_1; +exports.consectetur = __small$_2; +exports.adipiscing = __small$_3; +exports.lobortis = __small$_4; +exports.in = __small$_5; +exports.scelerisque = __small$_6; + +return exports; +})()); +exports.facilisis = (__small$_9 = (function() { +var exports = {}; +exports.lorem = __small$_38; +exports.mi = __small$_39; +exports.pellentesque = __small$_40; +exports.egestas = __small$_41; +exports.pulvinar = __small$_20; +exports.at = __small$_8; +exports.nisi = __small$_42; + +return exports; +})()); +exports.urna = (__small$_10 = (function() { +var exports = {}; +exports = { + lorem: __small$_38, + mi: __small$_39, + pellentesque: __small$_40, + egestas: __small$_41, + pulvinar: __small$_20, + at: __small$_8, + nisi: __small$_42 +}; +return exports; +})()); +exports.donec = (__small$_11 = (function() { +var exports = {}; +exports.lorem = __small$_38; +exports.mi = __small$_39; +exports.pellentesque = __small$_40; +exports.egestas = __small$_41; +exports.pulvinar = __small$_20; +exports.at = __small$_8; +exports.nisi = __small$_42; +exports.nec = __small$_43; + +return exports; +})()); +exports.morbi = (__small$_12 = (function() { +var exports = {}; +exports.lorem = __small$_38; +exports.mi = __small$_39; +exports.pellentesque = __small$_40; +exports.egestas = __small$_41; +exports.pulvinar = __small$_20; +exports.at = __small$_8; +exports.nisi = __small$_42; +exports.nec = __small$_43; +exports.diam = __small$_44; +exports.sit = __small$_37; +exports.ipsum = __small$_45; + +return exports; +})()); +exports.eleifend = (__small$_13 = (function() { +var exports = {}; +exports.lorem = __small$_38; +exports.mi = __small$_39; +exports.pellentesque = __small$_40; +exports.egestas = __small$_41; +exports.pulvinar = __small$_20; +exports.at = __small$_8; +exports.nisi = __small$_42; +exports.nec = __small$_43; +exports.diam = __small$_44; +exports.sit = __small$_37; +exports.ipsum = __small$_45; +exports.porta = __small$_46; +exports.suscipit = __small$_47; +exports.et = __small$_48; + +return exports; +})()); +exports.quisque = (__small$_14 = (function() { +var exports = {}; +exports.lorem = __small$_38; +exports.mi = __small$_39; +exports.pellentesque = __small$_40; +exports.egestas = __small$_41; +exports.pulvinar = __small$_20; +exports.at = __small$_8; +exports.nisi = __small$_42; +exports.nec = __small$_43; +exports.diam = __small$_44; +exports.sit = __small$_37; +exports.ipsum = __small$_45; +exports.porta = __small$_46; +exports.suscipit = __small$_47; +exports.et = __small$_48; + +return exports; +})()); +exports.justo = (__small$_15 = (function() { +var exports = {}; +exports.lorem = __small$_38; +exports.mi = __small$_39; +exports.pellentesque = __small$_40; +exports.egestas = __small$_41; +exports.pulvinar = __small$_20; +exports.at = __small$_8; +exports.nisi = __small$_42; +exports.nec = __small$_43; +exports.diam = __small$_44; +exports.sit = __small$_37; +exports.ipsum = __small$_45; +exports.porta = __small$_46; +exports.suscipit = __small$_47; +exports.et = __small$_48; +exports.viverra = __small$_49; + +return exports; +})()); +exports.vehicula = (__small$_16 = (function() { +var exports = {}; +exports = { + lorem: __small$_38, + mi: __small$_39, + pellentesque: __small$_40, + egestas: __small$_41, + pulvinar: __small$_20, + at: __small$_8, + nisi: __small$_42, + nec: __small$_43, + diam: __small$_44, + sit: __small$_37, + ipsum: __small$_45, + porta: __small$_46, + suscipit: __small$_47, + et: __small$_48, + viverra: __small$_49 +}; +return exports; +})()); +exports.nunc = (__small$_17 = (function() { +var exports = {}; +exports = { + ipsum: __small$_45, + sit: __small$_37, + nullam: __small$_50, + odio: __small$_23 +}; +return exports; +})()); +exports.pharetra = (__small$_18 = (function() { +var exports = {}; +exports.lorem = __small$_38; +exports.mi = __small$_39; +exports.pellentesque = __small$_40; +exports.egestas = __small$_41; +exports.pulvinar = __small$_20; +exports.at = __small$_8; +exports.nisi = __small$_42; +exports.nec = __small$_43; +exports.diam = __small$_44; +exports.sit = __small$_37; +exports.ipsum = __small$_45; +exports.porta = __small$_46; +exports.suscipit = __small$_47; +exports.et = __small$_48; +exports.viverra = __small$_49; +exports.ultrices = __small$_51; +exports.at = __small$_8; + +return exports; +})()); +exports.lacus = (__small$_19 = (function() { +var exports = {}; +exports.lorem = __small$_38; +exports.mi = __small$_39; +exports.pellentesque = __small$_40; +exports.egestas = __small$_41; +exports.pulvinar = __small$_20; +exports.at = __small$_8; +exports.nisi = __small$_42; +exports.nec = __small$_43; +exports.diam = __small$_44; +exports.sit = __small$_37; +exports.ipsum = __small$_45; +exports.porta = __small$_46; +exports.suscipit = __small$_47; +exports.et = __small$_48; +exports.viverra = __small$_49; +exports.ultrices = __small$_51; +exports.at = __small$_8; +exports.vehicula = __small$_16; +exports.dui = __small$_52; + +return exports; +})()); +exports.pulvinar = (__small$_20 = (function() { +var exports = {}; +exports = { + amet: __small$_1, + consectetur: __small$_2, + adipiscing: __small$_3, + lobortis: __small$_4, + in: __small$_5 +}; +return exports; +})()); +exports.ac = (__small$_21 = (function() { +var exports = {}; +exports = { + dolor: __small$_53, + elit: __small$_54, + rutrum: __small$_55, + interdum: __small$_56, + mollis: __small$_57, + etiam: __small$_58, + nunc: __small$_17, + ornare: __small$_59 +}; +return exports; +})()); +exports.at = __small$_8; +exports.aenean = (__small$_22 = (function() { +var exports = {}; +exports.lorem = __small$_38; +exports.mi = __small$_39; +exports.pellentesque = __small$_40; +exports.egestas = __small$_41; +exports.pulvinar = __small$_20; +exports.at = __small$_8; +exports.nisi = __small$_42; +exports.nec = __small$_43; +exports.diam = __small$_44; +exports.sit = __small$_37; +exports.ipsum = __small$_45; +exports.porta = __small$_46; +exports.suscipit = __small$_47; +exports.et = __small$_48; +exports.viverra = __small$_49; +exports.ultrices = __small$_51; +exports.at = __small$_8; +exports.vehicula = __small$_16; +exports.dui = __small$_52; +exports.nibh = __small$_60; +exports.mattis = __small$_61; +exports.imperdiet = __small$_62; + +return exports; +})()); +exports.odio = (__small$_23 = (function() { +var exports = {}; +exports = { + dolor: __small$_53, + elit: __small$_54, + rutrum: __small$_55 +}; +return exports; +})()); +exports.ac = __small$_21; +exports.erat = (__small$_24 = (function() { +var exports = {}; +exports.lorem = __small$_38; +exports.mi = __small$_39; +exports.pellentesque = __small$_40; +exports.egestas = __small$_41; +exports.pulvinar = __small$_20; +exports.at = __small$_8; +exports.nisi = __small$_42; +exports.nec = __small$_43; +exports.diam = __small$_44; +exports.sit = __small$_37; +exports.ipsum = __small$_45; +exports.porta = __small$_46; +exports.suscipit = __small$_47; +exports.et = __small$_48; +exports.viverra = __small$_49; +exports.ultrices = __small$_51; +exports.at = __small$_8; +exports.vehicula = __small$_16; +exports.dui = __small$_52; +exports.nibh = __small$_60; +exports.mattis = __small$_61; +exports.imperdiet = __small$_62; +exports.integer = __small$_63; +exports.varius = __small$_36; + +return exports; +})()); +exports.nam = (__small$_25 = (function() { +var exports = {}; +exports.lorem = __small$_38; +exports.mi = __small$_39; +exports.pellentesque = __small$_40; +exports.egestas = __small$_41; +exports.pulvinar = __small$_20; +exports.at = __small$_8; +exports.nisi = __small$_42; +exports.nec = __small$_43; +exports.diam = __small$_44; +exports.sit = __small$_37; +exports.ipsum = __small$_45; +exports.porta = __small$_46; +exports.suscipit = __small$_47; +exports.et = __small$_48; +exports.viverra = __small$_49; +exports.ultrices = __small$_51; +exports.at = __small$_8; +exports.vehicula = __small$_16; +exports.dui = __small$_52; +exports.nibh = __small$_60; +exports.mattis = __small$_61; +exports.imperdiet = __small$_62; +exports.integer = __small$_63; +exports.varius = __small$_36; + +return exports; +})()); +exports.justo = __small$_15; +exports.aliquet = (__small$_26 = (function() { +var exports = {}; +exports.ipsum = __small$_45; +exports.sit = __small$_37; +exports.nullam = __small$_50; +exports.odio = __small$_23; +exports.tortor = __small$_64; +exports.ac = __small$_21; +exports.nullam = __small$_50; + +return exports; +})()); +exports.scelerisque = __small$_6; +exports.metus = (__small$_27 = (function() { +var exports = {}; +exports.ipsum = __small$_45; +exports.sit = __small$_37; +exports.nullam = __small$_50; +exports.odio = __small$_23; +exports.tortor = __small$_64; +exports.ac = __small$_21; +exports.nullam = __small$_50; +exports.pellentesque = __small$_40; +exports.cursus = __small$_65; +exports.cras = __small$_66; +exports.semper = __small$_67; +exports.malesuada = __small$_68; +exports.elementum = __small$_69; +exports.pretium = __small$_70; +exports.sodales = __small$_71; +exports.tortor = __small$_64; +exports.risus = __small$_72; +exports.hendrerit = __small$_73; +exports.tristique = __small$_74; +exports.vel = __small$_75; +exports.non = __small$_76; +exports.mattis = __small$_61; +exports.dolor = __small$_53; +exports.nisi = __small$_42; + +return exports; +})()); +exports.volutpat = (__small$_28 = (function() { +var exports = {}; +exports.lorem = __small$_38; +exports.mi = __small$_39; +exports.pellentesque = __small$_40; +exports.egestas = __small$_41; +exports.pulvinar = __small$_20; +exports.at = __small$_8; +exports.nisi = __small$_42; +exports.nec = __small$_43; +exports.diam = __small$_44; +exports.sit = __small$_37; +exports.ipsum = __small$_45; +exports.porta = __small$_46; +exports.suscipit = __small$_47; +exports.et = __small$_48; +exports.viverra = __small$_49; +exports.ultrices = __small$_51; +exports.at = __small$_8; +exports.vehicula = __small$_16; +exports.dui = __small$_52; +exports.nibh = __small$_60; +exports.mattis = __small$_61; +exports.imperdiet = __small$_62; +exports.integer = __small$_63; +exports.varius = __small$_36; +exports.in = __small$_5; + +return exports; +})()); +exports.ac = __small$_21; +exports.venenatis = (__small$_29 = (function() { +var exports = {}; +exports.lorem = __small$_38; +exports.mi = __small$_39; +exports.pellentesque = __small$_40; +exports.egestas = __small$_41; +exports.pulvinar = __small$_20; +exports.at = __small$_8; +exports.nisi = __small$_42; +exports.nec = __small$_43; +exports.diam = __small$_44; +exports.sit = __small$_37; +exports.ipsum = __small$_45; +exports.porta = __small$_46; +exports.suscipit = __small$_47; +exports.et = __small$_48; +exports.viverra = __small$_49; +exports.ultrices = __small$_51; +exports.at = __small$_8; +exports.vehicula = __small$_16; +exports.dui = __small$_52; +exports.nibh = __small$_60; +exports.mattis = __small$_61; +exports.imperdiet = __small$_62; +exports.integer = __small$_63; +exports.varius = __small$_36; +exports.in = __small$_5; +exports.auctor = __small$_77; +exports.urna = __small$_10; + +return exports; +})()); +exports.justo = __small$_15; +exports.quam = (__small$_30 = (function() { +var exports = {}; +exports.lorem = __small$_38; +exports.mi = __small$_39; +exports.pellentesque = __small$_40; +exports.egestas = __small$_41; +exports.pulvinar = __small$_20; +exports.at = __small$_8; +exports.nisi = __small$_42; +exports.nec = __small$_43; +exports.diam = __small$_44; +exports.sit = __small$_37; +exports.ipsum = __small$_45; +exports.porta = __small$_46; +exports.suscipit = __small$_47; +exports.et = __small$_48; +exports.viverra = __small$_49; +exports.ultrices = __small$_51; +exports.at = __small$_8; +exports.vehicula = __small$_16; +exports.dui = __small$_52; +exports.nibh = __small$_60; +exports.mattis = __small$_61; +exports.imperdiet = __small$_62; +exports.integer = __small$_63; +exports.varius = __small$_36; +exports.in = __small$_5; +exports.auctor = __small$_77; +exports.urna = __small$_10; +exports.auctor = __small$_77; +exports.ante = __small$_78; +exports.sed = __small$_35; + +return exports; +})()); +exports.quis = (__small$_31 = (function() { +var exports = {}; +exports = { + dolor: __small$_53, + elit: __small$_54, + rutrum: __small$_55, + interdum: __small$_56, + mollis: __small$_57, + etiam: __small$_58, + nunc: __small$_17, + ornare: __small$_59, + eros: __small$_79, + nulla: __small$_80, + pulvinar: __small$_20, + aliquet: __small$_26, + ligula: __small$_81, + ullamcorper: __small$_82, + amet: __small$_1, + vulputate: __small$_7, + lorem: __small$_38, + libero: __small$_83, + tincidunt: __small$_84, + felis: __small$_85, + nisi: __small$_42, + sed: __small$_35, + felis: __small$_85, + ligula: __small$_81, + vulputate: __small$_7, + nam: __small$_25, + viverra: __small$_49, + metus: __small$_27, + tellus: __small$_86 +}; +return exports; +})()); +exports.augue = (__small$_32 = (function() { +var exports = {}; +exports = { + lorem: __small$_38, + mi: __small$_39, + pellentesque: __small$_40, + egestas: __small$_41, + pulvinar: __small$_20, + at: __small$_8, + nisi: __small$_42, + nec: __small$_43, + diam: __small$_44, + sit: __small$_37, + ipsum: __small$_45, + porta: __small$_46, + suscipit: __small$_47, + et: __small$_48, + viverra: __small$_49, + ultrices: __small$_51, + at: __small$_8, + vehicula: __small$_16, + dui: __small$_52, + nibh: __small$_60, + mattis: __small$_61, + imperdiet: __small$_62, + integer: __small$_63, + varius: __small$_36, + in: __small$_5, + auctor: __small$_77, + urna: __small$_10, + auctor: __small$_77, + ante: __small$_78, + sed: __small$_35, + sed: __small$_35 +}; +return exports; +})()); +exports.euismod = (__small$_33 = (function() { +var exports = {}; +exports.lorem = __small$_38; +exports.mi = __small$_39; +exports.pellentesque = __small$_40; +exports.egestas = __small$_41; +exports.pulvinar = __small$_20; +exports.at = __small$_8; +exports.nisi = __small$_42; +exports.nec = __small$_43; +exports.diam = __small$_44; +exports.sit = __small$_37; +exports.ipsum = __small$_45; +exports.porta = __small$_46; +exports.suscipit = __small$_47; +exports.et = __small$_48; +exports.viverra = __small$_49; +exports.ultrices = __small$_51; +exports.at = __small$_8; +exports.vehicula = __small$_16; +exports.dui = __small$_52; +exports.nibh = __small$_60; +exports.mattis = __small$_61; +exports.imperdiet = __small$_62; +exports.integer = __small$_63; +exports.varius = __small$_36; +exports.in = __small$_5; +exports.auctor = __small$_77; +exports.urna = __small$_10; +exports.auctor = __small$_77; +exports.ante = __small$_78; +exports.sed = __small$_35; +exports.sed = __small$_35; + +return exports; +})()); +exports.nunc = __small$_17; +exports.molestie = ((function() { +var exports = {}; +var __small$_93 = (function() { +var exports = {}; +exports.ipsum = __small$_45; +exports.sit = __small$_37; +exports.nullam = __small$_50; +exports.odio = __small$_23; +exports.tortor = __small$_64; +exports.ac = __small$_21; +exports.nullam = __small$_50; +exports.pellentesque = __small$_40; +exports.cursus = __small$_65; +exports.cras = __small$_66; +exports.semper = __small$_67; +exports.malesuada = __small$_68; +exports.elementum = __small$_69; +exports.pretium = __small$_70; +exports.sodales = __small$_71; +exports.tortor = __small$_64; +exports.risus = __small$_72; +exports.hendrerit = __small$_73; +exports.tristique = __small$_74; +exports.vel = __small$_75; +exports.non = __small$_76; +exports.mattis = __small$_61; +exports.dolor = __small$_53; +exports.nisi = __small$_42; +exports.quis = __small$_31; +exports.mi = __small$_39; + +return exports; +})(); +var __small$_91 = (function() { +var exports = {}; +exports.dolor = __small$_53; +exports.elit = __small$_54; +exports.rutrum = __small$_55; +exports.interdum = __small$_56; +exports.mollis = __small$_57; +exports.etiam = __small$_58; +exports.nunc = __small$_17; +exports.ornare = __small$_59; +exports.eros = __small$_79; +exports.nulla = __small$_80; +exports.pulvinar = __small$_20; +exports.aliquet = __small$_26; +exports.ligula = __small$_81; +exports.ullamcorper = __small$_82; +exports.amet = __small$_1; +exports.vulputate = __small$_7; +exports.lorem = __small$_38; +exports.libero = __small$_83; +exports.tincidunt = __small$_84; +exports.felis = __small$_85; +exports.nisi = __small$_42; +exports.sed = __small$_35; +exports.felis = __small$_85; +exports.ligula = __small$_81; +exports.vulputate = __small$_7; +exports.nam = __small$_25; +exports.viverra = __small$_49; +exports.metus = __small$_27; +exports.tellus = __small$_86; +exports.lectus = __small$_93; +exports.urna = __small$_10; + +return exports; +})(); +var __small$_94 = (function() { +var exports = {}; +exports.ipsum = __small$_45; +exports.sit = __small$_37; +exports.nullam = __small$_50; +exports.odio = __small$_23; +exports.tortor = __small$_64; +exports.ac = __small$_21; +exports.nullam = __small$_50; +exports.pellentesque = __small$_40; +exports.cursus = __small$_65; +exports.cras = __small$_66; +exports.semper = __small$_67; +exports.malesuada = __small$_68; +exports.elementum = __small$_69; +exports.pretium = __small$_70; +exports.sodales = __small$_71; +exports.tortor = __small$_64; +exports.risus = __small$_72; +exports.hendrerit = __small$_73; +exports.tristique = __small$_74; +exports.vel = __small$_75; +exports.non = __small$_76; +exports.mattis = __small$_61; +exports.dolor = __small$_53; +exports.nisi = __small$_42; +exports.quis = __small$_31; +exports.mi = __small$_39; +exports.mauris = __small$_91; + +return exports; +})(); +var __small$_95 = (function() { +var exports = {}; +exports.ipsum = __small$_45; +exports.sit = __small$_37; +exports.nullam = __small$_50; +exports.odio = __small$_23; +exports.tortor = __small$_64; +exports.ac = __small$_21; +exports.nullam = __small$_50; +exports.pellentesque = __small$_40; +exports.cursus = __small$_65; +exports.cras = __small$_66; +exports.semper = __small$_67; +exports.malesuada = __small$_68; +exports.elementum = __small$_69; +exports.pretium = __small$_70; +exports.sodales = __small$_71; +exports.tortor = __small$_64; +exports.risus = __small$_72; +exports.hendrerit = __small$_73; +exports.tristique = __small$_74; +exports.vel = __small$_75; +exports.non = __small$_76; +exports.mattis = __small$_61; +exports.dolor = __small$_53; +exports.nisi = __small$_42; +exports.quis = __small$_31; +exports.mi = __small$_39; +exports.mauris = __small$_91; +exports.in = __small$_5; + +return exports; +})(); +var __small$_96 = (function() { +var exports = {}; +exports.ipsum = __small$_45; +exports.sit = __small$_37; +exports.nullam = __small$_50; +exports.odio = __small$_23; +exports.tortor = __small$_64; +exports.ac = __small$_21; +exports.nullam = __small$_50; +exports.pellentesque = __small$_40; +exports.cursus = __small$_65; +exports.cras = __small$_66; +exports.semper = __small$_67; +exports.malesuada = __small$_68; +exports.elementum = __small$_69; +exports.pretium = __small$_70; +exports.sodales = __small$_71; +exports.tortor = __small$_64; +exports.risus = __small$_72; +exports.hendrerit = __small$_73; +exports.tristique = __small$_74; +exports.vel = __small$_75; +exports.non = __small$_76; +exports.mattis = __small$_61; +exports.dolor = __small$_53; +exports.nisi = __small$_42; +exports.quis = __small$_31; +exports.mi = __small$_39; +exports.mauris = __small$_91; +exports.in = __small$_5; + +return exports; +})(); +exports.lorem = __small$_38; +exports.mi = __small$_39; +exports.pellentesque = __small$_40; +exports.egestas = __small$_41; +exports.pulvinar = __small$_20; +exports.at = __small$_8; +exports.nisi = __small$_42; +exports.nec = __small$_43; +exports.diam = __small$_44; +exports.sit = __small$_37; +exports.ipsum = __small$_45; +exports.porta = __small$_46; +exports.suscipit = __small$_47; +exports.et = __small$_48; +exports.viverra = __small$_49; +exports.ultrices = __small$_51; +exports.at = __small$_8; +exports.vehicula = __small$_16; +exports.dui = __small$_52; +exports.nibh = __small$_60; +exports.mattis = __small$_61; +exports.imperdiet = __small$_62; +exports.integer = __small$_63; +exports.varius = __small$_36; +exports.in = __small$_5; +exports.auctor = __small$_77; +exports.urna = __small$_10; +exports.auctor = __small$_77; +exports.ante = __small$_78; +exports.sed = __small$_35; +exports.sed = __small$_35; +exports.aliquam = ((function() { +var exports = {}; +exports.amet = __small$_1; +exports.consectetur = __small$_2; +exports.adipiscing = __small$_3; +exports.lobortis = __small$_4; +exports.in = __small$_5; +exports.scelerisque = __small$_6; +exports.vulputate = __small$_7; +exports.at = __small$_8; +exports.facilisis = __small$_9; +exports.urna = __small$_10; +exports.donec = __small$_11; +exports.morbi = __small$_12; +exports.eleifend = __small$_13; +exports.quisque = __small$_14; +exports.justo = __small$_15; +exports.vehicula = __small$_16; +exports.nunc = __small$_17; +exports.pharetra = __small$_18; +exports.lacus = __small$_19; +exports.pulvinar = __small$_20; +exports.ac = __small$_21; +exports.at = __small$_8; +exports.aenean = __small$_22; +exports.odio = __small$_23; +exports.ac = __small$_21; +exports.erat = __small$_24; +exports.nam = __small$_25; +exports.justo = __small$_15; +exports.aliquet = __small$_26; +exports.scelerisque = __small$_6; +exports.metus = __small$_27; +exports.volutpat = __small$_28; +exports.ac = __small$_21; +exports.venenatis = __small$_29; +exports.justo = __small$_15; +exports.quam = __small$_30; +exports.quis = __small$_31; +exports.augue = __small$_32; +exports.euismod = __small$_33; + +return exports; +})()); +exports.lacus = __small$_19; +exports.tempor = ((function() { +var exports = {}; +exports.amet = __small$_1; +exports.consectetur = __small$_2; +exports.adipiscing = __small$_3; +exports.lobortis = __small$_4; +exports.in = __small$_5; +exports.scelerisque = __small$_6; +exports.vulputate = __small$_7; +exports.at = __small$_8; +exports.facilisis = __small$_9; +exports.urna = __small$_10; +exports.donec = __small$_11; +exports.morbi = __small$_12; +exports.eleifend = __small$_13; +exports.quisque = __small$_14; +exports.justo = __small$_15; +exports.vehicula = __small$_16; +exports.nunc = __small$_17; +exports.pharetra = __small$_18; +exports.lacus = __small$_19; +exports.pulvinar = __small$_20; +exports.ac = __small$_21; +exports.at = __small$_8; +exports.aenean = __small$_22; +exports.odio = __small$_23; +exports.ac = __small$_21; +exports.erat = __small$_24; +exports.nam = __small$_25; +exports.justo = __small$_15; +exports.aliquet = __small$_26; +exports.scelerisque = __small$_6; +exports.metus = __small$_27; +exports.volutpat = __small$_28; +exports.ac = __small$_21; +exports.venenatis = __small$_29; +exports.justo = __small$_15; +exports.quam = __small$_30; +exports.quis = __small$_31; +exports.augue = __small$_32; +exports.euismod = __small$_33; + +return exports; +})()); +exports.interdum = __small$_56; +exports.id = ((function() { +var exports = {}; +exports = { + ipsum: __small$_45, + sit: __small$_37, + nullam: __small$_50, + odio: __small$_23, + tortor: __small$_64, + ac: __small$_21, + nullam: __small$_50, + pellentesque: __small$_40, + cursus: __small$_65, + cras: __small$_66, + semper: __small$_67, + malesuada: __small$_68, + elementum: __small$_69, + pretium: __small$_70, + sodales: __small$_71, + tortor: __small$_64, + risus: __small$_72, + hendrerit: __small$_73, + tristique: __small$_74, + vel: __small$_75, + non: __small$_76, + mattis: __small$_61, + dolor: __small$_53, + nisi: __small$_42, + quis: __small$_31, + mi: __small$_39, + mauris: __small$_91, + in: __small$_5, + porttitor: __small$_90, + commodo: ((function() { +var exports = {}; +exports.dolor = __small$_53; +exports.elit = __small$_54; +exports.rutrum = __small$_55; +exports.interdum = __small$_56; +exports.mollis = __small$_57; +exports.etiam = __small$_58; +exports.nunc = __small$_17; +exports.ornare = __small$_59; +exports.eros = __small$_79; +exports.nulla = __small$_80; +exports.pulvinar = __small$_20; +exports.aliquet = __small$_26; +exports.ligula = __small$_81; +exports.ullamcorper = __small$_82; +exports.amet = __small$_1; +exports.vulputate = __small$_7; +exports.lorem = __small$_38; +exports.libero = __small$_83; +exports.tincidunt = __small$_84; +exports.felis = __small$_85; +exports.nisi = __small$_42; +exports.sed = __small$_35; +exports.felis = __small$_85; +exports.ligula = __small$_81; +exports.vulputate = __small$_7; +exports.nam = __small$_25; +exports.viverra = __small$_49; +exports.metus = __small$_27; +exports.tellus = __small$_86; +exports.lectus = __small$_93; +exports.urna = __small$_10; +exports.neque = __small$_94; +exports.mauris = __small$_91; +exports.a = __small$_95; +exports.posuere = __small$_96; + +return exports; +})()), + vel: __small$_75, + porta: __small$_46, + vel: __small$_75 +}; +return exports; +})()); +exports.porttitor = (__small$_90 = (function() { +var exports = {}; +exports.dolor = __small$_53; +exports.elit = __small$_54; +exports.rutrum = __small$_55; +exports.interdum = __small$_56; +exports.mollis = __small$_57; +exports.etiam = __small$_58; +exports.nunc = __small$_17; +exports.ornare = __small$_59; +exports.eros = __small$_79; +exports.nulla = __small$_80; +exports.pulvinar = __small$_20; +exports.aliquet = __small$_26; +exports.ligula = __small$_81; +exports.ullamcorper = __small$_82; +exports.amet = __small$_1; +exports.vulputate = __small$_7; +exports.lorem = __small$_38; +exports.libero = __small$_83; +exports.tincidunt = __small$_84; +exports.felis = __small$_85; +exports.nisi = __small$_42; +exports.sed = __small$_35; +exports.felis = __small$_85; +exports.ligula = __small$_81; +exports.vulputate = __small$_7; +exports.nam = __small$_25; +exports.viverra = __small$_49; +exports.metus = __small$_27; +exports.tellus = __small$_86; +exports.lectus = __small$_93; +exports.urna = __small$_10; +exports.neque = __small$_94; +exports.mauris = __small$_91; +exports.a = __small$_95; +exports.posuere = __small$_96; + +return exports; +})()); +exports.eros = __small$_79; + +return exports; +})()); +exports.sed = (__small$_35 = (function() { +var exports = {}; +exports = { + ipsum: __small$_45, + sit: __small$_37, + nullam: __small$_50, + odio: __small$_23, + tortor: __small$_64, + ac: __small$_21, + nullam: __small$_50, + pellentesque: __small$_40, + cursus: __small$_65, + cras: __small$_66, + semper: __small$_67, + malesuada: __small$_68, + elementum: __small$_69, + pretium: __small$_70, + sodales: __small$_71, + tortor: __small$_64, + risus: __small$_72 +}; +return exports; +})()); +exports.varius = (__small$_36 = (function() { +var exports = {}; +exports = { + amet: __small$_1, + consectetur: __small$_2, + adipiscing: __small$_3, + lobortis: __small$_4, + in: __small$_5, + scelerisque: __small$_6, + vulputate: __small$_7, + at: __small$_8, + facilisis: __small$_9, + urna: __small$_10, + donec: __small$_11, + morbi: __small$_12, + eleifend: __small$_13, + quisque: __small$_14, + justo: __small$_15, + vehicula: __small$_16, + nunc: __small$_17, + pharetra: __small$_18, + lacus: __small$_19, + pulvinar: __small$_20, + ac: __small$_21, + at: __small$_8, + aenean: __small$_22, + odio: __small$_23, + ac: __small$_21 +}; +return exports; +})()); +exports.sit = (__small$_37 = (function() { +var exports = {}; +exports.dolor = __small$_53; + +return exports; +})()); + +return exports; +})(); diff --git a/examples/big/output.standalone.js b/examples/big/output.standalone.js new file mode 100644 index 0000000..98bd50a --- /dev/null +++ b/examples/big/output.standalone.js @@ -0,0 +1,1984 @@ +(function() { +var exports = {}; +var __small$_38 = (function() { +var exports = {}; +exports = { + +}; +return exports; +})(); +var __small$_39 = (function() { +var exports = {}; +exports.amet = __small$_1; +exports.consectetur = __small$_2; +exports.adipiscing = __small$_3; +exports.lobortis = __small$_4; +exports.in = __small$_5; + +return exports; +})(); +var __small$_40 = (function() { +var exports = {}; +exports.amet = __small$_1; +exports.consectetur = __small$_2; +exports.adipiscing = __small$_3; +exports.lobortis = __small$_4; +exports.in = __small$_5; + +return exports; +})(); +var __small$_41 = (function() { +var exports = {}; +exports.amet = __small$_1; +exports.consectetur = __small$_2; +exports.adipiscing = __small$_3; +exports.lobortis = __small$_4; +exports.in = __small$_5; + +return exports; +})(); +var __small$_42 = (function() { +var exports = {}; +exports.amet = __small$_1; +exports.consectetur = __small$_2; +exports.adipiscing = __small$_3; +exports.lobortis = __small$_4; +exports.in = __small$_5; +exports.scelerisque = __small$_6; + +return exports; +})(); +var __small$_43 = (function() { +var exports = {}; +exports.amet = __small$_1; +exports.consectetur = __small$_2; +exports.adipiscing = __small$_3; +exports.lobortis = __small$_4; +exports.in = __small$_5; +exports.scelerisque = __small$_6; +exports.vulputate = __small$_7; +exports.at = __small$_8; +exports.facilisis = __small$_9; +exports.urna = __small$_10; + +return exports; +})(); +var __small$_44 = (function() { +var exports = {}; +exports = { + amet: __small$_1, + consectetur: __small$_2, + adipiscing: __small$_3, + lobortis: __small$_4, + in: __small$_5, + scelerisque: __small$_6, + vulputate: __small$_7, + at: __small$_8, + facilisis: __small$_9, + urna: __small$_10, + donec: __small$_11 +}; +return exports; +})(); +var __small$_45 = (function() { +var exports = {}; + +return exports; +})(); +var __small$_53 = (function() { +var exports = {}; +exports.ipsum = __small$_45; + +return exports; +})(); +var __small$_46 = (function() { +var exports = {}; +exports.amet = __small$_1; +exports.consectetur = __small$_2; +exports.adipiscing = __small$_3; +exports.lobortis = __small$_4; +exports.in = __small$_5; +exports.scelerisque = __small$_6; +exports.vulputate = __small$_7; +exports.at = __small$_8; +exports.facilisis = __small$_9; +exports.urna = __small$_10; +exports.donec = __small$_11; +exports.morbi = __small$_12; + +return exports; +})(); +var __small$_47 = (function() { +var exports = {}; +exports.amet = __small$_1; +exports.consectetur = __small$_2; +exports.adipiscing = __small$_3; +exports.lobortis = __small$_4; +exports.in = __small$_5; +exports.scelerisque = __small$_6; +exports.vulputate = __small$_7; +exports.at = __small$_8; +exports.facilisis = __small$_9; +exports.urna = __small$_10; +exports.donec = __small$_11; +exports.morbi = __small$_12; + +return exports; +})(); +var __small$_48 = (function() { +var exports = {}; +exports = { + amet: __small$_1, + consectetur: __small$_2, + adipiscing: __small$_3, + lobortis: __small$_4, + in: __small$_5, + scelerisque: __small$_6, + vulputate: __small$_7, + at: __small$_8, + facilisis: __small$_9, + urna: __small$_10, + donec: __small$_11, + morbi: __small$_12 +}; +return exports; +})(); +var __small$_49 = (function() { +var exports = {}; +exports.amet = __small$_1; +exports.consectetur = __small$_2; +exports.adipiscing = __small$_3; +exports.lobortis = __small$_4; +exports.in = __small$_5; +exports.scelerisque = __small$_6; +exports.vulputate = __small$_7; +exports.at = __small$_8; +exports.facilisis = __small$_9; +exports.urna = __small$_10; +exports.donec = __small$_11; +exports.morbi = __small$_12; +exports.eleifend = __small$_13; +exports.quisque = __small$_14; + +return exports; +})(); +var __small$_54 = (function() { +var exports = {}; +exports.ipsum = __small$_45; +exports.sit = __small$_37; + +return exports; +})(); +var __small$_50 = (function() { +var exports = {}; +exports.dolor = __small$_53; +exports.elit = __small$_54; + +return exports; +})(); +var __small$_55 = (function() { +var exports = {}; +exports.ipsum = __small$_45; +exports.sit = __small$_37; +exports.nullam = __small$_50; + +return exports; +})(); +var __small$_51 = (function() { +var exports = {}; +exports = { + amet: __small$_1, + consectetur: __small$_2, + adipiscing: __small$_3, + lobortis: __small$_4, + in: __small$_5, + scelerisque: __small$_6, + vulputate: __small$_7, + at: __small$_8, + facilisis: __small$_9, + urna: __small$_10, + donec: __small$_11, + morbi: __small$_12, + eleifend: __small$_13, + quisque: __small$_14, + justo: __small$_15, + vehicula: __small$_16, + nunc: __small$_17 +}; +return exports; +})(); +var __small$_52 = (function() { +var exports = {}; +exports = { + amet: __small$_1, + consectetur: __small$_2, + adipiscing: __small$_3, + lobortis: __small$_4, + in: __small$_5, + scelerisque: __small$_6, + vulputate: __small$_7, + at: __small$_8, + facilisis: __small$_9, + urna: __small$_10, + donec: __small$_11, + morbi: __small$_12, + eleifend: __small$_13, + quisque: __small$_14, + justo: __small$_15, + vehicula: __small$_16, + nunc: __small$_17, + pharetra: __small$_18 +}; +return exports; +})(); +var __small$_56 = (function() { +var exports = {}; +exports.ipsum = __small$_45; +exports.sit = __small$_37; +exports.nullam = __small$_50; +exports.odio = __small$_23; + +return exports; +})(); +var __small$_57 = (function() { +var exports = {}; +exports.ipsum = __small$_45; +exports.sit = __small$_37; +exports.nullam = __small$_50; +exports.odio = __small$_23; + +return exports; +})(); +var __small$_58 = (function() { +var exports = {}; +exports.ipsum = __small$_45; +exports.sit = __small$_37; +exports.nullam = __small$_50; +exports.odio = __small$_23; + +return exports; +})(); +var __small$_60 = (function() { +var exports = {}; +exports.amet = __small$_1; +exports.consectetur = __small$_2; +exports.adipiscing = __small$_3; +exports.lobortis = __small$_4; +exports.in = __small$_5; +exports.scelerisque = __small$_6; +exports.vulputate = __small$_7; +exports.at = __small$_8; +exports.facilisis = __small$_9; +exports.urna = __small$_10; +exports.donec = __small$_11; +exports.morbi = __small$_12; +exports.eleifend = __small$_13; +exports.quisque = __small$_14; +exports.justo = __small$_15; +exports.vehicula = __small$_16; +exports.nunc = __small$_17; +exports.pharetra = __small$_18; +exports.lacus = __small$_19; +exports.pulvinar = __small$_20; + +return exports; +})(); +var __small$_64 = (function() { +var exports = {}; +exports.dolor = __small$_53; +exports.elit = __small$_54; +exports.rutrum = __small$_55; +exports.interdum = __small$_56; +exports.mollis = __small$_57; +exports.etiam = __small$_58; +exports.nunc = __small$_17; + +return exports; +})(); +var __small$_59 = (function() { +var exports = {}; +exports.ipsum = __small$_45; +exports.sit = __small$_37; +exports.nullam = __small$_50; +exports.odio = __small$_23; +exports.tortor = __small$_64; + +return exports; +})(); +var __small$_61 = (function() { +var exports = {}; +exports.amet = __small$_1; +exports.consectetur = __small$_2; +exports.adipiscing = __small$_3; +exports.lobortis = __small$_4; +exports.in = __small$_5; +exports.scelerisque = __small$_6; +exports.vulputate = __small$_7; +exports.at = __small$_8; +exports.facilisis = __small$_9; +exports.urna = __small$_10; +exports.donec = __small$_11; +exports.morbi = __small$_12; +exports.eleifend = __small$_13; +exports.quisque = __small$_14; +exports.justo = __small$_15; +exports.vehicula = __small$_16; +exports.nunc = __small$_17; +exports.pharetra = __small$_18; +exports.lacus = __small$_19; +exports.pulvinar = __small$_20; +exports.ac = __small$_21; +exports.at = __small$_8; + +return exports; +})(); +var __small$_62 = (function() { +var exports = {}; +exports.amet = __small$_1; +exports.consectetur = __small$_2; +exports.adipiscing = __small$_3; +exports.lobortis = __small$_4; +exports.in = __small$_5; +exports.scelerisque = __small$_6; +exports.vulputate = __small$_7; +exports.at = __small$_8; +exports.facilisis = __small$_9; +exports.urna = __small$_10; +exports.donec = __small$_11; +exports.morbi = __small$_12; +exports.eleifend = __small$_13; +exports.quisque = __small$_14; +exports.justo = __small$_15; +exports.vehicula = __small$_16; +exports.nunc = __small$_17; +exports.pharetra = __small$_18; +exports.lacus = __small$_19; +exports.pulvinar = __small$_20; +exports.ac = __small$_21; +exports.at = __small$_8; + +return exports; +})(); +var __small$_63 = (function() { +var exports = {}; +exports = { + amet: __small$_1, + consectetur: __small$_2, + adipiscing: __small$_3, + lobortis: __small$_4, + in: __small$_5, + scelerisque: __small$_6, + vulputate: __small$_7, + at: __small$_8, + facilisis: __small$_9, + urna: __small$_10, + donec: __small$_11, + morbi: __small$_12, + eleifend: __small$_13, + quisque: __small$_14, + justo: __small$_15, + vehicula: __small$_16, + nunc: __small$_17, + pharetra: __small$_18, + lacus: __small$_19, + pulvinar: __small$_20, + ac: __small$_21, + at: __small$_8, + aenean: __small$_22, + odio: __small$_23 +}; +return exports; +})(); +var __small$_79 = (function() { +var exports = {}; +exports.ipsum = __small$_45; +exports.sit = __small$_37; +exports.nullam = __small$_50; +exports.odio = __small$_23; +exports.tortor = __small$_64; +exports.ac = __small$_21; + +return exports; +})(); +var __small$_80 = (function() { +var exports = {}; +exports.ipsum = __small$_45; +exports.sit = __small$_37; +exports.nullam = __small$_50; +exports.odio = __small$_23; +exports.tortor = __small$_64; +exports.ac = __small$_21; +exports.nullam = __small$_50; + +return exports; +})(); +var __small$_65 = (function() { +var exports = {}; +exports.dolor = __small$_53; +exports.elit = __small$_54; +exports.rutrum = __small$_55; +exports.interdum = __small$_56; +exports.mollis = __small$_57; +exports.etiam = __small$_58; +exports.nunc = __small$_17; +exports.ornare = __small$_59; +exports.eros = __small$_79; +exports.nulla = __small$_80; +exports.pulvinar = __small$_20; +exports.aliquet = __small$_26; + +return exports; +})(); +var __small$_66 = (function() { +var exports = {}; +exports.dolor = __small$_53; +exports.elit = __small$_54; +exports.rutrum = __small$_55; +exports.interdum = __small$_56; +exports.mollis = __small$_57; +exports.etiam = __small$_58; +exports.nunc = __small$_17; +exports.ornare = __small$_59; +exports.eros = __small$_79; +exports.nulla = __small$_80; +exports.pulvinar = __small$_20; +exports.aliquet = __small$_26; + +return exports; +})(); +var __small$_67 = (function() { +var exports = {}; +exports.dolor = __small$_53; +exports.elit = __small$_54; +exports.rutrum = __small$_55; +exports.interdum = __small$_56; +exports.mollis = __small$_57; +exports.etiam = __small$_58; +exports.nunc = __small$_17; +exports.ornare = __small$_59; +exports.eros = __small$_79; +exports.nulla = __small$_80; +exports.pulvinar = __small$_20; +exports.aliquet = __small$_26; + +return exports; +})(); +var __small$_81 = (function() { +var exports = {}; +exports.ipsum = __small$_45; +exports.sit = __small$_37; +exports.nullam = __small$_50; +exports.odio = __small$_23; +exports.tortor = __small$_64; +exports.ac = __small$_21; +exports.nullam = __small$_50; +exports.pellentesque = __small$_40; +exports.cursus = __small$_65; +exports.cras = __small$_66; +exports.semper = __small$_67; + +return exports; +})(); +var __small$_68 = (function() { +var exports = {}; +exports.dolor = __small$_53; +exports.elit = __small$_54; +exports.rutrum = __small$_55; +exports.interdum = __small$_56; +exports.mollis = __small$_57; +exports.etiam = __small$_58; +exports.nunc = __small$_17; +exports.ornare = __small$_59; +exports.eros = __small$_79; +exports.nulla = __small$_80; +exports.pulvinar = __small$_20; +exports.aliquet = __small$_26; +exports.ligula = __small$_81; + +return exports; +})(); +var __small$_82 = (function() { +var exports = {}; +exports.ipsum = __small$_45; +exports.sit = __small$_37; +exports.nullam = __small$_50; +exports.odio = __small$_23; +exports.tortor = __small$_64; +exports.ac = __small$_21; +exports.nullam = __small$_50; +exports.pellentesque = __small$_40; +exports.cursus = __small$_65; +exports.cras = __small$_66; +exports.semper = __small$_67; +exports.malesuada = __small$_68; + +return exports; +})(); +var __small$_69 = (function() { +var exports = {}; +exports.dolor = __small$_53; +exports.elit = __small$_54; +exports.rutrum = __small$_55; +exports.interdum = __small$_56; +exports.mollis = __small$_57; +exports.etiam = __small$_58; +exports.nunc = __small$_17; +exports.ornare = __small$_59; +exports.eros = __small$_79; +exports.nulla = __small$_80; +exports.pulvinar = __small$_20; +exports.aliquet = __small$_26; +exports.ligula = __small$_81; +exports.ullamcorper = __small$_82; +exports.amet = __small$_1; + +return exports; +})(); +var __small$_83 = (function() { +var exports = {}; +exports.ipsum = __small$_45; +exports.sit = __small$_37; +exports.nullam = __small$_50; +exports.odio = __small$_23; +exports.tortor = __small$_64; +exports.ac = __small$_21; +exports.nullam = __small$_50; +exports.pellentesque = __small$_40; +exports.cursus = __small$_65; +exports.cras = __small$_66; +exports.semper = __small$_67; +exports.malesuada = __small$_68; +exports.elementum = __small$_69; + +return exports; +})(); +var __small$_84 = (function() { +var exports = {}; +exports.ipsum = __small$_45; +exports.sit = __small$_37; +exports.nullam = __small$_50; +exports.odio = __small$_23; +exports.tortor = __small$_64; +exports.ac = __small$_21; +exports.nullam = __small$_50; +exports.pellentesque = __small$_40; +exports.cursus = __small$_65; +exports.cras = __small$_66; +exports.semper = __small$_67; +exports.malesuada = __small$_68; +exports.elementum = __small$_69; + +return exports; +})(); +var __small$_70 = (function() { +var exports = {}; +exports.dolor = __small$_53; +exports.elit = __small$_54; +exports.rutrum = __small$_55; +exports.interdum = __small$_56; +exports.mollis = __small$_57; +exports.etiam = __small$_58; +exports.nunc = __small$_17; +exports.ornare = __small$_59; +exports.eros = __small$_79; +exports.nulla = __small$_80; +exports.pulvinar = __small$_20; +exports.aliquet = __small$_26; +exports.ligula = __small$_81; +exports.ullamcorper = __small$_82; +exports.amet = __small$_1; +exports.vulputate = __small$_7; +exports.lorem = __small$_38; +exports.libero = __small$_83; +exports.tincidunt = __small$_84; + +return exports; +})(); +var __small$_85 = (function() { +var exports = {}; +exports.ipsum = __small$_45; +exports.sit = __small$_37; +exports.nullam = __small$_50; +exports.odio = __small$_23; +exports.tortor = __small$_64; +exports.ac = __small$_21; +exports.nullam = __small$_50; +exports.pellentesque = __small$_40; +exports.cursus = __small$_65; +exports.cras = __small$_66; +exports.semper = __small$_67; +exports.malesuada = __small$_68; +exports.elementum = __small$_69; +exports.pretium = __small$_70; + +return exports; +})(); +var __small$_71 = (function() { +var exports = {}; +exports = { + dolor: __small$_53, + elit: __small$_54, + rutrum: __small$_55, + interdum: __small$_56, + mollis: __small$_57, + etiam: __small$_58, + nunc: __small$_17, + ornare: __small$_59, + eros: __small$_79, + nulla: __small$_80, + pulvinar: __small$_20, + aliquet: __small$_26, + ligula: __small$_81, + ullamcorper: __small$_82, + amet: __small$_1, + vulputate: __small$_7, + lorem: __small$_38, + libero: __small$_83, + tincidunt: __small$_84, + felis: __small$_85 +}; +return exports; +})(); +var __small$_72 = (function() { +var exports = {}; +exports.dolor = __small$_53; +exports.elit = __small$_54; +exports.rutrum = __small$_55; +exports.interdum = __small$_56; +exports.mollis = __small$_57; +exports.etiam = __small$_58; +exports.nunc = __small$_17; +exports.ornare = __small$_59; +exports.eros = __small$_79; +exports.nulla = __small$_80; +exports.pulvinar = __small$_20; +exports.aliquet = __small$_26; +exports.ligula = __small$_81; +exports.ullamcorper = __small$_82; +exports.amet = __small$_1; +exports.vulputate = __small$_7; +exports.lorem = __small$_38; +exports.libero = __small$_83; +exports.tincidunt = __small$_84; +exports.felis = __small$_85; + +return exports; +})(); +var __small$_73 = (function() { +var exports = {}; +exports.dolor = __small$_53; +exports.elit = __small$_54; +exports.rutrum = __small$_55; +exports.interdum = __small$_56; +exports.mollis = __small$_57; +exports.etiam = __small$_58; +exports.nunc = __small$_17; +exports.ornare = __small$_59; +exports.eros = __small$_79; +exports.nulla = __small$_80; +exports.pulvinar = __small$_20; +exports.aliquet = __small$_26; +exports.ligula = __small$_81; +exports.ullamcorper = __small$_82; +exports.amet = __small$_1; +exports.vulputate = __small$_7; +exports.lorem = __small$_38; +exports.libero = __small$_83; +exports.tincidunt = __small$_84; +exports.felis = __small$_85; +exports.nisi = __small$_42; +exports.sed = __small$_35; + +return exports; +})(); +var __small$_74 = (function() { +var exports = {}; +exports = { + dolor: __small$_53, + elit: __small$_54, + rutrum: __small$_55, + interdum: __small$_56, + mollis: __small$_57, + etiam: __small$_58, + nunc: __small$_17, + ornare: __small$_59, + eros: __small$_79, + nulla: __small$_80, + pulvinar: __small$_20, + aliquet: __small$_26, + ligula: __small$_81, + ullamcorper: __small$_82, + amet: __small$_1, + vulputate: __small$_7, + lorem: __small$_38, + libero: __small$_83, + tincidunt: __small$_84, + felis: __small$_85, + nisi: __small$_42, + sed: __small$_35, + felis: __small$_85 +}; +return exports; +})(); +var __small$_75 = (function() { +var exports = {}; +exports.dolor = __small$_53; +exports.elit = __small$_54; +exports.rutrum = __small$_55; +exports.interdum = __small$_56; +exports.mollis = __small$_57; +exports.etiam = __small$_58; +exports.nunc = __small$_17; +exports.ornare = __small$_59; +exports.eros = __small$_79; +exports.nulla = __small$_80; +exports.pulvinar = __small$_20; +exports.aliquet = __small$_26; +exports.ligula = __small$_81; +exports.ullamcorper = __small$_82; +exports.amet = __small$_1; +exports.vulputate = __small$_7; +exports.lorem = __small$_38; +exports.libero = __small$_83; +exports.tincidunt = __small$_84; +exports.felis = __small$_85; +exports.nisi = __small$_42; +exports.sed = __small$_35; +exports.felis = __small$_85; + +return exports; +})(); +var __small$_76 = (function() { +var exports = {}; +exports.dolor = __small$_53; +exports.elit = __small$_54; +exports.rutrum = __small$_55; +exports.interdum = __small$_56; +exports.mollis = __small$_57; +exports.etiam = __small$_58; +exports.nunc = __small$_17; +exports.ornare = __small$_59; +exports.eros = __small$_79; +exports.nulla = __small$_80; +exports.pulvinar = __small$_20; +exports.aliquet = __small$_26; +exports.ligula = __small$_81; +exports.ullamcorper = __small$_82; +exports.amet = __small$_1; +exports.vulputate = __small$_7; +exports.lorem = __small$_38; +exports.libero = __small$_83; +exports.tincidunt = __small$_84; +exports.felis = __small$_85; +exports.nisi = __small$_42; +exports.sed = __small$_35; +exports.felis = __small$_85; +exports.ligula = __small$_81; + +return exports; +})(); +var __small$_77 = (function() { +var exports = {}; +exports.amet = __small$_1; +exports.consectetur = __small$_2; +exports.adipiscing = __small$_3; +exports.lobortis = __small$_4; +exports.in = __small$_5; +exports.scelerisque = __small$_6; +exports.vulputate = __small$_7; +exports.at = __small$_8; +exports.facilisis = __small$_9; +exports.urna = __small$_10; +exports.donec = __small$_11; +exports.morbi = __small$_12; +exports.eleifend = __small$_13; +exports.quisque = __small$_14; +exports.justo = __small$_15; +exports.vehicula = __small$_16; +exports.nunc = __small$_17; +exports.pharetra = __small$_18; +exports.lacus = __small$_19; +exports.pulvinar = __small$_20; +exports.ac = __small$_21; +exports.at = __small$_8; +exports.aenean = __small$_22; +exports.odio = __small$_23; +exports.ac = __small$_21; +exports.erat = __small$_24; +exports.nam = __small$_25; +exports.justo = __small$_15; +exports.aliquet = __small$_26; +exports.scelerisque = __small$_6; +exports.metus = __small$_27; +exports.volutpat = __small$_28; + +return exports; +})(); +var __small$_78 = (function() { +var exports = {}; +exports = { + amet: __small$_1, + consectetur: __small$_2, + adipiscing: __small$_3, + lobortis: __small$_4, + in: __small$_5, + scelerisque: __small$_6, + vulputate: __small$_7, + at: __small$_8, + facilisis: __small$_9, + urna: __small$_10, + donec: __small$_11, + morbi: __small$_12, + eleifend: __small$_13, + quisque: __small$_14, + justo: __small$_15, + vehicula: __small$_16, + nunc: __small$_17, + pharetra: __small$_18, + lacus: __small$_19, + pulvinar: __small$_20, + ac: __small$_21, + at: __small$_8, + aenean: __small$_22, + odio: __small$_23, + ac: __small$_21, + erat: __small$_24, + nam: __small$_25, + justo: __small$_15, + aliquet: __small$_26, + scelerisque: __small$_6, + metus: __small$_27, + volutpat: __small$_28, + ac: __small$_21, + venenatis: __small$_29 +}; +return exports; +})(); +var __small$_86 = (function() { +var exports = {}; +exports.ipsum = __small$_45; +exports.sit = __small$_37; +exports.nullam = __small$_50; +exports.odio = __small$_23; +exports.tortor = __small$_64; +exports.ac = __small$_21; +exports.nullam = __small$_50; +exports.pellentesque = __small$_40; +exports.cursus = __small$_65; +exports.cras = __small$_66; +exports.semper = __small$_67; +exports.malesuada = __small$_68; +exports.elementum = __small$_69; +exports.pretium = __small$_70; +exports.sodales = __small$_71; +exports.tortor = __small$_64; +exports.risus = __small$_72; +exports.hendrerit = __small$_73; +exports.tristique = __small$_74; +exports.vel = __small$_75; +exports.non = __small$_76; +exports.mattis = __small$_61; +exports.dolor = __small$_53; +exports.nisi = __small$_42; + +return exports; +})(); +exports.amet = (__small$_1 = (function() { +var exports = {}; +exports.lorem = __small$_38; + +return exports; +})()); +exports.consectetur = (__small$_2 = (function() { +var exports = {}; +exports = { + lorem: __small$_38 +}; +return exports; +})()); +exports.adipiscing = (__small$_3 = (function() { +var exports = {}; +exports.lorem = __small$_38; + +return exports; +})()); +exports.lobortis = (__small$_4 = (function() { +var exports = {}; +exports.lorem = __small$_38; + +return exports; +})()); +exports.in = (__small$_5 = (function() { +var exports = {}; +exports.lorem = __small$_38; + +return exports; +})()); +exports.scelerisque = (__small$_6 = (function() { +var exports = {}; +exports.lorem = __small$_38; +exports.mi = __small$_39; +exports.pellentesque = __small$_40; +exports.egestas = __small$_41; +exports.pulvinar = __small$_20; + +return exports; +})()); +exports.vulputate = (__small$_7 = (function() { +var exports = {}; +exports = { + lorem: __small$_38, + mi: __small$_39, + pellentesque: __small$_40, + egestas: __small$_41, + pulvinar: __small$_20, + at: __small$_8, + nisi: __small$_42 +}; +return exports; +})()); +exports.at = (__small$_8 = (function() { +var exports = {}; +exports.amet = __small$_1; +exports.consectetur = __small$_2; +exports.adipiscing = __small$_3; +exports.lobortis = __small$_4; +exports.in = __small$_5; +exports.scelerisque = __small$_6; + +return exports; +})()); +exports.facilisis = (__small$_9 = (function() { +var exports = {}; +exports.lorem = __small$_38; +exports.mi = __small$_39; +exports.pellentesque = __small$_40; +exports.egestas = __small$_41; +exports.pulvinar = __small$_20; +exports.at = __small$_8; +exports.nisi = __small$_42; + +return exports; +})()); +exports.urna = (__small$_10 = (function() { +var exports = {}; +exports = { + lorem: __small$_38, + mi: __small$_39, + pellentesque: __small$_40, + egestas: __small$_41, + pulvinar: __small$_20, + at: __small$_8, + nisi: __small$_42 +}; +return exports; +})()); +exports.donec = (__small$_11 = (function() { +var exports = {}; +exports.lorem = __small$_38; +exports.mi = __small$_39; +exports.pellentesque = __small$_40; +exports.egestas = __small$_41; +exports.pulvinar = __small$_20; +exports.at = __small$_8; +exports.nisi = __small$_42; +exports.nec = __small$_43; + +return exports; +})()); +exports.morbi = (__small$_12 = (function() { +var exports = {}; +exports.lorem = __small$_38; +exports.mi = __small$_39; +exports.pellentesque = __small$_40; +exports.egestas = __small$_41; +exports.pulvinar = __small$_20; +exports.at = __small$_8; +exports.nisi = __small$_42; +exports.nec = __small$_43; +exports.diam = __small$_44; +exports.sit = __small$_37; +exports.ipsum = __small$_45; + +return exports; +})()); +exports.eleifend = (__small$_13 = (function() { +var exports = {}; +exports.lorem = __small$_38; +exports.mi = __small$_39; +exports.pellentesque = __small$_40; +exports.egestas = __small$_41; +exports.pulvinar = __small$_20; +exports.at = __small$_8; +exports.nisi = __small$_42; +exports.nec = __small$_43; +exports.diam = __small$_44; +exports.sit = __small$_37; +exports.ipsum = __small$_45; +exports.porta = __small$_46; +exports.suscipit = __small$_47; +exports.et = __small$_48; + +return exports; +})()); +exports.quisque = (__small$_14 = (function() { +var exports = {}; +exports.lorem = __small$_38; +exports.mi = __small$_39; +exports.pellentesque = __small$_40; +exports.egestas = __small$_41; +exports.pulvinar = __small$_20; +exports.at = __small$_8; +exports.nisi = __small$_42; +exports.nec = __small$_43; +exports.diam = __small$_44; +exports.sit = __small$_37; +exports.ipsum = __small$_45; +exports.porta = __small$_46; +exports.suscipit = __small$_47; +exports.et = __small$_48; + +return exports; +})()); +exports.justo = (__small$_15 = (function() { +var exports = {}; +exports.lorem = __small$_38; +exports.mi = __small$_39; +exports.pellentesque = __small$_40; +exports.egestas = __small$_41; +exports.pulvinar = __small$_20; +exports.at = __small$_8; +exports.nisi = __small$_42; +exports.nec = __small$_43; +exports.diam = __small$_44; +exports.sit = __small$_37; +exports.ipsum = __small$_45; +exports.porta = __small$_46; +exports.suscipit = __small$_47; +exports.et = __small$_48; +exports.viverra = __small$_49; + +return exports; +})()); +exports.vehicula = (__small$_16 = (function() { +var exports = {}; +exports = { + lorem: __small$_38, + mi: __small$_39, + pellentesque: __small$_40, + egestas: __small$_41, + pulvinar: __small$_20, + at: __small$_8, + nisi: __small$_42, + nec: __small$_43, + diam: __small$_44, + sit: __small$_37, + ipsum: __small$_45, + porta: __small$_46, + suscipit: __small$_47, + et: __small$_48, + viverra: __small$_49 +}; +return exports; +})()); +exports.nunc = (__small$_17 = (function() { +var exports = {}; +exports = { + ipsum: __small$_45, + sit: __small$_37, + nullam: __small$_50, + odio: __small$_23 +}; +return exports; +})()); +exports.pharetra = (__small$_18 = (function() { +var exports = {}; +exports.lorem = __small$_38; +exports.mi = __small$_39; +exports.pellentesque = __small$_40; +exports.egestas = __small$_41; +exports.pulvinar = __small$_20; +exports.at = __small$_8; +exports.nisi = __small$_42; +exports.nec = __small$_43; +exports.diam = __small$_44; +exports.sit = __small$_37; +exports.ipsum = __small$_45; +exports.porta = __small$_46; +exports.suscipit = __small$_47; +exports.et = __small$_48; +exports.viverra = __small$_49; +exports.ultrices = __small$_51; +exports.at = __small$_8; + +return exports; +})()); +exports.lacus = (__small$_19 = (function() { +var exports = {}; +exports.lorem = __small$_38; +exports.mi = __small$_39; +exports.pellentesque = __small$_40; +exports.egestas = __small$_41; +exports.pulvinar = __small$_20; +exports.at = __small$_8; +exports.nisi = __small$_42; +exports.nec = __small$_43; +exports.diam = __small$_44; +exports.sit = __small$_37; +exports.ipsum = __small$_45; +exports.porta = __small$_46; +exports.suscipit = __small$_47; +exports.et = __small$_48; +exports.viverra = __small$_49; +exports.ultrices = __small$_51; +exports.at = __small$_8; +exports.vehicula = __small$_16; +exports.dui = __small$_52; + +return exports; +})()); +exports.pulvinar = (__small$_20 = (function() { +var exports = {}; +exports = { + amet: __small$_1, + consectetur: __small$_2, + adipiscing: __small$_3, + lobortis: __small$_4, + in: __small$_5 +}; +return exports; +})()); +exports.ac = (__small$_21 = (function() { +var exports = {}; +exports = { + dolor: __small$_53, + elit: __small$_54, + rutrum: __small$_55, + interdum: __small$_56, + mollis: __small$_57, + etiam: __small$_58, + nunc: __small$_17, + ornare: __small$_59 +}; +return exports; +})()); +exports.at = __small$_8; +exports.aenean = (__small$_22 = (function() { +var exports = {}; +exports.lorem = __small$_38; +exports.mi = __small$_39; +exports.pellentesque = __small$_40; +exports.egestas = __small$_41; +exports.pulvinar = __small$_20; +exports.at = __small$_8; +exports.nisi = __small$_42; +exports.nec = __small$_43; +exports.diam = __small$_44; +exports.sit = __small$_37; +exports.ipsum = __small$_45; +exports.porta = __small$_46; +exports.suscipit = __small$_47; +exports.et = __small$_48; +exports.viverra = __small$_49; +exports.ultrices = __small$_51; +exports.at = __small$_8; +exports.vehicula = __small$_16; +exports.dui = __small$_52; +exports.nibh = __small$_60; +exports.mattis = __small$_61; +exports.imperdiet = __small$_62; + +return exports; +})()); +exports.odio = (__small$_23 = (function() { +var exports = {}; +exports = { + dolor: __small$_53, + elit: __small$_54, + rutrum: __small$_55 +}; +return exports; +})()); +exports.ac = __small$_21; +exports.erat = (__small$_24 = (function() { +var exports = {}; +exports.lorem = __small$_38; +exports.mi = __small$_39; +exports.pellentesque = __small$_40; +exports.egestas = __small$_41; +exports.pulvinar = __small$_20; +exports.at = __small$_8; +exports.nisi = __small$_42; +exports.nec = __small$_43; +exports.diam = __small$_44; +exports.sit = __small$_37; +exports.ipsum = __small$_45; +exports.porta = __small$_46; +exports.suscipit = __small$_47; +exports.et = __small$_48; +exports.viverra = __small$_49; +exports.ultrices = __small$_51; +exports.at = __small$_8; +exports.vehicula = __small$_16; +exports.dui = __small$_52; +exports.nibh = __small$_60; +exports.mattis = __small$_61; +exports.imperdiet = __small$_62; +exports.integer = __small$_63; +exports.varius = __small$_36; + +return exports; +})()); +exports.nam = (__small$_25 = (function() { +var exports = {}; +exports.lorem = __small$_38; +exports.mi = __small$_39; +exports.pellentesque = __small$_40; +exports.egestas = __small$_41; +exports.pulvinar = __small$_20; +exports.at = __small$_8; +exports.nisi = __small$_42; +exports.nec = __small$_43; +exports.diam = __small$_44; +exports.sit = __small$_37; +exports.ipsum = __small$_45; +exports.porta = __small$_46; +exports.suscipit = __small$_47; +exports.et = __small$_48; +exports.viverra = __small$_49; +exports.ultrices = __small$_51; +exports.at = __small$_8; +exports.vehicula = __small$_16; +exports.dui = __small$_52; +exports.nibh = __small$_60; +exports.mattis = __small$_61; +exports.imperdiet = __small$_62; +exports.integer = __small$_63; +exports.varius = __small$_36; + +return exports; +})()); +exports.justo = __small$_15; +exports.aliquet = (__small$_26 = (function() { +var exports = {}; +exports.ipsum = __small$_45; +exports.sit = __small$_37; +exports.nullam = __small$_50; +exports.odio = __small$_23; +exports.tortor = __small$_64; +exports.ac = __small$_21; +exports.nullam = __small$_50; + +return exports; +})()); +exports.scelerisque = __small$_6; +exports.metus = (__small$_27 = (function() { +var exports = {}; +exports.ipsum = __small$_45; +exports.sit = __small$_37; +exports.nullam = __small$_50; +exports.odio = __small$_23; +exports.tortor = __small$_64; +exports.ac = __small$_21; +exports.nullam = __small$_50; +exports.pellentesque = __small$_40; +exports.cursus = __small$_65; +exports.cras = __small$_66; +exports.semper = __small$_67; +exports.malesuada = __small$_68; +exports.elementum = __small$_69; +exports.pretium = __small$_70; +exports.sodales = __small$_71; +exports.tortor = __small$_64; +exports.risus = __small$_72; +exports.hendrerit = __small$_73; +exports.tristique = __small$_74; +exports.vel = __small$_75; +exports.non = __small$_76; +exports.mattis = __small$_61; +exports.dolor = __small$_53; +exports.nisi = __small$_42; + +return exports; +})()); +exports.volutpat = (__small$_28 = (function() { +var exports = {}; +exports.lorem = __small$_38; +exports.mi = __small$_39; +exports.pellentesque = __small$_40; +exports.egestas = __small$_41; +exports.pulvinar = __small$_20; +exports.at = __small$_8; +exports.nisi = __small$_42; +exports.nec = __small$_43; +exports.diam = __small$_44; +exports.sit = __small$_37; +exports.ipsum = __small$_45; +exports.porta = __small$_46; +exports.suscipit = __small$_47; +exports.et = __small$_48; +exports.viverra = __small$_49; +exports.ultrices = __small$_51; +exports.at = __small$_8; +exports.vehicula = __small$_16; +exports.dui = __small$_52; +exports.nibh = __small$_60; +exports.mattis = __small$_61; +exports.imperdiet = __small$_62; +exports.integer = __small$_63; +exports.varius = __small$_36; +exports.in = __small$_5; + +return exports; +})()); +exports.ac = __small$_21; +exports.venenatis = (__small$_29 = (function() { +var exports = {}; +exports.lorem = __small$_38; +exports.mi = __small$_39; +exports.pellentesque = __small$_40; +exports.egestas = __small$_41; +exports.pulvinar = __small$_20; +exports.at = __small$_8; +exports.nisi = __small$_42; +exports.nec = __small$_43; +exports.diam = __small$_44; +exports.sit = __small$_37; +exports.ipsum = __small$_45; +exports.porta = __small$_46; +exports.suscipit = __small$_47; +exports.et = __small$_48; +exports.viverra = __small$_49; +exports.ultrices = __small$_51; +exports.at = __small$_8; +exports.vehicula = __small$_16; +exports.dui = __small$_52; +exports.nibh = __small$_60; +exports.mattis = __small$_61; +exports.imperdiet = __small$_62; +exports.integer = __small$_63; +exports.varius = __small$_36; +exports.in = __small$_5; +exports.auctor = __small$_77; +exports.urna = __small$_10; + +return exports; +})()); +exports.justo = __small$_15; +exports.quam = (__small$_30 = (function() { +var exports = {}; +exports.lorem = __small$_38; +exports.mi = __small$_39; +exports.pellentesque = __small$_40; +exports.egestas = __small$_41; +exports.pulvinar = __small$_20; +exports.at = __small$_8; +exports.nisi = __small$_42; +exports.nec = __small$_43; +exports.diam = __small$_44; +exports.sit = __small$_37; +exports.ipsum = __small$_45; +exports.porta = __small$_46; +exports.suscipit = __small$_47; +exports.et = __small$_48; +exports.viverra = __small$_49; +exports.ultrices = __small$_51; +exports.at = __small$_8; +exports.vehicula = __small$_16; +exports.dui = __small$_52; +exports.nibh = __small$_60; +exports.mattis = __small$_61; +exports.imperdiet = __small$_62; +exports.integer = __small$_63; +exports.varius = __small$_36; +exports.in = __small$_5; +exports.auctor = __small$_77; +exports.urna = __small$_10; +exports.auctor = __small$_77; +exports.ante = __small$_78; +exports.sed = __small$_35; + +return exports; +})()); +exports.quis = (__small$_31 = (function() { +var exports = {}; +exports = { + dolor: __small$_53, + elit: __small$_54, + rutrum: __small$_55, + interdum: __small$_56, + mollis: __small$_57, + etiam: __small$_58, + nunc: __small$_17, + ornare: __small$_59, + eros: __small$_79, + nulla: __small$_80, + pulvinar: __small$_20, + aliquet: __small$_26, + ligula: __small$_81, + ullamcorper: __small$_82, + amet: __small$_1, + vulputate: __small$_7, + lorem: __small$_38, + libero: __small$_83, + tincidunt: __small$_84, + felis: __small$_85, + nisi: __small$_42, + sed: __small$_35, + felis: __small$_85, + ligula: __small$_81, + vulputate: __small$_7, + nam: __small$_25, + viverra: __small$_49, + metus: __small$_27, + tellus: __small$_86 +}; +return exports; +})()); +exports.augue = (__small$_32 = (function() { +var exports = {}; +exports = { + lorem: __small$_38, + mi: __small$_39, + pellentesque: __small$_40, + egestas: __small$_41, + pulvinar: __small$_20, + at: __small$_8, + nisi: __small$_42, + nec: __small$_43, + diam: __small$_44, + sit: __small$_37, + ipsum: __small$_45, + porta: __small$_46, + suscipit: __small$_47, + et: __small$_48, + viverra: __small$_49, + ultrices: __small$_51, + at: __small$_8, + vehicula: __small$_16, + dui: __small$_52, + nibh: __small$_60, + mattis: __small$_61, + imperdiet: __small$_62, + integer: __small$_63, + varius: __small$_36, + in: __small$_5, + auctor: __small$_77, + urna: __small$_10, + auctor: __small$_77, + ante: __small$_78, + sed: __small$_35, + sed: __small$_35 +}; +return exports; +})()); +exports.euismod = (__small$_33 = (function() { +var exports = {}; +exports.lorem = __small$_38; +exports.mi = __small$_39; +exports.pellentesque = __small$_40; +exports.egestas = __small$_41; +exports.pulvinar = __small$_20; +exports.at = __small$_8; +exports.nisi = __small$_42; +exports.nec = __small$_43; +exports.diam = __small$_44; +exports.sit = __small$_37; +exports.ipsum = __small$_45; +exports.porta = __small$_46; +exports.suscipit = __small$_47; +exports.et = __small$_48; +exports.viverra = __small$_49; +exports.ultrices = __small$_51; +exports.at = __small$_8; +exports.vehicula = __small$_16; +exports.dui = __small$_52; +exports.nibh = __small$_60; +exports.mattis = __small$_61; +exports.imperdiet = __small$_62; +exports.integer = __small$_63; +exports.varius = __small$_36; +exports.in = __small$_5; +exports.auctor = __small$_77; +exports.urna = __small$_10; +exports.auctor = __small$_77; +exports.ante = __small$_78; +exports.sed = __small$_35; +exports.sed = __small$_35; + +return exports; +})()); +exports.nunc = __small$_17; +exports.molestie = ((function() { +var exports = {}; +var __small$_93 = (function() { +var exports = {}; +exports.ipsum = __small$_45; +exports.sit = __small$_37; +exports.nullam = __small$_50; +exports.odio = __small$_23; +exports.tortor = __small$_64; +exports.ac = __small$_21; +exports.nullam = __small$_50; +exports.pellentesque = __small$_40; +exports.cursus = __small$_65; +exports.cras = __small$_66; +exports.semper = __small$_67; +exports.malesuada = __small$_68; +exports.elementum = __small$_69; +exports.pretium = __small$_70; +exports.sodales = __small$_71; +exports.tortor = __small$_64; +exports.risus = __small$_72; +exports.hendrerit = __small$_73; +exports.tristique = __small$_74; +exports.vel = __small$_75; +exports.non = __small$_76; +exports.mattis = __small$_61; +exports.dolor = __small$_53; +exports.nisi = __small$_42; +exports.quis = __small$_31; +exports.mi = __small$_39; + +return exports; +})(); +var __small$_91 = (function() { +var exports = {}; +exports.dolor = __small$_53; +exports.elit = __small$_54; +exports.rutrum = __small$_55; +exports.interdum = __small$_56; +exports.mollis = __small$_57; +exports.etiam = __small$_58; +exports.nunc = __small$_17; +exports.ornare = __small$_59; +exports.eros = __small$_79; +exports.nulla = __small$_80; +exports.pulvinar = __small$_20; +exports.aliquet = __small$_26; +exports.ligula = __small$_81; +exports.ullamcorper = __small$_82; +exports.amet = __small$_1; +exports.vulputate = __small$_7; +exports.lorem = __small$_38; +exports.libero = __small$_83; +exports.tincidunt = __small$_84; +exports.felis = __small$_85; +exports.nisi = __small$_42; +exports.sed = __small$_35; +exports.felis = __small$_85; +exports.ligula = __small$_81; +exports.vulputate = __small$_7; +exports.nam = __small$_25; +exports.viverra = __small$_49; +exports.metus = __small$_27; +exports.tellus = __small$_86; +exports.lectus = __small$_93; +exports.urna = __small$_10; + +return exports; +})(); +var __small$_94 = (function() { +var exports = {}; +exports.ipsum = __small$_45; +exports.sit = __small$_37; +exports.nullam = __small$_50; +exports.odio = __small$_23; +exports.tortor = __small$_64; +exports.ac = __small$_21; +exports.nullam = __small$_50; +exports.pellentesque = __small$_40; +exports.cursus = __small$_65; +exports.cras = __small$_66; +exports.semper = __small$_67; +exports.malesuada = __small$_68; +exports.elementum = __small$_69; +exports.pretium = __small$_70; +exports.sodales = __small$_71; +exports.tortor = __small$_64; +exports.risus = __small$_72; +exports.hendrerit = __small$_73; +exports.tristique = __small$_74; +exports.vel = __small$_75; +exports.non = __small$_76; +exports.mattis = __small$_61; +exports.dolor = __small$_53; +exports.nisi = __small$_42; +exports.quis = __small$_31; +exports.mi = __small$_39; +exports.mauris = __small$_91; + +return exports; +})(); +var __small$_95 = (function() { +var exports = {}; +exports.ipsum = __small$_45; +exports.sit = __small$_37; +exports.nullam = __small$_50; +exports.odio = __small$_23; +exports.tortor = __small$_64; +exports.ac = __small$_21; +exports.nullam = __small$_50; +exports.pellentesque = __small$_40; +exports.cursus = __small$_65; +exports.cras = __small$_66; +exports.semper = __small$_67; +exports.malesuada = __small$_68; +exports.elementum = __small$_69; +exports.pretium = __small$_70; +exports.sodales = __small$_71; +exports.tortor = __small$_64; +exports.risus = __small$_72; +exports.hendrerit = __small$_73; +exports.tristique = __small$_74; +exports.vel = __small$_75; +exports.non = __small$_76; +exports.mattis = __small$_61; +exports.dolor = __small$_53; +exports.nisi = __small$_42; +exports.quis = __small$_31; +exports.mi = __small$_39; +exports.mauris = __small$_91; +exports.in = __small$_5; + +return exports; +})(); +var __small$_96 = (function() { +var exports = {}; +exports.ipsum = __small$_45; +exports.sit = __small$_37; +exports.nullam = __small$_50; +exports.odio = __small$_23; +exports.tortor = __small$_64; +exports.ac = __small$_21; +exports.nullam = __small$_50; +exports.pellentesque = __small$_40; +exports.cursus = __small$_65; +exports.cras = __small$_66; +exports.semper = __small$_67; +exports.malesuada = __small$_68; +exports.elementum = __small$_69; +exports.pretium = __small$_70; +exports.sodales = __small$_71; +exports.tortor = __small$_64; +exports.risus = __small$_72; +exports.hendrerit = __small$_73; +exports.tristique = __small$_74; +exports.vel = __small$_75; +exports.non = __small$_76; +exports.mattis = __small$_61; +exports.dolor = __small$_53; +exports.nisi = __small$_42; +exports.quis = __small$_31; +exports.mi = __small$_39; +exports.mauris = __small$_91; +exports.in = __small$_5; + +return exports; +})(); +exports.lorem = __small$_38; +exports.mi = __small$_39; +exports.pellentesque = __small$_40; +exports.egestas = __small$_41; +exports.pulvinar = __small$_20; +exports.at = __small$_8; +exports.nisi = __small$_42; +exports.nec = __small$_43; +exports.diam = __small$_44; +exports.sit = __small$_37; +exports.ipsum = __small$_45; +exports.porta = __small$_46; +exports.suscipit = __small$_47; +exports.et = __small$_48; +exports.viverra = __small$_49; +exports.ultrices = __small$_51; +exports.at = __small$_8; +exports.vehicula = __small$_16; +exports.dui = __small$_52; +exports.nibh = __small$_60; +exports.mattis = __small$_61; +exports.imperdiet = __small$_62; +exports.integer = __small$_63; +exports.varius = __small$_36; +exports.in = __small$_5; +exports.auctor = __small$_77; +exports.urna = __small$_10; +exports.auctor = __small$_77; +exports.ante = __small$_78; +exports.sed = __small$_35; +exports.sed = __small$_35; +exports.aliquam = ((function() { +var exports = {}; +exports.amet = __small$_1; +exports.consectetur = __small$_2; +exports.adipiscing = __small$_3; +exports.lobortis = __small$_4; +exports.in = __small$_5; +exports.scelerisque = __small$_6; +exports.vulputate = __small$_7; +exports.at = __small$_8; +exports.facilisis = __small$_9; +exports.urna = __small$_10; +exports.donec = __small$_11; +exports.morbi = __small$_12; +exports.eleifend = __small$_13; +exports.quisque = __small$_14; +exports.justo = __small$_15; +exports.vehicula = __small$_16; +exports.nunc = __small$_17; +exports.pharetra = __small$_18; +exports.lacus = __small$_19; +exports.pulvinar = __small$_20; +exports.ac = __small$_21; +exports.at = __small$_8; +exports.aenean = __small$_22; +exports.odio = __small$_23; +exports.ac = __small$_21; +exports.erat = __small$_24; +exports.nam = __small$_25; +exports.justo = __small$_15; +exports.aliquet = __small$_26; +exports.scelerisque = __small$_6; +exports.metus = __small$_27; +exports.volutpat = __small$_28; +exports.ac = __small$_21; +exports.venenatis = __small$_29; +exports.justo = __small$_15; +exports.quam = __small$_30; +exports.quis = __small$_31; +exports.augue = __small$_32; +exports.euismod = __small$_33; + +return exports; +})()); +exports.lacus = __small$_19; +exports.tempor = ((function() { +var exports = {}; +exports.amet = __small$_1; +exports.consectetur = __small$_2; +exports.adipiscing = __small$_3; +exports.lobortis = __small$_4; +exports.in = __small$_5; +exports.scelerisque = __small$_6; +exports.vulputate = __small$_7; +exports.at = __small$_8; +exports.facilisis = __small$_9; +exports.urna = __small$_10; +exports.donec = __small$_11; +exports.morbi = __small$_12; +exports.eleifend = __small$_13; +exports.quisque = __small$_14; +exports.justo = __small$_15; +exports.vehicula = __small$_16; +exports.nunc = __small$_17; +exports.pharetra = __small$_18; +exports.lacus = __small$_19; +exports.pulvinar = __small$_20; +exports.ac = __small$_21; +exports.at = __small$_8; +exports.aenean = __small$_22; +exports.odio = __small$_23; +exports.ac = __small$_21; +exports.erat = __small$_24; +exports.nam = __small$_25; +exports.justo = __small$_15; +exports.aliquet = __small$_26; +exports.scelerisque = __small$_6; +exports.metus = __small$_27; +exports.volutpat = __small$_28; +exports.ac = __small$_21; +exports.venenatis = __small$_29; +exports.justo = __small$_15; +exports.quam = __small$_30; +exports.quis = __small$_31; +exports.augue = __small$_32; +exports.euismod = __small$_33; + +return exports; +})()); +exports.interdum = __small$_56; +exports.id = ((function() { +var exports = {}; +exports = { + ipsum: __small$_45, + sit: __small$_37, + nullam: __small$_50, + odio: __small$_23, + tortor: __small$_64, + ac: __small$_21, + nullam: __small$_50, + pellentesque: __small$_40, + cursus: __small$_65, + cras: __small$_66, + semper: __small$_67, + malesuada: __small$_68, + elementum: __small$_69, + pretium: __small$_70, + sodales: __small$_71, + tortor: __small$_64, + risus: __small$_72, + hendrerit: __small$_73, + tristique: __small$_74, + vel: __small$_75, + non: __small$_76, + mattis: __small$_61, + dolor: __small$_53, + nisi: __small$_42, + quis: __small$_31, + mi: __small$_39, + mauris: __small$_91, + in: __small$_5, + porttitor: __small$_90, + commodo: ((function() { +var exports = {}; +exports.dolor = __small$_53; +exports.elit = __small$_54; +exports.rutrum = __small$_55; +exports.interdum = __small$_56; +exports.mollis = __small$_57; +exports.etiam = __small$_58; +exports.nunc = __small$_17; +exports.ornare = __small$_59; +exports.eros = __small$_79; +exports.nulla = __small$_80; +exports.pulvinar = __small$_20; +exports.aliquet = __small$_26; +exports.ligula = __small$_81; +exports.ullamcorper = __small$_82; +exports.amet = __small$_1; +exports.vulputate = __small$_7; +exports.lorem = __small$_38; +exports.libero = __small$_83; +exports.tincidunt = __small$_84; +exports.felis = __small$_85; +exports.nisi = __small$_42; +exports.sed = __small$_35; +exports.felis = __small$_85; +exports.ligula = __small$_81; +exports.vulputate = __small$_7; +exports.nam = __small$_25; +exports.viverra = __small$_49; +exports.metus = __small$_27; +exports.tellus = __small$_86; +exports.lectus = __small$_93; +exports.urna = __small$_10; +exports.neque = __small$_94; +exports.mauris = __small$_91; +exports.a = __small$_95; +exports.posuere = __small$_96; + +return exports; +})()), + vel: __small$_75, + porta: __small$_46, + vel: __small$_75 +}; +return exports; +})()); +exports.porttitor = (__small$_90 = (function() { +var exports = {}; +exports.dolor = __small$_53; +exports.elit = __small$_54; +exports.rutrum = __small$_55; +exports.interdum = __small$_56; +exports.mollis = __small$_57; +exports.etiam = __small$_58; +exports.nunc = __small$_17; +exports.ornare = __small$_59; +exports.eros = __small$_79; +exports.nulla = __small$_80; +exports.pulvinar = __small$_20; +exports.aliquet = __small$_26; +exports.ligula = __small$_81; +exports.ullamcorper = __small$_82; +exports.amet = __small$_1; +exports.vulputate = __small$_7; +exports.lorem = __small$_38; +exports.libero = __small$_83; +exports.tincidunt = __small$_84; +exports.felis = __small$_85; +exports.nisi = __small$_42; +exports.sed = __small$_35; +exports.felis = __small$_85; +exports.ligula = __small$_81; +exports.vulputate = __small$_7; +exports.nam = __small$_25; +exports.viverra = __small$_49; +exports.metus = __small$_27; +exports.tellus = __small$_86; +exports.lectus = __small$_93; +exports.urna = __small$_10; +exports.neque = __small$_94; +exports.mauris = __small$_91; +exports.a = __small$_95; +exports.posuere = __small$_96; + +return exports; +})()); +exports.eros = __small$_79; + +return exports; +})()); +exports.sed = (__small$_35 = (function() { +var exports = {}; +exports = { + ipsum: __small$_45, + sit: __small$_37, + nullam: __small$_50, + odio: __small$_23, + tortor: __small$_64, + ac: __small$_21, + nullam: __small$_50, + pellentesque: __small$_40, + cursus: __small$_65, + cras: __small$_66, + semper: __small$_67, + malesuada: __small$_68, + elementum: __small$_69, + pretium: __small$_70, + sodales: __small$_71, + tortor: __small$_64, + risus: __small$_72 +}; +return exports; +})()); +exports.varius = (__small$_36 = (function() { +var exports = {}; +exports = { + amet: __small$_1, + consectetur: __small$_2, + adipiscing: __small$_3, + lobortis: __small$_4, + in: __small$_5, + scelerisque: __small$_6, + vulputate: __small$_7, + at: __small$_8, + facilisis: __small$_9, + urna: __small$_10, + donec: __small$_11, + morbi: __small$_12, + eleifend: __small$_13, + quisque: __small$_14, + justo: __small$_15, + vehicula: __small$_16, + nunc: __small$_17, + pharetra: __small$_18, + lacus: __small$_19, + pulvinar: __small$_20, + ac: __small$_21, + at: __small$_8, + aenean: __small$_22, + odio: __small$_23, + ac: __small$_21 +}; +return exports; +})()); +exports.sit = (__small$_37 = (function() { +var exports = {}; +exports.dolor = __small$_53; + +return exports; +})()); + +return exports; +})(); diff --git a/examples/big/output.universal.js b/examples/big/output.universal.js new file mode 100644 index 0000000..52285f7 --- /dev/null +++ b/examples/big/output.universal.js @@ -0,0 +1,1984 @@ +(function(__root, __factory) { if (typeof define === "function" && define.amd) { define([], __factory);} else if (typeof exports === "object") {__factory();} else {__factory();}})(this, (function() { +var exports = {}; +var __small$_38 = (function() { +var exports = {}; +exports = { + +}; +return exports; +})(); +var __small$_39 = (function() { +var exports = {}; +exports.amet = __small$_1; +exports.consectetur = __small$_2; +exports.adipiscing = __small$_3; +exports.lobortis = __small$_4; +exports.in = __small$_5; + +return exports; +})(); +var __small$_40 = (function() { +var exports = {}; +exports.amet = __small$_1; +exports.consectetur = __small$_2; +exports.adipiscing = __small$_3; +exports.lobortis = __small$_4; +exports.in = __small$_5; + +return exports; +})(); +var __small$_41 = (function() { +var exports = {}; +exports.amet = __small$_1; +exports.consectetur = __small$_2; +exports.adipiscing = __small$_3; +exports.lobortis = __small$_4; +exports.in = __small$_5; + +return exports; +})(); +var __small$_42 = (function() { +var exports = {}; +exports.amet = __small$_1; +exports.consectetur = __small$_2; +exports.adipiscing = __small$_3; +exports.lobortis = __small$_4; +exports.in = __small$_5; +exports.scelerisque = __small$_6; + +return exports; +})(); +var __small$_43 = (function() { +var exports = {}; +exports.amet = __small$_1; +exports.consectetur = __small$_2; +exports.adipiscing = __small$_3; +exports.lobortis = __small$_4; +exports.in = __small$_5; +exports.scelerisque = __small$_6; +exports.vulputate = __small$_7; +exports.at = __small$_8; +exports.facilisis = __small$_9; +exports.urna = __small$_10; + +return exports; +})(); +var __small$_44 = (function() { +var exports = {}; +exports = { + amet: __small$_1, + consectetur: __small$_2, + adipiscing: __small$_3, + lobortis: __small$_4, + in: __small$_5, + scelerisque: __small$_6, + vulputate: __small$_7, + at: __small$_8, + facilisis: __small$_9, + urna: __small$_10, + donec: __small$_11 +}; +return exports; +})(); +var __small$_45 = (function() { +var exports = {}; + +return exports; +})(); +var __small$_53 = (function() { +var exports = {}; +exports.ipsum = __small$_45; + +return exports; +})(); +var __small$_46 = (function() { +var exports = {}; +exports.amet = __small$_1; +exports.consectetur = __small$_2; +exports.adipiscing = __small$_3; +exports.lobortis = __small$_4; +exports.in = __small$_5; +exports.scelerisque = __small$_6; +exports.vulputate = __small$_7; +exports.at = __small$_8; +exports.facilisis = __small$_9; +exports.urna = __small$_10; +exports.donec = __small$_11; +exports.morbi = __small$_12; + +return exports; +})(); +var __small$_47 = (function() { +var exports = {}; +exports.amet = __small$_1; +exports.consectetur = __small$_2; +exports.adipiscing = __small$_3; +exports.lobortis = __small$_4; +exports.in = __small$_5; +exports.scelerisque = __small$_6; +exports.vulputate = __small$_7; +exports.at = __small$_8; +exports.facilisis = __small$_9; +exports.urna = __small$_10; +exports.donec = __small$_11; +exports.morbi = __small$_12; + +return exports; +})(); +var __small$_48 = (function() { +var exports = {}; +exports = { + amet: __small$_1, + consectetur: __small$_2, + adipiscing: __small$_3, + lobortis: __small$_4, + in: __small$_5, + scelerisque: __small$_6, + vulputate: __small$_7, + at: __small$_8, + facilisis: __small$_9, + urna: __small$_10, + donec: __small$_11, + morbi: __small$_12 +}; +return exports; +})(); +var __small$_49 = (function() { +var exports = {}; +exports.amet = __small$_1; +exports.consectetur = __small$_2; +exports.adipiscing = __small$_3; +exports.lobortis = __small$_4; +exports.in = __small$_5; +exports.scelerisque = __small$_6; +exports.vulputate = __small$_7; +exports.at = __small$_8; +exports.facilisis = __small$_9; +exports.urna = __small$_10; +exports.donec = __small$_11; +exports.morbi = __small$_12; +exports.eleifend = __small$_13; +exports.quisque = __small$_14; + +return exports; +})(); +var __small$_54 = (function() { +var exports = {}; +exports.ipsum = __small$_45; +exports.sit = __small$_37; + +return exports; +})(); +var __small$_50 = (function() { +var exports = {}; +exports.dolor = __small$_53; +exports.elit = __small$_54; + +return exports; +})(); +var __small$_55 = (function() { +var exports = {}; +exports.ipsum = __small$_45; +exports.sit = __small$_37; +exports.nullam = __small$_50; + +return exports; +})(); +var __small$_51 = (function() { +var exports = {}; +exports = { + amet: __small$_1, + consectetur: __small$_2, + adipiscing: __small$_3, + lobortis: __small$_4, + in: __small$_5, + scelerisque: __small$_6, + vulputate: __small$_7, + at: __small$_8, + facilisis: __small$_9, + urna: __small$_10, + donec: __small$_11, + morbi: __small$_12, + eleifend: __small$_13, + quisque: __small$_14, + justo: __small$_15, + vehicula: __small$_16, + nunc: __small$_17 +}; +return exports; +})(); +var __small$_52 = (function() { +var exports = {}; +exports = { + amet: __small$_1, + consectetur: __small$_2, + adipiscing: __small$_3, + lobortis: __small$_4, + in: __small$_5, + scelerisque: __small$_6, + vulputate: __small$_7, + at: __small$_8, + facilisis: __small$_9, + urna: __small$_10, + donec: __small$_11, + morbi: __small$_12, + eleifend: __small$_13, + quisque: __small$_14, + justo: __small$_15, + vehicula: __small$_16, + nunc: __small$_17, + pharetra: __small$_18 +}; +return exports; +})(); +var __small$_56 = (function() { +var exports = {}; +exports.ipsum = __small$_45; +exports.sit = __small$_37; +exports.nullam = __small$_50; +exports.odio = __small$_23; + +return exports; +})(); +var __small$_57 = (function() { +var exports = {}; +exports.ipsum = __small$_45; +exports.sit = __small$_37; +exports.nullam = __small$_50; +exports.odio = __small$_23; + +return exports; +})(); +var __small$_58 = (function() { +var exports = {}; +exports.ipsum = __small$_45; +exports.sit = __small$_37; +exports.nullam = __small$_50; +exports.odio = __small$_23; + +return exports; +})(); +var __small$_60 = (function() { +var exports = {}; +exports.amet = __small$_1; +exports.consectetur = __small$_2; +exports.adipiscing = __small$_3; +exports.lobortis = __small$_4; +exports.in = __small$_5; +exports.scelerisque = __small$_6; +exports.vulputate = __small$_7; +exports.at = __small$_8; +exports.facilisis = __small$_9; +exports.urna = __small$_10; +exports.donec = __small$_11; +exports.morbi = __small$_12; +exports.eleifend = __small$_13; +exports.quisque = __small$_14; +exports.justo = __small$_15; +exports.vehicula = __small$_16; +exports.nunc = __small$_17; +exports.pharetra = __small$_18; +exports.lacus = __small$_19; +exports.pulvinar = __small$_20; + +return exports; +})(); +var __small$_64 = (function() { +var exports = {}; +exports.dolor = __small$_53; +exports.elit = __small$_54; +exports.rutrum = __small$_55; +exports.interdum = __small$_56; +exports.mollis = __small$_57; +exports.etiam = __small$_58; +exports.nunc = __small$_17; + +return exports; +})(); +var __small$_59 = (function() { +var exports = {}; +exports.ipsum = __small$_45; +exports.sit = __small$_37; +exports.nullam = __small$_50; +exports.odio = __small$_23; +exports.tortor = __small$_64; + +return exports; +})(); +var __small$_61 = (function() { +var exports = {}; +exports.amet = __small$_1; +exports.consectetur = __small$_2; +exports.adipiscing = __small$_3; +exports.lobortis = __small$_4; +exports.in = __small$_5; +exports.scelerisque = __small$_6; +exports.vulputate = __small$_7; +exports.at = __small$_8; +exports.facilisis = __small$_9; +exports.urna = __small$_10; +exports.donec = __small$_11; +exports.morbi = __small$_12; +exports.eleifend = __small$_13; +exports.quisque = __small$_14; +exports.justo = __small$_15; +exports.vehicula = __small$_16; +exports.nunc = __small$_17; +exports.pharetra = __small$_18; +exports.lacus = __small$_19; +exports.pulvinar = __small$_20; +exports.ac = __small$_21; +exports.at = __small$_8; + +return exports; +})(); +var __small$_62 = (function() { +var exports = {}; +exports.amet = __small$_1; +exports.consectetur = __small$_2; +exports.adipiscing = __small$_3; +exports.lobortis = __small$_4; +exports.in = __small$_5; +exports.scelerisque = __small$_6; +exports.vulputate = __small$_7; +exports.at = __small$_8; +exports.facilisis = __small$_9; +exports.urna = __small$_10; +exports.donec = __small$_11; +exports.morbi = __small$_12; +exports.eleifend = __small$_13; +exports.quisque = __small$_14; +exports.justo = __small$_15; +exports.vehicula = __small$_16; +exports.nunc = __small$_17; +exports.pharetra = __small$_18; +exports.lacus = __small$_19; +exports.pulvinar = __small$_20; +exports.ac = __small$_21; +exports.at = __small$_8; + +return exports; +})(); +var __small$_63 = (function() { +var exports = {}; +exports = { + amet: __small$_1, + consectetur: __small$_2, + adipiscing: __small$_3, + lobortis: __small$_4, + in: __small$_5, + scelerisque: __small$_6, + vulputate: __small$_7, + at: __small$_8, + facilisis: __small$_9, + urna: __small$_10, + donec: __small$_11, + morbi: __small$_12, + eleifend: __small$_13, + quisque: __small$_14, + justo: __small$_15, + vehicula: __small$_16, + nunc: __small$_17, + pharetra: __small$_18, + lacus: __small$_19, + pulvinar: __small$_20, + ac: __small$_21, + at: __small$_8, + aenean: __small$_22, + odio: __small$_23 +}; +return exports; +})(); +var __small$_79 = (function() { +var exports = {}; +exports.ipsum = __small$_45; +exports.sit = __small$_37; +exports.nullam = __small$_50; +exports.odio = __small$_23; +exports.tortor = __small$_64; +exports.ac = __small$_21; + +return exports; +})(); +var __small$_80 = (function() { +var exports = {}; +exports.ipsum = __small$_45; +exports.sit = __small$_37; +exports.nullam = __small$_50; +exports.odio = __small$_23; +exports.tortor = __small$_64; +exports.ac = __small$_21; +exports.nullam = __small$_50; + +return exports; +})(); +var __small$_65 = (function() { +var exports = {}; +exports.dolor = __small$_53; +exports.elit = __small$_54; +exports.rutrum = __small$_55; +exports.interdum = __small$_56; +exports.mollis = __small$_57; +exports.etiam = __small$_58; +exports.nunc = __small$_17; +exports.ornare = __small$_59; +exports.eros = __small$_79; +exports.nulla = __small$_80; +exports.pulvinar = __small$_20; +exports.aliquet = __small$_26; + +return exports; +})(); +var __small$_66 = (function() { +var exports = {}; +exports.dolor = __small$_53; +exports.elit = __small$_54; +exports.rutrum = __small$_55; +exports.interdum = __small$_56; +exports.mollis = __small$_57; +exports.etiam = __small$_58; +exports.nunc = __small$_17; +exports.ornare = __small$_59; +exports.eros = __small$_79; +exports.nulla = __small$_80; +exports.pulvinar = __small$_20; +exports.aliquet = __small$_26; + +return exports; +})(); +var __small$_67 = (function() { +var exports = {}; +exports.dolor = __small$_53; +exports.elit = __small$_54; +exports.rutrum = __small$_55; +exports.interdum = __small$_56; +exports.mollis = __small$_57; +exports.etiam = __small$_58; +exports.nunc = __small$_17; +exports.ornare = __small$_59; +exports.eros = __small$_79; +exports.nulla = __small$_80; +exports.pulvinar = __small$_20; +exports.aliquet = __small$_26; + +return exports; +})(); +var __small$_81 = (function() { +var exports = {}; +exports.ipsum = __small$_45; +exports.sit = __small$_37; +exports.nullam = __small$_50; +exports.odio = __small$_23; +exports.tortor = __small$_64; +exports.ac = __small$_21; +exports.nullam = __small$_50; +exports.pellentesque = __small$_40; +exports.cursus = __small$_65; +exports.cras = __small$_66; +exports.semper = __small$_67; + +return exports; +})(); +var __small$_68 = (function() { +var exports = {}; +exports.dolor = __small$_53; +exports.elit = __small$_54; +exports.rutrum = __small$_55; +exports.interdum = __small$_56; +exports.mollis = __small$_57; +exports.etiam = __small$_58; +exports.nunc = __small$_17; +exports.ornare = __small$_59; +exports.eros = __small$_79; +exports.nulla = __small$_80; +exports.pulvinar = __small$_20; +exports.aliquet = __small$_26; +exports.ligula = __small$_81; + +return exports; +})(); +var __small$_82 = (function() { +var exports = {}; +exports.ipsum = __small$_45; +exports.sit = __small$_37; +exports.nullam = __small$_50; +exports.odio = __small$_23; +exports.tortor = __small$_64; +exports.ac = __small$_21; +exports.nullam = __small$_50; +exports.pellentesque = __small$_40; +exports.cursus = __small$_65; +exports.cras = __small$_66; +exports.semper = __small$_67; +exports.malesuada = __small$_68; + +return exports; +})(); +var __small$_69 = (function() { +var exports = {}; +exports.dolor = __small$_53; +exports.elit = __small$_54; +exports.rutrum = __small$_55; +exports.interdum = __small$_56; +exports.mollis = __small$_57; +exports.etiam = __small$_58; +exports.nunc = __small$_17; +exports.ornare = __small$_59; +exports.eros = __small$_79; +exports.nulla = __small$_80; +exports.pulvinar = __small$_20; +exports.aliquet = __small$_26; +exports.ligula = __small$_81; +exports.ullamcorper = __small$_82; +exports.amet = __small$_1; + +return exports; +})(); +var __small$_83 = (function() { +var exports = {}; +exports.ipsum = __small$_45; +exports.sit = __small$_37; +exports.nullam = __small$_50; +exports.odio = __small$_23; +exports.tortor = __small$_64; +exports.ac = __small$_21; +exports.nullam = __small$_50; +exports.pellentesque = __small$_40; +exports.cursus = __small$_65; +exports.cras = __small$_66; +exports.semper = __small$_67; +exports.malesuada = __small$_68; +exports.elementum = __small$_69; + +return exports; +})(); +var __small$_84 = (function() { +var exports = {}; +exports.ipsum = __small$_45; +exports.sit = __small$_37; +exports.nullam = __small$_50; +exports.odio = __small$_23; +exports.tortor = __small$_64; +exports.ac = __small$_21; +exports.nullam = __small$_50; +exports.pellentesque = __small$_40; +exports.cursus = __small$_65; +exports.cras = __small$_66; +exports.semper = __small$_67; +exports.malesuada = __small$_68; +exports.elementum = __small$_69; + +return exports; +})(); +var __small$_70 = (function() { +var exports = {}; +exports.dolor = __small$_53; +exports.elit = __small$_54; +exports.rutrum = __small$_55; +exports.interdum = __small$_56; +exports.mollis = __small$_57; +exports.etiam = __small$_58; +exports.nunc = __small$_17; +exports.ornare = __small$_59; +exports.eros = __small$_79; +exports.nulla = __small$_80; +exports.pulvinar = __small$_20; +exports.aliquet = __small$_26; +exports.ligula = __small$_81; +exports.ullamcorper = __small$_82; +exports.amet = __small$_1; +exports.vulputate = __small$_7; +exports.lorem = __small$_38; +exports.libero = __small$_83; +exports.tincidunt = __small$_84; + +return exports; +})(); +var __small$_85 = (function() { +var exports = {}; +exports.ipsum = __small$_45; +exports.sit = __small$_37; +exports.nullam = __small$_50; +exports.odio = __small$_23; +exports.tortor = __small$_64; +exports.ac = __small$_21; +exports.nullam = __small$_50; +exports.pellentesque = __small$_40; +exports.cursus = __small$_65; +exports.cras = __small$_66; +exports.semper = __small$_67; +exports.malesuada = __small$_68; +exports.elementum = __small$_69; +exports.pretium = __small$_70; + +return exports; +})(); +var __small$_71 = (function() { +var exports = {}; +exports = { + dolor: __small$_53, + elit: __small$_54, + rutrum: __small$_55, + interdum: __small$_56, + mollis: __small$_57, + etiam: __small$_58, + nunc: __small$_17, + ornare: __small$_59, + eros: __small$_79, + nulla: __small$_80, + pulvinar: __small$_20, + aliquet: __small$_26, + ligula: __small$_81, + ullamcorper: __small$_82, + amet: __small$_1, + vulputate: __small$_7, + lorem: __small$_38, + libero: __small$_83, + tincidunt: __small$_84, + felis: __small$_85 +}; +return exports; +})(); +var __small$_72 = (function() { +var exports = {}; +exports.dolor = __small$_53; +exports.elit = __small$_54; +exports.rutrum = __small$_55; +exports.interdum = __small$_56; +exports.mollis = __small$_57; +exports.etiam = __small$_58; +exports.nunc = __small$_17; +exports.ornare = __small$_59; +exports.eros = __small$_79; +exports.nulla = __small$_80; +exports.pulvinar = __small$_20; +exports.aliquet = __small$_26; +exports.ligula = __small$_81; +exports.ullamcorper = __small$_82; +exports.amet = __small$_1; +exports.vulputate = __small$_7; +exports.lorem = __small$_38; +exports.libero = __small$_83; +exports.tincidunt = __small$_84; +exports.felis = __small$_85; + +return exports; +})(); +var __small$_73 = (function() { +var exports = {}; +exports.dolor = __small$_53; +exports.elit = __small$_54; +exports.rutrum = __small$_55; +exports.interdum = __small$_56; +exports.mollis = __small$_57; +exports.etiam = __small$_58; +exports.nunc = __small$_17; +exports.ornare = __small$_59; +exports.eros = __small$_79; +exports.nulla = __small$_80; +exports.pulvinar = __small$_20; +exports.aliquet = __small$_26; +exports.ligula = __small$_81; +exports.ullamcorper = __small$_82; +exports.amet = __small$_1; +exports.vulputate = __small$_7; +exports.lorem = __small$_38; +exports.libero = __small$_83; +exports.tincidunt = __small$_84; +exports.felis = __small$_85; +exports.nisi = __small$_42; +exports.sed = __small$_35; + +return exports; +})(); +var __small$_74 = (function() { +var exports = {}; +exports = { + dolor: __small$_53, + elit: __small$_54, + rutrum: __small$_55, + interdum: __small$_56, + mollis: __small$_57, + etiam: __small$_58, + nunc: __small$_17, + ornare: __small$_59, + eros: __small$_79, + nulla: __small$_80, + pulvinar: __small$_20, + aliquet: __small$_26, + ligula: __small$_81, + ullamcorper: __small$_82, + amet: __small$_1, + vulputate: __small$_7, + lorem: __small$_38, + libero: __small$_83, + tincidunt: __small$_84, + felis: __small$_85, + nisi: __small$_42, + sed: __small$_35, + felis: __small$_85 +}; +return exports; +})(); +var __small$_75 = (function() { +var exports = {}; +exports.dolor = __small$_53; +exports.elit = __small$_54; +exports.rutrum = __small$_55; +exports.interdum = __small$_56; +exports.mollis = __small$_57; +exports.etiam = __small$_58; +exports.nunc = __small$_17; +exports.ornare = __small$_59; +exports.eros = __small$_79; +exports.nulla = __small$_80; +exports.pulvinar = __small$_20; +exports.aliquet = __small$_26; +exports.ligula = __small$_81; +exports.ullamcorper = __small$_82; +exports.amet = __small$_1; +exports.vulputate = __small$_7; +exports.lorem = __small$_38; +exports.libero = __small$_83; +exports.tincidunt = __small$_84; +exports.felis = __small$_85; +exports.nisi = __small$_42; +exports.sed = __small$_35; +exports.felis = __small$_85; + +return exports; +})(); +var __small$_76 = (function() { +var exports = {}; +exports.dolor = __small$_53; +exports.elit = __small$_54; +exports.rutrum = __small$_55; +exports.interdum = __small$_56; +exports.mollis = __small$_57; +exports.etiam = __small$_58; +exports.nunc = __small$_17; +exports.ornare = __small$_59; +exports.eros = __small$_79; +exports.nulla = __small$_80; +exports.pulvinar = __small$_20; +exports.aliquet = __small$_26; +exports.ligula = __small$_81; +exports.ullamcorper = __small$_82; +exports.amet = __small$_1; +exports.vulputate = __small$_7; +exports.lorem = __small$_38; +exports.libero = __small$_83; +exports.tincidunt = __small$_84; +exports.felis = __small$_85; +exports.nisi = __small$_42; +exports.sed = __small$_35; +exports.felis = __small$_85; +exports.ligula = __small$_81; + +return exports; +})(); +var __small$_77 = (function() { +var exports = {}; +exports.amet = __small$_1; +exports.consectetur = __small$_2; +exports.adipiscing = __small$_3; +exports.lobortis = __small$_4; +exports.in = __small$_5; +exports.scelerisque = __small$_6; +exports.vulputate = __small$_7; +exports.at = __small$_8; +exports.facilisis = __small$_9; +exports.urna = __small$_10; +exports.donec = __small$_11; +exports.morbi = __small$_12; +exports.eleifend = __small$_13; +exports.quisque = __small$_14; +exports.justo = __small$_15; +exports.vehicula = __small$_16; +exports.nunc = __small$_17; +exports.pharetra = __small$_18; +exports.lacus = __small$_19; +exports.pulvinar = __small$_20; +exports.ac = __small$_21; +exports.at = __small$_8; +exports.aenean = __small$_22; +exports.odio = __small$_23; +exports.ac = __small$_21; +exports.erat = __small$_24; +exports.nam = __small$_25; +exports.justo = __small$_15; +exports.aliquet = __small$_26; +exports.scelerisque = __small$_6; +exports.metus = __small$_27; +exports.volutpat = __small$_28; + +return exports; +})(); +var __small$_78 = (function() { +var exports = {}; +exports = { + amet: __small$_1, + consectetur: __small$_2, + adipiscing: __small$_3, + lobortis: __small$_4, + in: __small$_5, + scelerisque: __small$_6, + vulputate: __small$_7, + at: __small$_8, + facilisis: __small$_9, + urna: __small$_10, + donec: __small$_11, + morbi: __small$_12, + eleifend: __small$_13, + quisque: __small$_14, + justo: __small$_15, + vehicula: __small$_16, + nunc: __small$_17, + pharetra: __small$_18, + lacus: __small$_19, + pulvinar: __small$_20, + ac: __small$_21, + at: __small$_8, + aenean: __small$_22, + odio: __small$_23, + ac: __small$_21, + erat: __small$_24, + nam: __small$_25, + justo: __small$_15, + aliquet: __small$_26, + scelerisque: __small$_6, + metus: __small$_27, + volutpat: __small$_28, + ac: __small$_21, + venenatis: __small$_29 +}; +return exports; +})(); +var __small$_86 = (function() { +var exports = {}; +exports.ipsum = __small$_45; +exports.sit = __small$_37; +exports.nullam = __small$_50; +exports.odio = __small$_23; +exports.tortor = __small$_64; +exports.ac = __small$_21; +exports.nullam = __small$_50; +exports.pellentesque = __small$_40; +exports.cursus = __small$_65; +exports.cras = __small$_66; +exports.semper = __small$_67; +exports.malesuada = __small$_68; +exports.elementum = __small$_69; +exports.pretium = __small$_70; +exports.sodales = __small$_71; +exports.tortor = __small$_64; +exports.risus = __small$_72; +exports.hendrerit = __small$_73; +exports.tristique = __small$_74; +exports.vel = __small$_75; +exports.non = __small$_76; +exports.mattis = __small$_61; +exports.dolor = __small$_53; +exports.nisi = __small$_42; + +return exports; +})(); +exports.amet = (__small$_1 = (function() { +var exports = {}; +exports.lorem = __small$_38; + +return exports; +})()); +exports.consectetur = (__small$_2 = (function() { +var exports = {}; +exports = { + lorem: __small$_38 +}; +return exports; +})()); +exports.adipiscing = (__small$_3 = (function() { +var exports = {}; +exports.lorem = __small$_38; + +return exports; +})()); +exports.lobortis = (__small$_4 = (function() { +var exports = {}; +exports.lorem = __small$_38; + +return exports; +})()); +exports.in = (__small$_5 = (function() { +var exports = {}; +exports.lorem = __small$_38; + +return exports; +})()); +exports.scelerisque = (__small$_6 = (function() { +var exports = {}; +exports.lorem = __small$_38; +exports.mi = __small$_39; +exports.pellentesque = __small$_40; +exports.egestas = __small$_41; +exports.pulvinar = __small$_20; + +return exports; +})()); +exports.vulputate = (__small$_7 = (function() { +var exports = {}; +exports = { + lorem: __small$_38, + mi: __small$_39, + pellentesque: __small$_40, + egestas: __small$_41, + pulvinar: __small$_20, + at: __small$_8, + nisi: __small$_42 +}; +return exports; +})()); +exports.at = (__small$_8 = (function() { +var exports = {}; +exports.amet = __small$_1; +exports.consectetur = __small$_2; +exports.adipiscing = __small$_3; +exports.lobortis = __small$_4; +exports.in = __small$_5; +exports.scelerisque = __small$_6; + +return exports; +})()); +exports.facilisis = (__small$_9 = (function() { +var exports = {}; +exports.lorem = __small$_38; +exports.mi = __small$_39; +exports.pellentesque = __small$_40; +exports.egestas = __small$_41; +exports.pulvinar = __small$_20; +exports.at = __small$_8; +exports.nisi = __small$_42; + +return exports; +})()); +exports.urna = (__small$_10 = (function() { +var exports = {}; +exports = { + lorem: __small$_38, + mi: __small$_39, + pellentesque: __small$_40, + egestas: __small$_41, + pulvinar: __small$_20, + at: __small$_8, + nisi: __small$_42 +}; +return exports; +})()); +exports.donec = (__small$_11 = (function() { +var exports = {}; +exports.lorem = __small$_38; +exports.mi = __small$_39; +exports.pellentesque = __small$_40; +exports.egestas = __small$_41; +exports.pulvinar = __small$_20; +exports.at = __small$_8; +exports.nisi = __small$_42; +exports.nec = __small$_43; + +return exports; +})()); +exports.morbi = (__small$_12 = (function() { +var exports = {}; +exports.lorem = __small$_38; +exports.mi = __small$_39; +exports.pellentesque = __small$_40; +exports.egestas = __small$_41; +exports.pulvinar = __small$_20; +exports.at = __small$_8; +exports.nisi = __small$_42; +exports.nec = __small$_43; +exports.diam = __small$_44; +exports.sit = __small$_37; +exports.ipsum = __small$_45; + +return exports; +})()); +exports.eleifend = (__small$_13 = (function() { +var exports = {}; +exports.lorem = __small$_38; +exports.mi = __small$_39; +exports.pellentesque = __small$_40; +exports.egestas = __small$_41; +exports.pulvinar = __small$_20; +exports.at = __small$_8; +exports.nisi = __small$_42; +exports.nec = __small$_43; +exports.diam = __small$_44; +exports.sit = __small$_37; +exports.ipsum = __small$_45; +exports.porta = __small$_46; +exports.suscipit = __small$_47; +exports.et = __small$_48; + +return exports; +})()); +exports.quisque = (__small$_14 = (function() { +var exports = {}; +exports.lorem = __small$_38; +exports.mi = __small$_39; +exports.pellentesque = __small$_40; +exports.egestas = __small$_41; +exports.pulvinar = __small$_20; +exports.at = __small$_8; +exports.nisi = __small$_42; +exports.nec = __small$_43; +exports.diam = __small$_44; +exports.sit = __small$_37; +exports.ipsum = __small$_45; +exports.porta = __small$_46; +exports.suscipit = __small$_47; +exports.et = __small$_48; + +return exports; +})()); +exports.justo = (__small$_15 = (function() { +var exports = {}; +exports.lorem = __small$_38; +exports.mi = __small$_39; +exports.pellentesque = __small$_40; +exports.egestas = __small$_41; +exports.pulvinar = __small$_20; +exports.at = __small$_8; +exports.nisi = __small$_42; +exports.nec = __small$_43; +exports.diam = __small$_44; +exports.sit = __small$_37; +exports.ipsum = __small$_45; +exports.porta = __small$_46; +exports.suscipit = __small$_47; +exports.et = __small$_48; +exports.viverra = __small$_49; + +return exports; +})()); +exports.vehicula = (__small$_16 = (function() { +var exports = {}; +exports = { + lorem: __small$_38, + mi: __small$_39, + pellentesque: __small$_40, + egestas: __small$_41, + pulvinar: __small$_20, + at: __small$_8, + nisi: __small$_42, + nec: __small$_43, + diam: __small$_44, + sit: __small$_37, + ipsum: __small$_45, + porta: __small$_46, + suscipit: __small$_47, + et: __small$_48, + viverra: __small$_49 +}; +return exports; +})()); +exports.nunc = (__small$_17 = (function() { +var exports = {}; +exports = { + ipsum: __small$_45, + sit: __small$_37, + nullam: __small$_50, + odio: __small$_23 +}; +return exports; +})()); +exports.pharetra = (__small$_18 = (function() { +var exports = {}; +exports.lorem = __small$_38; +exports.mi = __small$_39; +exports.pellentesque = __small$_40; +exports.egestas = __small$_41; +exports.pulvinar = __small$_20; +exports.at = __small$_8; +exports.nisi = __small$_42; +exports.nec = __small$_43; +exports.diam = __small$_44; +exports.sit = __small$_37; +exports.ipsum = __small$_45; +exports.porta = __small$_46; +exports.suscipit = __small$_47; +exports.et = __small$_48; +exports.viverra = __small$_49; +exports.ultrices = __small$_51; +exports.at = __small$_8; + +return exports; +})()); +exports.lacus = (__small$_19 = (function() { +var exports = {}; +exports.lorem = __small$_38; +exports.mi = __small$_39; +exports.pellentesque = __small$_40; +exports.egestas = __small$_41; +exports.pulvinar = __small$_20; +exports.at = __small$_8; +exports.nisi = __small$_42; +exports.nec = __small$_43; +exports.diam = __small$_44; +exports.sit = __small$_37; +exports.ipsum = __small$_45; +exports.porta = __small$_46; +exports.suscipit = __small$_47; +exports.et = __small$_48; +exports.viverra = __small$_49; +exports.ultrices = __small$_51; +exports.at = __small$_8; +exports.vehicula = __small$_16; +exports.dui = __small$_52; + +return exports; +})()); +exports.pulvinar = (__small$_20 = (function() { +var exports = {}; +exports = { + amet: __small$_1, + consectetur: __small$_2, + adipiscing: __small$_3, + lobortis: __small$_4, + in: __small$_5 +}; +return exports; +})()); +exports.ac = (__small$_21 = (function() { +var exports = {}; +exports = { + dolor: __small$_53, + elit: __small$_54, + rutrum: __small$_55, + interdum: __small$_56, + mollis: __small$_57, + etiam: __small$_58, + nunc: __small$_17, + ornare: __small$_59 +}; +return exports; +})()); +exports.at = __small$_8; +exports.aenean = (__small$_22 = (function() { +var exports = {}; +exports.lorem = __small$_38; +exports.mi = __small$_39; +exports.pellentesque = __small$_40; +exports.egestas = __small$_41; +exports.pulvinar = __small$_20; +exports.at = __small$_8; +exports.nisi = __small$_42; +exports.nec = __small$_43; +exports.diam = __small$_44; +exports.sit = __small$_37; +exports.ipsum = __small$_45; +exports.porta = __small$_46; +exports.suscipit = __small$_47; +exports.et = __small$_48; +exports.viverra = __small$_49; +exports.ultrices = __small$_51; +exports.at = __small$_8; +exports.vehicula = __small$_16; +exports.dui = __small$_52; +exports.nibh = __small$_60; +exports.mattis = __small$_61; +exports.imperdiet = __small$_62; + +return exports; +})()); +exports.odio = (__small$_23 = (function() { +var exports = {}; +exports = { + dolor: __small$_53, + elit: __small$_54, + rutrum: __small$_55 +}; +return exports; +})()); +exports.ac = __small$_21; +exports.erat = (__small$_24 = (function() { +var exports = {}; +exports.lorem = __small$_38; +exports.mi = __small$_39; +exports.pellentesque = __small$_40; +exports.egestas = __small$_41; +exports.pulvinar = __small$_20; +exports.at = __small$_8; +exports.nisi = __small$_42; +exports.nec = __small$_43; +exports.diam = __small$_44; +exports.sit = __small$_37; +exports.ipsum = __small$_45; +exports.porta = __small$_46; +exports.suscipit = __small$_47; +exports.et = __small$_48; +exports.viverra = __small$_49; +exports.ultrices = __small$_51; +exports.at = __small$_8; +exports.vehicula = __small$_16; +exports.dui = __small$_52; +exports.nibh = __small$_60; +exports.mattis = __small$_61; +exports.imperdiet = __small$_62; +exports.integer = __small$_63; +exports.varius = __small$_36; + +return exports; +})()); +exports.nam = (__small$_25 = (function() { +var exports = {}; +exports.lorem = __small$_38; +exports.mi = __small$_39; +exports.pellentesque = __small$_40; +exports.egestas = __small$_41; +exports.pulvinar = __small$_20; +exports.at = __small$_8; +exports.nisi = __small$_42; +exports.nec = __small$_43; +exports.diam = __small$_44; +exports.sit = __small$_37; +exports.ipsum = __small$_45; +exports.porta = __small$_46; +exports.suscipit = __small$_47; +exports.et = __small$_48; +exports.viverra = __small$_49; +exports.ultrices = __small$_51; +exports.at = __small$_8; +exports.vehicula = __small$_16; +exports.dui = __small$_52; +exports.nibh = __small$_60; +exports.mattis = __small$_61; +exports.imperdiet = __small$_62; +exports.integer = __small$_63; +exports.varius = __small$_36; + +return exports; +})()); +exports.justo = __small$_15; +exports.aliquet = (__small$_26 = (function() { +var exports = {}; +exports.ipsum = __small$_45; +exports.sit = __small$_37; +exports.nullam = __small$_50; +exports.odio = __small$_23; +exports.tortor = __small$_64; +exports.ac = __small$_21; +exports.nullam = __small$_50; + +return exports; +})()); +exports.scelerisque = __small$_6; +exports.metus = (__small$_27 = (function() { +var exports = {}; +exports.ipsum = __small$_45; +exports.sit = __small$_37; +exports.nullam = __small$_50; +exports.odio = __small$_23; +exports.tortor = __small$_64; +exports.ac = __small$_21; +exports.nullam = __small$_50; +exports.pellentesque = __small$_40; +exports.cursus = __small$_65; +exports.cras = __small$_66; +exports.semper = __small$_67; +exports.malesuada = __small$_68; +exports.elementum = __small$_69; +exports.pretium = __small$_70; +exports.sodales = __small$_71; +exports.tortor = __small$_64; +exports.risus = __small$_72; +exports.hendrerit = __small$_73; +exports.tristique = __small$_74; +exports.vel = __small$_75; +exports.non = __small$_76; +exports.mattis = __small$_61; +exports.dolor = __small$_53; +exports.nisi = __small$_42; + +return exports; +})()); +exports.volutpat = (__small$_28 = (function() { +var exports = {}; +exports.lorem = __small$_38; +exports.mi = __small$_39; +exports.pellentesque = __small$_40; +exports.egestas = __small$_41; +exports.pulvinar = __small$_20; +exports.at = __small$_8; +exports.nisi = __small$_42; +exports.nec = __small$_43; +exports.diam = __small$_44; +exports.sit = __small$_37; +exports.ipsum = __small$_45; +exports.porta = __small$_46; +exports.suscipit = __small$_47; +exports.et = __small$_48; +exports.viverra = __small$_49; +exports.ultrices = __small$_51; +exports.at = __small$_8; +exports.vehicula = __small$_16; +exports.dui = __small$_52; +exports.nibh = __small$_60; +exports.mattis = __small$_61; +exports.imperdiet = __small$_62; +exports.integer = __small$_63; +exports.varius = __small$_36; +exports.in = __small$_5; + +return exports; +})()); +exports.ac = __small$_21; +exports.venenatis = (__small$_29 = (function() { +var exports = {}; +exports.lorem = __small$_38; +exports.mi = __small$_39; +exports.pellentesque = __small$_40; +exports.egestas = __small$_41; +exports.pulvinar = __small$_20; +exports.at = __small$_8; +exports.nisi = __small$_42; +exports.nec = __small$_43; +exports.diam = __small$_44; +exports.sit = __small$_37; +exports.ipsum = __small$_45; +exports.porta = __small$_46; +exports.suscipit = __small$_47; +exports.et = __small$_48; +exports.viverra = __small$_49; +exports.ultrices = __small$_51; +exports.at = __small$_8; +exports.vehicula = __small$_16; +exports.dui = __small$_52; +exports.nibh = __small$_60; +exports.mattis = __small$_61; +exports.imperdiet = __small$_62; +exports.integer = __small$_63; +exports.varius = __small$_36; +exports.in = __small$_5; +exports.auctor = __small$_77; +exports.urna = __small$_10; + +return exports; +})()); +exports.justo = __small$_15; +exports.quam = (__small$_30 = (function() { +var exports = {}; +exports.lorem = __small$_38; +exports.mi = __small$_39; +exports.pellentesque = __small$_40; +exports.egestas = __small$_41; +exports.pulvinar = __small$_20; +exports.at = __small$_8; +exports.nisi = __small$_42; +exports.nec = __small$_43; +exports.diam = __small$_44; +exports.sit = __small$_37; +exports.ipsum = __small$_45; +exports.porta = __small$_46; +exports.suscipit = __small$_47; +exports.et = __small$_48; +exports.viverra = __small$_49; +exports.ultrices = __small$_51; +exports.at = __small$_8; +exports.vehicula = __small$_16; +exports.dui = __small$_52; +exports.nibh = __small$_60; +exports.mattis = __small$_61; +exports.imperdiet = __small$_62; +exports.integer = __small$_63; +exports.varius = __small$_36; +exports.in = __small$_5; +exports.auctor = __small$_77; +exports.urna = __small$_10; +exports.auctor = __small$_77; +exports.ante = __small$_78; +exports.sed = __small$_35; + +return exports; +})()); +exports.quis = (__small$_31 = (function() { +var exports = {}; +exports = { + dolor: __small$_53, + elit: __small$_54, + rutrum: __small$_55, + interdum: __small$_56, + mollis: __small$_57, + etiam: __small$_58, + nunc: __small$_17, + ornare: __small$_59, + eros: __small$_79, + nulla: __small$_80, + pulvinar: __small$_20, + aliquet: __small$_26, + ligula: __small$_81, + ullamcorper: __small$_82, + amet: __small$_1, + vulputate: __small$_7, + lorem: __small$_38, + libero: __small$_83, + tincidunt: __small$_84, + felis: __small$_85, + nisi: __small$_42, + sed: __small$_35, + felis: __small$_85, + ligula: __small$_81, + vulputate: __small$_7, + nam: __small$_25, + viverra: __small$_49, + metus: __small$_27, + tellus: __small$_86 +}; +return exports; +})()); +exports.augue = (__small$_32 = (function() { +var exports = {}; +exports = { + lorem: __small$_38, + mi: __small$_39, + pellentesque: __small$_40, + egestas: __small$_41, + pulvinar: __small$_20, + at: __small$_8, + nisi: __small$_42, + nec: __small$_43, + diam: __small$_44, + sit: __small$_37, + ipsum: __small$_45, + porta: __small$_46, + suscipit: __small$_47, + et: __small$_48, + viverra: __small$_49, + ultrices: __small$_51, + at: __small$_8, + vehicula: __small$_16, + dui: __small$_52, + nibh: __small$_60, + mattis: __small$_61, + imperdiet: __small$_62, + integer: __small$_63, + varius: __small$_36, + in: __small$_5, + auctor: __small$_77, + urna: __small$_10, + auctor: __small$_77, + ante: __small$_78, + sed: __small$_35, + sed: __small$_35 +}; +return exports; +})()); +exports.euismod = (__small$_33 = (function() { +var exports = {}; +exports.lorem = __small$_38; +exports.mi = __small$_39; +exports.pellentesque = __small$_40; +exports.egestas = __small$_41; +exports.pulvinar = __small$_20; +exports.at = __small$_8; +exports.nisi = __small$_42; +exports.nec = __small$_43; +exports.diam = __small$_44; +exports.sit = __small$_37; +exports.ipsum = __small$_45; +exports.porta = __small$_46; +exports.suscipit = __small$_47; +exports.et = __small$_48; +exports.viverra = __small$_49; +exports.ultrices = __small$_51; +exports.at = __small$_8; +exports.vehicula = __small$_16; +exports.dui = __small$_52; +exports.nibh = __small$_60; +exports.mattis = __small$_61; +exports.imperdiet = __small$_62; +exports.integer = __small$_63; +exports.varius = __small$_36; +exports.in = __small$_5; +exports.auctor = __small$_77; +exports.urna = __small$_10; +exports.auctor = __small$_77; +exports.ante = __small$_78; +exports.sed = __small$_35; +exports.sed = __small$_35; + +return exports; +})()); +exports.nunc = __small$_17; +exports.molestie = ((function() { +var exports = {}; +var __small$_93 = (function() { +var exports = {}; +exports.ipsum = __small$_45; +exports.sit = __small$_37; +exports.nullam = __small$_50; +exports.odio = __small$_23; +exports.tortor = __small$_64; +exports.ac = __small$_21; +exports.nullam = __small$_50; +exports.pellentesque = __small$_40; +exports.cursus = __small$_65; +exports.cras = __small$_66; +exports.semper = __small$_67; +exports.malesuada = __small$_68; +exports.elementum = __small$_69; +exports.pretium = __small$_70; +exports.sodales = __small$_71; +exports.tortor = __small$_64; +exports.risus = __small$_72; +exports.hendrerit = __small$_73; +exports.tristique = __small$_74; +exports.vel = __small$_75; +exports.non = __small$_76; +exports.mattis = __small$_61; +exports.dolor = __small$_53; +exports.nisi = __small$_42; +exports.quis = __small$_31; +exports.mi = __small$_39; + +return exports; +})(); +var __small$_91 = (function() { +var exports = {}; +exports.dolor = __small$_53; +exports.elit = __small$_54; +exports.rutrum = __small$_55; +exports.interdum = __small$_56; +exports.mollis = __small$_57; +exports.etiam = __small$_58; +exports.nunc = __small$_17; +exports.ornare = __small$_59; +exports.eros = __small$_79; +exports.nulla = __small$_80; +exports.pulvinar = __small$_20; +exports.aliquet = __small$_26; +exports.ligula = __small$_81; +exports.ullamcorper = __small$_82; +exports.amet = __small$_1; +exports.vulputate = __small$_7; +exports.lorem = __small$_38; +exports.libero = __small$_83; +exports.tincidunt = __small$_84; +exports.felis = __small$_85; +exports.nisi = __small$_42; +exports.sed = __small$_35; +exports.felis = __small$_85; +exports.ligula = __small$_81; +exports.vulputate = __small$_7; +exports.nam = __small$_25; +exports.viverra = __small$_49; +exports.metus = __small$_27; +exports.tellus = __small$_86; +exports.lectus = __small$_93; +exports.urna = __small$_10; + +return exports; +})(); +var __small$_94 = (function() { +var exports = {}; +exports.ipsum = __small$_45; +exports.sit = __small$_37; +exports.nullam = __small$_50; +exports.odio = __small$_23; +exports.tortor = __small$_64; +exports.ac = __small$_21; +exports.nullam = __small$_50; +exports.pellentesque = __small$_40; +exports.cursus = __small$_65; +exports.cras = __small$_66; +exports.semper = __small$_67; +exports.malesuada = __small$_68; +exports.elementum = __small$_69; +exports.pretium = __small$_70; +exports.sodales = __small$_71; +exports.tortor = __small$_64; +exports.risus = __small$_72; +exports.hendrerit = __small$_73; +exports.tristique = __small$_74; +exports.vel = __small$_75; +exports.non = __small$_76; +exports.mattis = __small$_61; +exports.dolor = __small$_53; +exports.nisi = __small$_42; +exports.quis = __small$_31; +exports.mi = __small$_39; +exports.mauris = __small$_91; + +return exports; +})(); +var __small$_95 = (function() { +var exports = {}; +exports.ipsum = __small$_45; +exports.sit = __small$_37; +exports.nullam = __small$_50; +exports.odio = __small$_23; +exports.tortor = __small$_64; +exports.ac = __small$_21; +exports.nullam = __small$_50; +exports.pellentesque = __small$_40; +exports.cursus = __small$_65; +exports.cras = __small$_66; +exports.semper = __small$_67; +exports.malesuada = __small$_68; +exports.elementum = __small$_69; +exports.pretium = __small$_70; +exports.sodales = __small$_71; +exports.tortor = __small$_64; +exports.risus = __small$_72; +exports.hendrerit = __small$_73; +exports.tristique = __small$_74; +exports.vel = __small$_75; +exports.non = __small$_76; +exports.mattis = __small$_61; +exports.dolor = __small$_53; +exports.nisi = __small$_42; +exports.quis = __small$_31; +exports.mi = __small$_39; +exports.mauris = __small$_91; +exports.in = __small$_5; + +return exports; +})(); +var __small$_96 = (function() { +var exports = {}; +exports.ipsum = __small$_45; +exports.sit = __small$_37; +exports.nullam = __small$_50; +exports.odio = __small$_23; +exports.tortor = __small$_64; +exports.ac = __small$_21; +exports.nullam = __small$_50; +exports.pellentesque = __small$_40; +exports.cursus = __small$_65; +exports.cras = __small$_66; +exports.semper = __small$_67; +exports.malesuada = __small$_68; +exports.elementum = __small$_69; +exports.pretium = __small$_70; +exports.sodales = __small$_71; +exports.tortor = __small$_64; +exports.risus = __small$_72; +exports.hendrerit = __small$_73; +exports.tristique = __small$_74; +exports.vel = __small$_75; +exports.non = __small$_76; +exports.mattis = __small$_61; +exports.dolor = __small$_53; +exports.nisi = __small$_42; +exports.quis = __small$_31; +exports.mi = __small$_39; +exports.mauris = __small$_91; +exports.in = __small$_5; + +return exports; +})(); +exports.lorem = __small$_38; +exports.mi = __small$_39; +exports.pellentesque = __small$_40; +exports.egestas = __small$_41; +exports.pulvinar = __small$_20; +exports.at = __small$_8; +exports.nisi = __small$_42; +exports.nec = __small$_43; +exports.diam = __small$_44; +exports.sit = __small$_37; +exports.ipsum = __small$_45; +exports.porta = __small$_46; +exports.suscipit = __small$_47; +exports.et = __small$_48; +exports.viverra = __small$_49; +exports.ultrices = __small$_51; +exports.at = __small$_8; +exports.vehicula = __small$_16; +exports.dui = __small$_52; +exports.nibh = __small$_60; +exports.mattis = __small$_61; +exports.imperdiet = __small$_62; +exports.integer = __small$_63; +exports.varius = __small$_36; +exports.in = __small$_5; +exports.auctor = __small$_77; +exports.urna = __small$_10; +exports.auctor = __small$_77; +exports.ante = __small$_78; +exports.sed = __small$_35; +exports.sed = __small$_35; +exports.aliquam = ((function() { +var exports = {}; +exports.amet = __small$_1; +exports.consectetur = __small$_2; +exports.adipiscing = __small$_3; +exports.lobortis = __small$_4; +exports.in = __small$_5; +exports.scelerisque = __small$_6; +exports.vulputate = __small$_7; +exports.at = __small$_8; +exports.facilisis = __small$_9; +exports.urna = __small$_10; +exports.donec = __small$_11; +exports.morbi = __small$_12; +exports.eleifend = __small$_13; +exports.quisque = __small$_14; +exports.justo = __small$_15; +exports.vehicula = __small$_16; +exports.nunc = __small$_17; +exports.pharetra = __small$_18; +exports.lacus = __small$_19; +exports.pulvinar = __small$_20; +exports.ac = __small$_21; +exports.at = __small$_8; +exports.aenean = __small$_22; +exports.odio = __small$_23; +exports.ac = __small$_21; +exports.erat = __small$_24; +exports.nam = __small$_25; +exports.justo = __small$_15; +exports.aliquet = __small$_26; +exports.scelerisque = __small$_6; +exports.metus = __small$_27; +exports.volutpat = __small$_28; +exports.ac = __small$_21; +exports.venenatis = __small$_29; +exports.justo = __small$_15; +exports.quam = __small$_30; +exports.quis = __small$_31; +exports.augue = __small$_32; +exports.euismod = __small$_33; + +return exports; +})()); +exports.lacus = __small$_19; +exports.tempor = ((function() { +var exports = {}; +exports.amet = __small$_1; +exports.consectetur = __small$_2; +exports.adipiscing = __small$_3; +exports.lobortis = __small$_4; +exports.in = __small$_5; +exports.scelerisque = __small$_6; +exports.vulputate = __small$_7; +exports.at = __small$_8; +exports.facilisis = __small$_9; +exports.urna = __small$_10; +exports.donec = __small$_11; +exports.morbi = __small$_12; +exports.eleifend = __small$_13; +exports.quisque = __small$_14; +exports.justo = __small$_15; +exports.vehicula = __small$_16; +exports.nunc = __small$_17; +exports.pharetra = __small$_18; +exports.lacus = __small$_19; +exports.pulvinar = __small$_20; +exports.ac = __small$_21; +exports.at = __small$_8; +exports.aenean = __small$_22; +exports.odio = __small$_23; +exports.ac = __small$_21; +exports.erat = __small$_24; +exports.nam = __small$_25; +exports.justo = __small$_15; +exports.aliquet = __small$_26; +exports.scelerisque = __small$_6; +exports.metus = __small$_27; +exports.volutpat = __small$_28; +exports.ac = __small$_21; +exports.venenatis = __small$_29; +exports.justo = __small$_15; +exports.quam = __small$_30; +exports.quis = __small$_31; +exports.augue = __small$_32; +exports.euismod = __small$_33; + +return exports; +})()); +exports.interdum = __small$_56; +exports.id = ((function() { +var exports = {}; +exports = { + ipsum: __small$_45, + sit: __small$_37, + nullam: __small$_50, + odio: __small$_23, + tortor: __small$_64, + ac: __small$_21, + nullam: __small$_50, + pellentesque: __small$_40, + cursus: __small$_65, + cras: __small$_66, + semper: __small$_67, + malesuada: __small$_68, + elementum: __small$_69, + pretium: __small$_70, + sodales: __small$_71, + tortor: __small$_64, + risus: __small$_72, + hendrerit: __small$_73, + tristique: __small$_74, + vel: __small$_75, + non: __small$_76, + mattis: __small$_61, + dolor: __small$_53, + nisi: __small$_42, + quis: __small$_31, + mi: __small$_39, + mauris: __small$_91, + in: __small$_5, + porttitor: __small$_90, + commodo: ((function() { +var exports = {}; +exports.dolor = __small$_53; +exports.elit = __small$_54; +exports.rutrum = __small$_55; +exports.interdum = __small$_56; +exports.mollis = __small$_57; +exports.etiam = __small$_58; +exports.nunc = __small$_17; +exports.ornare = __small$_59; +exports.eros = __small$_79; +exports.nulla = __small$_80; +exports.pulvinar = __small$_20; +exports.aliquet = __small$_26; +exports.ligula = __small$_81; +exports.ullamcorper = __small$_82; +exports.amet = __small$_1; +exports.vulputate = __small$_7; +exports.lorem = __small$_38; +exports.libero = __small$_83; +exports.tincidunt = __small$_84; +exports.felis = __small$_85; +exports.nisi = __small$_42; +exports.sed = __small$_35; +exports.felis = __small$_85; +exports.ligula = __small$_81; +exports.vulputate = __small$_7; +exports.nam = __small$_25; +exports.viverra = __small$_49; +exports.metus = __small$_27; +exports.tellus = __small$_86; +exports.lectus = __small$_93; +exports.urna = __small$_10; +exports.neque = __small$_94; +exports.mauris = __small$_91; +exports.a = __small$_95; +exports.posuere = __small$_96; + +return exports; +})()), + vel: __small$_75, + porta: __small$_46, + vel: __small$_75 +}; +return exports; +})()); +exports.porttitor = (__small$_90 = (function() { +var exports = {}; +exports.dolor = __small$_53; +exports.elit = __small$_54; +exports.rutrum = __small$_55; +exports.interdum = __small$_56; +exports.mollis = __small$_57; +exports.etiam = __small$_58; +exports.nunc = __small$_17; +exports.ornare = __small$_59; +exports.eros = __small$_79; +exports.nulla = __small$_80; +exports.pulvinar = __small$_20; +exports.aliquet = __small$_26; +exports.ligula = __small$_81; +exports.ullamcorper = __small$_82; +exports.amet = __small$_1; +exports.vulputate = __small$_7; +exports.lorem = __small$_38; +exports.libero = __small$_83; +exports.tincidunt = __small$_84; +exports.felis = __small$_85; +exports.nisi = __small$_42; +exports.sed = __small$_35; +exports.felis = __small$_85; +exports.ligula = __small$_81; +exports.vulputate = __small$_7; +exports.nam = __small$_25; +exports.viverra = __small$_49; +exports.metus = __small$_27; +exports.tellus = __small$_86; +exports.lectus = __small$_93; +exports.urna = __small$_10; +exports.neque = __small$_94; +exports.mauris = __small$_91; +exports.a = __small$_95; +exports.posuere = __small$_96; + +return exports; +})()); +exports.eros = __small$_79; + +return exports; +})()); +exports.sed = (__small$_35 = (function() { +var exports = {}; +exports = { + ipsum: __small$_45, + sit: __small$_37, + nullam: __small$_50, + odio: __small$_23, + tortor: __small$_64, + ac: __small$_21, + nullam: __small$_50, + pellentesque: __small$_40, + cursus: __small$_65, + cras: __small$_66, + semper: __small$_67, + malesuada: __small$_68, + elementum: __small$_69, + pretium: __small$_70, + sodales: __small$_71, + tortor: __small$_64, + risus: __small$_72 +}; +return exports; +})()); +exports.varius = (__small$_36 = (function() { +var exports = {}; +exports = { + amet: __small$_1, + consectetur: __small$_2, + adipiscing: __small$_3, + lobortis: __small$_4, + in: __small$_5, + scelerisque: __small$_6, + vulputate: __small$_7, + at: __small$_8, + facilisis: __small$_9, + urna: __small$_10, + donec: __small$_11, + morbi: __small$_12, + eleifend: __small$_13, + quisque: __small$_14, + justo: __small$_15, + vehicula: __small$_16, + nunc: __small$_17, + pharetra: __small$_18, + lacus: __small$_19, + pulvinar: __small$_20, + ac: __small$_21, + at: __small$_8, + aenean: __small$_22, + odio: __small$_23, + ac: __small$_21 +}; +return exports; +})()); +exports.sit = (__small$_37 = (function() { +var exports = {}; +exports.dolor = __small$_53; + +return exports; +})()); + +return exports; +})) diff --git a/examples/big/pellentesque.js b/examples/big/pellentesque.js new file mode 100644 index 0000000..cccf5be --- /dev/null +++ b/examples/big/pellentesque.js @@ -0,0 +1,5 @@ +exports.amet = require('./amet'); +exports.consectetur = require('./consectetur'); +exports.adipiscing = require('./adipiscing'); +exports.lobortis = require('./lobortis'); +exports.in = require('./in'); diff --git a/examples/big/pharetra.js b/examples/big/pharetra.js new file mode 100644 index 0000000..5780f03 --- /dev/null +++ b/examples/big/pharetra.js @@ -0,0 +1,17 @@ +this.lorem = require('./lorem'); +this.mi = require('./mi'); +this.pellentesque = require('./pellentesque'); +this.egestas = require('./egestas'); +this.pulvinar = require('./pulvinar'); +this.at = require('./at'); +this.nisi = require('./nisi'); +this.nec = require('./nec'); +this.diam = require('./diam'); +this.sit = require('./sit'); +this.ipsum = require('./ipsum'); +this.porta = require('./porta'); +this.suscipit = require('./suscipit'); +this.et = require('./et'); +this.viverra = require('./viverra'); +this.ultrices = require('./ultrices'); +this.at = require('./at'); diff --git a/examples/big/porta.js b/examples/big/porta.js new file mode 100644 index 0000000..15d932b --- /dev/null +++ b/examples/big/porta.js @@ -0,0 +1,12 @@ +exports.amet = require('./amet'); +exports.consectetur = require('./consectetur'); +exports.adipiscing = require('./adipiscing'); +exports.lobortis = require('./lobortis'); +exports.in = require('./in'); +exports.scelerisque = require('./scelerisque'); +exports.vulputate = require('./vulputate'); +exports.at = require('./at'); +exports.facilisis = require('./facilisis'); +exports.urna = require('./urna'); +exports.donec = require('./donec'); +exports.morbi = require('./morbi'); diff --git a/examples/big/porttitor.js b/examples/big/porttitor.js new file mode 100644 index 0000000..253dd9b --- /dev/null +++ b/examples/big/porttitor.js @@ -0,0 +1,35 @@ +module.exports.dolor = require('./dolor'); +module.exports.elit = require('./elit'); +module.exports.rutrum = require('./rutrum'); +module.exports.interdum = require('./interdum'); +module.exports.mollis = require('./mollis'); +module.exports.etiam = require('./etiam'); +module.exports.nunc = require('./nunc'); +module.exports.ornare = require('./ornare'); +module.exports.eros = require('./eros'); +module.exports.nulla = require('./nulla'); +module.exports.pulvinar = require('./pulvinar'); +module.exports.aliquet = require('./aliquet'); +module.exports.ligula = require('./ligula'); +module.exports.ullamcorper = require('./ullamcorper'); +module.exports.amet = require('./amet'); +module.exports.vulputate = require('./vulputate'); +module.exports.lorem = require('./lorem'); +module.exports.libero = require('./libero'); +module.exports.tincidunt = require('./tincidunt'); +module.exports.felis = require('./felis'); +module.exports.nisi = require('./nisi'); +module.exports.sed = require('./sed'); +module.exports.felis = require('./felis'); +module.exports.ligula = require('./ligula'); +module.exports.vulputate = require('./vulputate'); +module.exports.nam = require('./nam'); +module.exports.viverra = require('./viverra'); +module.exports.metus = require('./metus'); +module.exports.tellus = require('./tellus'); +module.exports.lectus = require('./lectus'); +module.exports.urna = require('./urna'); +module.exports.neque = require('./neque'); +module.exports.mauris = require('./mauris'); +module.exports.a = require('./a'); +module.exports.posuere = require('./posuere'); diff --git a/examples/big/posuere.js b/examples/big/posuere.js new file mode 100644 index 0000000..5eef104 --- /dev/null +++ b/examples/big/posuere.js @@ -0,0 +1,28 @@ +module.exports.ipsum = require('./ipsum'); +module.exports.sit = require('./sit'); +module.exports.nullam = require('./nullam'); +module.exports.odio = require('./odio'); +module.exports.tortor = require('./tortor'); +module.exports.ac = require('./ac'); +module.exports.nullam = require('./nullam'); +module.exports.pellentesque = require('./pellentesque'); +module.exports.cursus = require('./cursus'); +module.exports.cras = require('./cras'); +module.exports.semper = require('./semper'); +module.exports.malesuada = require('./malesuada'); +module.exports.elementum = require('./elementum'); +module.exports.pretium = require('./pretium'); +module.exports.sodales = require('./sodales'); +module.exports.tortor = require('./tortor'); +module.exports.risus = require('./risus'); +module.exports.hendrerit = require('./hendrerit'); +module.exports.tristique = require('./tristique'); +module.exports.vel = require('./vel'); +module.exports.non = require('./non'); +module.exports.mattis = require('./mattis'); +module.exports.dolor = require('./dolor'); +module.exports.nisi = require('./nisi'); +module.exports.quis = require('./quis'); +module.exports.mi = require('./mi'); +module.exports.mauris = require('./mauris'); +module.exports.in = require('./in'); diff --git a/examples/big/pretium.js b/examples/big/pretium.js new file mode 100644 index 0000000..54b0f2b --- /dev/null +++ b/examples/big/pretium.js @@ -0,0 +1,19 @@ +this.dolor = require('./dolor'); +this.elit = require('./elit'); +this.rutrum = require('./rutrum'); +this.interdum = require('./interdum'); +this.mollis = require('./mollis'); +this.etiam = require('./etiam'); +this.nunc = require('./nunc'); +this.ornare = require('./ornare'); +this.eros = require('./eros'); +this.nulla = require('./nulla'); +this.pulvinar = require('./pulvinar'); +this.aliquet = require('./aliquet'); +this.ligula = require('./ligula'); +this.ullamcorper = require('./ullamcorper'); +this.amet = require('./amet'); +this.vulputate = require('./vulputate'); +this.lorem = require('./lorem'); +this.libero = require('./libero'); +this.tincidunt = require('./tincidunt'); diff --git a/examples/big/pulvinar.js b/examples/big/pulvinar.js new file mode 100644 index 0000000..c671406 --- /dev/null +++ b/examples/big/pulvinar.js @@ -0,0 +1,7 @@ +module.exports = { + amet: require('./amet'), + consectetur: require('./consectetur'), + adipiscing: require('./adipiscing'), + lobortis: require('./lobortis'), + in: require('./in') +}; diff --git a/examples/big/quam.js b/examples/big/quam.js new file mode 100644 index 0000000..9dfcdc8 --- /dev/null +++ b/examples/big/quam.js @@ -0,0 +1,30 @@ +this.lorem = require('./lorem'); +this.mi = require('./mi'); +this.pellentesque = require('./pellentesque'); +this.egestas = require('./egestas'); +this.pulvinar = require('./pulvinar'); +this.at = require('./at'); +this.nisi = require('./nisi'); +this.nec = require('./nec'); +this.diam = require('./diam'); +this.sit = require('./sit'); +this.ipsum = require('./ipsum'); +this.porta = require('./porta'); +this.suscipit = require('./suscipit'); +this.et = require('./et'); +this.viverra = require('./viverra'); +this.ultrices = require('./ultrices'); +this.at = require('./at'); +this.vehicula = require('./vehicula'); +this.dui = require('./dui'); +this.nibh = require('./nibh'); +this.mattis = require('./mattis'); +this.imperdiet = require('./imperdiet'); +this.integer = require('./integer'); +this.varius = require('./varius'); +this.in = require('./in'); +this.auctor = require('./auctor'); +this.urna = require('./urna'); +this.auctor = require('./auctor'); +this.ante = require('./ante'); +this.sed = require('./sed'); diff --git a/examples/big/quis.js b/examples/big/quis.js new file mode 100644 index 0000000..1f4cef9 --- /dev/null +++ b/examples/big/quis.js @@ -0,0 +1,31 @@ +module.exports = { + dolor: require('./dolor'), + elit: require('./elit'), + rutrum: require('./rutrum'), + interdum: require('./interdum'), + mollis: require('./mollis'), + etiam: require('./etiam'), + nunc: require('./nunc'), + ornare: require('./ornare'), + eros: require('./eros'), + nulla: require('./nulla'), + pulvinar: require('./pulvinar'), + aliquet: require('./aliquet'), + ligula: require('./ligula'), + ullamcorper: require('./ullamcorper'), + amet: require('./amet'), + vulputate: require('./vulputate'), + lorem: require('./lorem'), + libero: require('./libero'), + tincidunt: require('./tincidunt'), + felis: require('./felis'), + nisi: require('./nisi'), + sed: require('./sed'), + felis: require('./felis'), + ligula: require('./ligula'), + vulputate: require('./vulputate'), + nam: require('./nam'), + viverra: require('./viverra'), + metus: require('./metus'), + tellus: require('./tellus') +}; diff --git a/examples/big/quisque.js b/examples/big/quisque.js new file mode 100644 index 0000000..ee60be8 --- /dev/null +++ b/examples/big/quisque.js @@ -0,0 +1,14 @@ +exports.lorem = require('./lorem'); +exports.mi = require('./mi'); +exports.pellentesque = require('./pellentesque'); +exports.egestas = require('./egestas'); +exports.pulvinar = require('./pulvinar'); +exports.at = require('./at'); +exports.nisi = require('./nisi'); +exports.nec = require('./nec'); +exports.diam = require('./diam'); +exports.sit = require('./sit'); +exports.ipsum = require('./ipsum'); +exports.porta = require('./porta'); +exports.suscipit = require('./suscipit'); +exports.et = require('./et'); diff --git a/examples/big/rhoncus.js b/examples/big/rhoncus.js new file mode 100644 index 0000000..4b8b3a1 --- /dev/null +++ b/examples/big/rhoncus.js @@ -0,0 +1,44 @@ +exports.amet = require('./amet'); +exports.consectetur = require('./consectetur'); +exports.adipiscing = require('./adipiscing'); +exports.lobortis = require('./lobortis'); +exports.in = require('./in'); +exports.scelerisque = require('./scelerisque'); +exports.vulputate = require('./vulputate'); +exports.at = require('./at'); +exports.facilisis = require('./facilisis'); +exports.urna = require('./urna'); +exports.donec = require('./donec'); +exports.morbi = require('./morbi'); +exports.eleifend = require('./eleifend'); +exports.quisque = require('./quisque'); +exports.justo = require('./justo'); +exports.vehicula = require('./vehicula'); +exports.nunc = require('./nunc'); +exports.pharetra = require('./pharetra'); +exports.lacus = require('./lacus'); +exports.pulvinar = require('./pulvinar'); +exports.ac = require('./ac'); +exports.at = require('./at'); +exports.aenean = require('./aenean'); +exports.odio = require('./odio'); +exports.ac = require('./ac'); +exports.erat = require('./erat'); +exports.nam = require('./nam'); +exports.justo = require('./justo'); +exports.aliquet = require('./aliquet'); +exports.scelerisque = require('./scelerisque'); +exports.metus = require('./metus'); +exports.volutpat = require('./volutpat'); +exports.ac = require('./ac'); +exports.venenatis = require('./venenatis'); +exports.justo = require('./justo'); +exports.quam = require('./quam'); +exports.quis = require('./quis'); +exports.augue = require('./augue'); +exports.euismod = require('./euismod'); +exports.nunc = require('./nunc'); +exports.molestie = require('./molestie'); +exports.sed = require('./sed'); +exports.varius = require('./varius'); +exports.sit = require('./sit'); diff --git a/examples/big/risus.js b/examples/big/risus.js new file mode 100644 index 0000000..4c242b1 --- /dev/null +++ b/examples/big/risus.js @@ -0,0 +1,20 @@ +exports.dolor = require('./dolor'); +exports.elit = require('./elit'); +exports.rutrum = require('./rutrum'); +exports.interdum = require('./interdum'); +exports.mollis = require('./mollis'); +exports.etiam = require('./etiam'); +exports.nunc = require('./nunc'); +exports.ornare = require('./ornare'); +exports.eros = require('./eros'); +exports.nulla = require('./nulla'); +exports.pulvinar = require('./pulvinar'); +exports.aliquet = require('./aliquet'); +exports.ligula = require('./ligula'); +exports.ullamcorper = require('./ullamcorper'); +exports.amet = require('./amet'); +exports.vulputate = require('./vulputate'); +exports.lorem = require('./lorem'); +exports.libero = require('./libero'); +exports.tincidunt = require('./tincidunt'); +exports.felis = require('./felis'); diff --git a/examples/big/rutrum.js b/examples/big/rutrum.js new file mode 100644 index 0000000..4d78d5c --- /dev/null +++ b/examples/big/rutrum.js @@ -0,0 +1,3 @@ +module.exports.ipsum = require('./ipsum'); +module.exports.sit = require('./sit'); +module.exports.nullam = require('./nullam'); diff --git a/examples/big/scelerisque.js b/examples/big/scelerisque.js new file mode 100644 index 0000000..ac69581 --- /dev/null +++ b/examples/big/scelerisque.js @@ -0,0 +1,5 @@ +module.exports.lorem = require('./lorem'); +module.exports.mi = require('./mi'); +module.exports.pellentesque = require('./pellentesque'); +module.exports.egestas = require('./egestas'); +module.exports.pulvinar = require('./pulvinar'); diff --git a/examples/big/sed.js b/examples/big/sed.js new file mode 100644 index 0000000..eee0106 --- /dev/null +++ b/examples/big/sed.js @@ -0,0 +1,19 @@ +module.exports = { + ipsum: require('./ipsum'), + sit: require('./sit'), + nullam: require('./nullam'), + odio: require('./odio'), + tortor: require('./tortor'), + ac: require('./ac'), + nullam: require('./nullam'), + pellentesque: require('./pellentesque'), + cursus: require('./cursus'), + cras: require('./cras'), + semper: require('./semper'), + malesuada: require('./malesuada'), + elementum: require('./elementum'), + pretium: require('./pretium'), + sodales: require('./sodales'), + tortor: require('./tortor'), + risus: require('./risus') +}; diff --git a/examples/big/semper.js b/examples/big/semper.js new file mode 100644 index 0000000..41f50d6 --- /dev/null +++ b/examples/big/semper.js @@ -0,0 +1,12 @@ +exports.dolor = require('./dolor'); +exports.elit = require('./elit'); +exports.rutrum = require('./rutrum'); +exports.interdum = require('./interdum'); +exports.mollis = require('./mollis'); +exports.etiam = require('./etiam'); +exports.nunc = require('./nunc'); +exports.ornare = require('./ornare'); +exports.eros = require('./eros'); +exports.nulla = require('./nulla'); +exports.pulvinar = require('./pulvinar'); +exports.aliquet = require('./aliquet'); diff --git a/examples/big/sit.js b/examples/big/sit.js new file mode 100644 index 0000000..8145501 --- /dev/null +++ b/examples/big/sit.js @@ -0,0 +1 @@ +this.dolor = require('./dolor'); diff --git a/examples/big/sodales.js b/examples/big/sodales.js new file mode 100644 index 0000000..048a79a --- /dev/null +++ b/examples/big/sodales.js @@ -0,0 +1,22 @@ +module.exports = { + dolor: require('./dolor'), + elit: require('./elit'), + rutrum: require('./rutrum'), + interdum: require('./interdum'), + mollis: require('./mollis'), + etiam: require('./etiam'), + nunc: require('./nunc'), + ornare: require('./ornare'), + eros: require('./eros'), + nulla: require('./nulla'), + pulvinar: require('./pulvinar'), + aliquet: require('./aliquet'), + ligula: require('./ligula'), + ullamcorper: require('./ullamcorper'), + amet: require('./amet'), + vulputate: require('./vulputate'), + lorem: require('./lorem'), + libero: require('./libero'), + tincidunt: require('./tincidunt'), + felis: require('./felis') +}; diff --git a/examples/big/suscipit.js b/examples/big/suscipit.js new file mode 100644 index 0000000..9d3c749 --- /dev/null +++ b/examples/big/suscipit.js @@ -0,0 +1,12 @@ +this.amet = require('./amet'); +this.consectetur = require('./consectetur'); +this.adipiscing = require('./adipiscing'); +this.lobortis = require('./lobortis'); +this.in = require('./in'); +this.scelerisque = require('./scelerisque'); +this.vulputate = require('./vulputate'); +this.at = require('./at'); +this.facilisis = require('./facilisis'); +this.urna = require('./urna'); +this.donec = require('./donec'); +this.morbi = require('./morbi'); diff --git a/examples/big/tellus.js b/examples/big/tellus.js new file mode 100644 index 0000000..5b79057 --- /dev/null +++ b/examples/big/tellus.js @@ -0,0 +1,24 @@ +module.exports.ipsum = require('./ipsum'); +module.exports.sit = require('./sit'); +module.exports.nullam = require('./nullam'); +module.exports.odio = require('./odio'); +module.exports.tortor = require('./tortor'); +module.exports.ac = require('./ac'); +module.exports.nullam = require('./nullam'); +module.exports.pellentesque = require('./pellentesque'); +module.exports.cursus = require('./cursus'); +module.exports.cras = require('./cras'); +module.exports.semper = require('./semper'); +module.exports.malesuada = require('./malesuada'); +module.exports.elementum = require('./elementum'); +module.exports.pretium = require('./pretium'); +module.exports.sodales = require('./sodales'); +module.exports.tortor = require('./tortor'); +module.exports.risus = require('./risus'); +module.exports.hendrerit = require('./hendrerit'); +module.exports.tristique = require('./tristique'); +module.exports.vel = require('./vel'); +module.exports.non = require('./non'); +module.exports.mattis = require('./mattis'); +module.exports.dolor = require('./dolor'); +module.exports.nisi = require('./nisi'); diff --git a/examples/big/tempor.js b/examples/big/tempor.js new file mode 100644 index 0000000..10170bf --- /dev/null +++ b/examples/big/tempor.js @@ -0,0 +1,39 @@ +exports.amet = require('./amet'); +exports.consectetur = require('./consectetur'); +exports.adipiscing = require('./adipiscing'); +exports.lobortis = require('./lobortis'); +exports.in = require('./in'); +exports.scelerisque = require('./scelerisque'); +exports.vulputate = require('./vulputate'); +exports.at = require('./at'); +exports.facilisis = require('./facilisis'); +exports.urna = require('./urna'); +exports.donec = require('./donec'); +exports.morbi = require('./morbi'); +exports.eleifend = require('./eleifend'); +exports.quisque = require('./quisque'); +exports.justo = require('./justo'); +exports.vehicula = require('./vehicula'); +exports.nunc = require('./nunc'); +exports.pharetra = require('./pharetra'); +exports.lacus = require('./lacus'); +exports.pulvinar = require('./pulvinar'); +exports.ac = require('./ac'); +exports.at = require('./at'); +exports.aenean = require('./aenean'); +exports.odio = require('./odio'); +exports.ac = require('./ac'); +exports.erat = require('./erat'); +exports.nam = require('./nam'); +exports.justo = require('./justo'); +exports.aliquet = require('./aliquet'); +exports.scelerisque = require('./scelerisque'); +exports.metus = require('./metus'); +exports.volutpat = require('./volutpat'); +exports.ac = require('./ac'); +exports.venenatis = require('./venenatis'); +exports.justo = require('./justo'); +exports.quam = require('./quam'); +exports.quis = require('./quis'); +exports.augue = require('./augue'); +exports.euismod = require('./euismod'); diff --git a/examples/big/tincidunt.js b/examples/big/tincidunt.js new file mode 100644 index 0000000..7e30c20 --- /dev/null +++ b/examples/big/tincidunt.js @@ -0,0 +1,13 @@ +exports.ipsum = require('./ipsum'); +exports.sit = require('./sit'); +exports.nullam = require('./nullam'); +exports.odio = require('./odio'); +exports.tortor = require('./tortor'); +exports.ac = require('./ac'); +exports.nullam = require('./nullam'); +exports.pellentesque = require('./pellentesque'); +exports.cursus = require('./cursus'); +exports.cras = require('./cras'); +exports.semper = require('./semper'); +exports.malesuada = require('./malesuada'); +exports.elementum = require('./elementum'); diff --git a/examples/big/tortor.js b/examples/big/tortor.js new file mode 100644 index 0000000..9ccfac2 --- /dev/null +++ b/examples/big/tortor.js @@ -0,0 +1,7 @@ +exports.dolor = require('./dolor'); +exports.elit = require('./elit'); +exports.rutrum = require('./rutrum'); +exports.interdum = require('./interdum'); +exports.mollis = require('./mollis'); +exports.etiam = require('./etiam'); +exports.nunc = require('./nunc'); diff --git a/examples/big/tristique.js b/examples/big/tristique.js new file mode 100644 index 0000000..ff4a669 --- /dev/null +++ b/examples/big/tristique.js @@ -0,0 +1,25 @@ +module.exports = { + dolor: require('./dolor'), + elit: require('./elit'), + rutrum: require('./rutrum'), + interdum: require('./interdum'), + mollis: require('./mollis'), + etiam: require('./etiam'), + nunc: require('./nunc'), + ornare: require('./ornare'), + eros: require('./eros'), + nulla: require('./nulla'), + pulvinar: require('./pulvinar'), + aliquet: require('./aliquet'), + ligula: require('./ligula'), + ullamcorper: require('./ullamcorper'), + amet: require('./amet'), + vulputate: require('./vulputate'), + lorem: require('./lorem'), + libero: require('./libero'), + tincidunt: require('./tincidunt'), + felis: require('./felis'), + nisi: require('./nisi'), + sed: require('./sed'), + felis: require('./felis') +}; diff --git a/examples/big/turpis.js b/examples/big/turpis.js new file mode 100644 index 0000000..4b8b3a1 --- /dev/null +++ b/examples/big/turpis.js @@ -0,0 +1,44 @@ +exports.amet = require('./amet'); +exports.consectetur = require('./consectetur'); +exports.adipiscing = require('./adipiscing'); +exports.lobortis = require('./lobortis'); +exports.in = require('./in'); +exports.scelerisque = require('./scelerisque'); +exports.vulputate = require('./vulputate'); +exports.at = require('./at'); +exports.facilisis = require('./facilisis'); +exports.urna = require('./urna'); +exports.donec = require('./donec'); +exports.morbi = require('./morbi'); +exports.eleifend = require('./eleifend'); +exports.quisque = require('./quisque'); +exports.justo = require('./justo'); +exports.vehicula = require('./vehicula'); +exports.nunc = require('./nunc'); +exports.pharetra = require('./pharetra'); +exports.lacus = require('./lacus'); +exports.pulvinar = require('./pulvinar'); +exports.ac = require('./ac'); +exports.at = require('./at'); +exports.aenean = require('./aenean'); +exports.odio = require('./odio'); +exports.ac = require('./ac'); +exports.erat = require('./erat'); +exports.nam = require('./nam'); +exports.justo = require('./justo'); +exports.aliquet = require('./aliquet'); +exports.scelerisque = require('./scelerisque'); +exports.metus = require('./metus'); +exports.volutpat = require('./volutpat'); +exports.ac = require('./ac'); +exports.venenatis = require('./venenatis'); +exports.justo = require('./justo'); +exports.quam = require('./quam'); +exports.quis = require('./quis'); +exports.augue = require('./augue'); +exports.euismod = require('./euismod'); +exports.nunc = require('./nunc'); +exports.molestie = require('./molestie'); +exports.sed = require('./sed'); +exports.varius = require('./varius'); +exports.sit = require('./sit'); diff --git a/examples/big/ullamcorper.js b/examples/big/ullamcorper.js new file mode 100644 index 0000000..fa20d8d --- /dev/null +++ b/examples/big/ullamcorper.js @@ -0,0 +1,12 @@ +module.exports.ipsum = require('./ipsum'); +module.exports.sit = require('./sit'); +module.exports.nullam = require('./nullam'); +module.exports.odio = require('./odio'); +module.exports.tortor = require('./tortor'); +module.exports.ac = require('./ac'); +module.exports.nullam = require('./nullam'); +module.exports.pellentesque = require('./pellentesque'); +module.exports.cursus = require('./cursus'); +module.exports.cras = require('./cras'); +module.exports.semper = require('./semper'); +module.exports.malesuada = require('./malesuada'); diff --git a/examples/big/ultrices.js b/examples/big/ultrices.js new file mode 100644 index 0000000..613bf41 --- /dev/null +++ b/examples/big/ultrices.js @@ -0,0 +1,19 @@ +module.exports = { + amet: require('./amet'), + consectetur: require('./consectetur'), + adipiscing: require('./adipiscing'), + lobortis: require('./lobortis'), + in: require('./in'), + scelerisque: require('./scelerisque'), + vulputate: require('./vulputate'), + at: require('./at'), + facilisis: require('./facilisis'), + urna: require('./urna'), + donec: require('./donec'), + morbi: require('./morbi'), + eleifend: require('./eleifend'), + quisque: require('./quisque'), + justo: require('./justo'), + vehicula: require('./vehicula'), + nunc: require('./nunc') +}; diff --git a/examples/big/urna.js b/examples/big/urna.js new file mode 100644 index 0000000..622ba52 --- /dev/null +++ b/examples/big/urna.js @@ -0,0 +1,9 @@ +module.exports = { + lorem: require('./lorem'), + mi: require('./mi'), + pellentesque: require('./pellentesque'), + egestas: require('./egestas'), + pulvinar: require('./pulvinar'), + at: require('./at'), + nisi: require('./nisi') +}; diff --git a/examples/big/ut.js b/examples/big/ut.js new file mode 100644 index 0000000..253e474 --- /dev/null +++ b/examples/big/ut.js @@ -0,0 +1,47 @@ +module.exports = { + ipsum: require('./ipsum'), + sit: require('./sit'), + nullam: require('./nullam'), + odio: require('./odio'), + tortor: require('./tortor'), + ac: require('./ac'), + nullam: require('./nullam'), + pellentesque: require('./pellentesque'), + cursus: require('./cursus'), + cras: require('./cras'), + semper: require('./semper'), + malesuada: require('./malesuada'), + elementum: require('./elementum'), + pretium: require('./pretium'), + sodales: require('./sodales'), + tortor: require('./tortor'), + risus: require('./risus'), + hendrerit: require('./hendrerit'), + tristique: require('./tristique'), + vel: require('./vel'), + non: require('./non'), + mattis: require('./mattis'), + dolor: require('./dolor'), + nisi: require('./nisi'), + quis: require('./quis'), + mi: require('./mi'), + mauris: require('./mauris'), + in: require('./in'), + porttitor: require('./porttitor'), + commodo: require('./commodo'), + vel: require('./vel'), + porta: require('./porta'), + vel: require('./vel'), + quis: require('./quis'), + iaculis: require('./iaculis'), + a: require('./a'), + viverra: require('./viverra'), + egestas: require('./egestas'), + donec: require('./donec'), + pharetra: require('./pharetra'), + tortor: require('./tortor'), + adipiscing: require('./adipiscing'), + amet: require('./amet'), + et: require('./et'), + scelerisque: require('./scelerisque') +}; diff --git a/examples/big/varius.js b/examples/big/varius.js new file mode 100644 index 0000000..db2de4c --- /dev/null +++ b/examples/big/varius.js @@ -0,0 +1,27 @@ +module.exports = { + amet: require('./amet'), + consectetur: require('./consectetur'), + adipiscing: require('./adipiscing'), + lobortis: require('./lobortis'), + in: require('./in'), + scelerisque: require('./scelerisque'), + vulputate: require('./vulputate'), + at: require('./at'), + facilisis: require('./facilisis'), + urna: require('./urna'), + donec: require('./donec'), + morbi: require('./morbi'), + eleifend: require('./eleifend'), + quisque: require('./quisque'), + justo: require('./justo'), + vehicula: require('./vehicula'), + nunc: require('./nunc'), + pharetra: require('./pharetra'), + lacus: require('./lacus'), + pulvinar: require('./pulvinar'), + ac: require('./ac'), + at: require('./at'), + aenean: require('./aenean'), + odio: require('./odio'), + ac: require('./ac') +}; diff --git a/examples/big/vehicula.js b/examples/big/vehicula.js new file mode 100644 index 0000000..4bd026b --- /dev/null +++ b/examples/big/vehicula.js @@ -0,0 +1,17 @@ +module.exports = { + lorem: require('./lorem'), + mi: require('./mi'), + pellentesque: require('./pellentesque'), + egestas: require('./egestas'), + pulvinar: require('./pulvinar'), + at: require('./at'), + nisi: require('./nisi'), + nec: require('./nec'), + diam: require('./diam'), + sit: require('./sit'), + ipsum: require('./ipsum'), + porta: require('./porta'), + suscipit: require('./suscipit'), + et: require('./et'), + viverra: require('./viverra') +}; diff --git a/examples/big/vel.js b/examples/big/vel.js new file mode 100644 index 0000000..687e4c9 --- /dev/null +++ b/examples/big/vel.js @@ -0,0 +1,23 @@ +exports.dolor = require('./dolor'); +exports.elit = require('./elit'); +exports.rutrum = require('./rutrum'); +exports.interdum = require('./interdum'); +exports.mollis = require('./mollis'); +exports.etiam = require('./etiam'); +exports.nunc = require('./nunc'); +exports.ornare = require('./ornare'); +exports.eros = require('./eros'); +exports.nulla = require('./nulla'); +exports.pulvinar = require('./pulvinar'); +exports.aliquet = require('./aliquet'); +exports.ligula = require('./ligula'); +exports.ullamcorper = require('./ullamcorper'); +exports.amet = require('./amet'); +exports.vulputate = require('./vulputate'); +exports.lorem = require('./lorem'); +exports.libero = require('./libero'); +exports.tincidunt = require('./tincidunt'); +exports.felis = require('./felis'); +exports.nisi = require('./nisi'); +exports.sed = require('./sed'); +exports.felis = require('./felis'); diff --git a/examples/big/velit.js b/examples/big/velit.js new file mode 100644 index 0000000..77441fa --- /dev/null +++ b/examples/big/velit.js @@ -0,0 +1,33 @@ +exports.ipsum = require('./ipsum'); +exports.sit = require('./sit'); +exports.nullam = require('./nullam'); +exports.odio = require('./odio'); +exports.tortor = require('./tortor'); +exports.ac = require('./ac'); +exports.nullam = require('./nullam'); +exports.pellentesque = require('./pellentesque'); +exports.cursus = require('./cursus'); +exports.cras = require('./cras'); +exports.semper = require('./semper'); +exports.malesuada = require('./malesuada'); +exports.elementum = require('./elementum'); +exports.pretium = require('./pretium'); +exports.sodales = require('./sodales'); +exports.tortor = require('./tortor'); +exports.risus = require('./risus'); +exports.hendrerit = require('./hendrerit'); +exports.tristique = require('./tristique'); +exports.vel = require('./vel'); +exports.non = require('./non'); +exports.mattis = require('./mattis'); +exports.dolor = require('./dolor'); +exports.nisi = require('./nisi'); +exports.quis = require('./quis'); +exports.mi = require('./mi'); +exports.mauris = require('./mauris'); +exports.in = require('./in'); +exports.porttitor = require('./porttitor'); +exports.commodo = require('./commodo'); +exports.vel = require('./vel'); +exports.porta = require('./porta'); +exports.vel = require('./vel'); diff --git a/examples/big/venenatis.js b/examples/big/venenatis.js new file mode 100644 index 0000000..8804cc7 --- /dev/null +++ b/examples/big/venenatis.js @@ -0,0 +1,27 @@ +module.exports.lorem = require('./lorem'); +module.exports.mi = require('./mi'); +module.exports.pellentesque = require('./pellentesque'); +module.exports.egestas = require('./egestas'); +module.exports.pulvinar = require('./pulvinar'); +module.exports.at = require('./at'); +module.exports.nisi = require('./nisi'); +module.exports.nec = require('./nec'); +module.exports.diam = require('./diam'); +module.exports.sit = require('./sit'); +module.exports.ipsum = require('./ipsum'); +module.exports.porta = require('./porta'); +module.exports.suscipit = require('./suscipit'); +module.exports.et = require('./et'); +module.exports.viverra = require('./viverra'); +module.exports.ultrices = require('./ultrices'); +module.exports.at = require('./at'); +module.exports.vehicula = require('./vehicula'); +module.exports.dui = require('./dui'); +module.exports.nibh = require('./nibh'); +module.exports.mattis = require('./mattis'); +module.exports.imperdiet = require('./imperdiet'); +module.exports.integer = require('./integer'); +module.exports.varius = require('./varius'); +module.exports.in = require('./in'); +module.exports.auctor = require('./auctor'); +module.exports.urna = require('./urna'); diff --git a/examples/big/vestibulum.js b/examples/big/vestibulum.js new file mode 100644 index 0000000..a13d5e8 --- /dev/null +++ b/examples/big/vestibulum.js @@ -0,0 +1,33 @@ +module.exports.ipsum = require('./ipsum'); +module.exports.sit = require('./sit'); +module.exports.nullam = require('./nullam'); +module.exports.odio = require('./odio'); +module.exports.tortor = require('./tortor'); +module.exports.ac = require('./ac'); +module.exports.nullam = require('./nullam'); +module.exports.pellentesque = require('./pellentesque'); +module.exports.cursus = require('./cursus'); +module.exports.cras = require('./cras'); +module.exports.semper = require('./semper'); +module.exports.malesuada = require('./malesuada'); +module.exports.elementum = require('./elementum'); +module.exports.pretium = require('./pretium'); +module.exports.sodales = require('./sodales'); +module.exports.tortor = require('./tortor'); +module.exports.risus = require('./risus'); +module.exports.hendrerit = require('./hendrerit'); +module.exports.tristique = require('./tristique'); +module.exports.vel = require('./vel'); +module.exports.non = require('./non'); +module.exports.mattis = require('./mattis'); +module.exports.dolor = require('./dolor'); +module.exports.nisi = require('./nisi'); +module.exports.quis = require('./quis'); +module.exports.mi = require('./mi'); +module.exports.mauris = require('./mauris'); +module.exports.in = require('./in'); +module.exports.porttitor = require('./porttitor'); +module.exports.commodo = require('./commodo'); +module.exports.vel = require('./vel'); +module.exports.porta = require('./porta'); +module.exports.vel = require('./vel'); diff --git a/examples/big/viverra.js b/examples/big/viverra.js new file mode 100644 index 0000000..6e9b79a --- /dev/null +++ b/examples/big/viverra.js @@ -0,0 +1,14 @@ +this.amet = require('./amet'); +this.consectetur = require('./consectetur'); +this.adipiscing = require('./adipiscing'); +this.lobortis = require('./lobortis'); +this.in = require('./in'); +this.scelerisque = require('./scelerisque'); +this.vulputate = require('./vulputate'); +this.at = require('./at'); +this.facilisis = require('./facilisis'); +this.urna = require('./urna'); +this.donec = require('./donec'); +this.morbi = require('./morbi'); +this.eleifend = require('./eleifend'); +this.quisque = require('./quisque'); diff --git a/examples/big/volutpat.js b/examples/big/volutpat.js new file mode 100644 index 0000000..5eeb109 --- /dev/null +++ b/examples/big/volutpat.js @@ -0,0 +1,25 @@ +this.lorem = require('./lorem'); +this.mi = require('./mi'); +this.pellentesque = require('./pellentesque'); +this.egestas = require('./egestas'); +this.pulvinar = require('./pulvinar'); +this.at = require('./at'); +this.nisi = require('./nisi'); +this.nec = require('./nec'); +this.diam = require('./diam'); +this.sit = require('./sit'); +this.ipsum = require('./ipsum'); +this.porta = require('./porta'); +this.suscipit = require('./suscipit'); +this.et = require('./et'); +this.viverra = require('./viverra'); +this.ultrices = require('./ultrices'); +this.at = require('./at'); +this.vehicula = require('./vehicula'); +this.dui = require('./dui'); +this.nibh = require('./nibh'); +this.mattis = require('./mattis'); +this.imperdiet = require('./imperdiet'); +this.integer = require('./integer'); +this.varius = require('./varius'); +this.in = require('./in'); diff --git a/examples/big/vulputate.js b/examples/big/vulputate.js new file mode 100644 index 0000000..622ba52 --- /dev/null +++ b/examples/big/vulputate.js @@ -0,0 +1,9 @@ +module.exports = { + lorem: require('./lorem'), + mi: require('./mi'), + pellentesque: require('./pellentesque'), + egestas: require('./egestas'), + pulvinar: require('./pulvinar'), + at: require('./at'), + nisi: require('./nisi') +}; diff --git a/examples/generateBig.js b/examples/generateBig.js new file mode 100644 index 0000000..dcb21dc --- /dev/null +++ b/examples/generateBig.js @@ -0,0 +1,60 @@ +var fs = require('fs'); +var path = require('path'); + +var names = 'Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nullam rutrum odio interdum lobortis mollis. Etiam nunc tortor, ornare in mi ac, pellentesque egestas eros. Nullam pulvinar nulla pulvinar aliquet scelerisque. Pellentesque at cursus nisi. Cras vulputate semper ligula, at facilisis urna malesuada nec. Donec ullamcorper diam sit amet ipsum elementum vulputate. Morbi porta suscipit lorem et eleifend. Quisque viverra justo vehicula libero tincidunt pretium. Nunc ultrices, felis at pharetra vehicula, dui lacus pulvinar nibh, ac sodales tortor risus at nisi. Sed hendrerit felis mattis imperdiet tristique. Aenean vel odio ligula. Integer non mattis dolor, ac varius erat. Nam vulputate justo. Nam aliquet, nisi in viverra scelerisque, metus metus volutpat tellus, quis auctor mi lectus ac urna. Mauris urna neque, venenatis in mauris a, auctor posuere ante. Sed justo quam, porttitor sed commodo quis, cursus a augue. Nam euismod nulla vel viverra porta. Aliquam vel lacus id velit tempor condimentum. Vestibulum quis eros gravida, interdum metus id, porttitor eros. Donec iaculis nunc a massa viverra molestie. Sed fringilla egestas velit. Donec pharetra ante tortor, in varius mi adipiscing sit amet. Nullam et tellus feugiat, scelerisque est ut, rhoncus turpis.'.toLowerCase().replace(/,|\./g, '').split(' '); + +for (var i = 0; i < names.length; ++i) { + var name = names[i]; + + if (names.indexOf(name) != i) continue; + + var source = ''; + + var requires = []; + + for (var j = 0; j < i; ++j) { + var other = names[j]; + if (name == other) continue; + + if ((i + j + name.length + other.length) % 4 == 1) { + requires.push(other); + } + } + + switch (i % 5) { + case 0: // module.exports = { } + source = 'module.exports = {\n'; + var sep = ''; + for (var j = 0; j < requires.length; ++j) { + source += sep + '\t' + requires[j] + ': require(\'./' + requires[j] + '\')'; + sep = ',\n'; + } + source += '\n};'; + break; + case 1: // exports. = + case 2: + source = ''; + for (var j = 0; j < requires.length; ++j) { + source += 'exports.' + requires[j] + ' = require(\'./' + requires[j] + '\');\n'; + } + break; + case 3: // this. = + source = ''; + for (var j = 0; j < requires.length; ++j) { + source += 'this.' + requires[j] + ' = require(\'./' + requires[j] + '\');\n'; + } + break; + case 4: // module.exports. = + source = ''; + for (var j = 0; j < requires.length; ++j) { + source += 'module.exports.' + requires[j] + ' = require(\'./' + requires[j] + '\');\n'; + } + break; + } + + fs.writeFile(path.join(__dirname, 'big', name + '.js'), source, {encoding:'utf8'}, function(error) { + if (error) { + throw error; + } + }); +} diff --git a/examples/simple/a.js b/examples/simple/a.js new file mode 100644 index 0000000..d67d9f3 --- /dev/null +++ b/examples/simple/a.js @@ -0,0 +1,18 @@ +var c = require('./c'); +var b = require('./b'); + +var c2 = require('./c'); + +function hallo() { + this.c = c; +} +var hoi = (function() { + this.c = c; +}); + +module.exports = c; +module.exports.b = b; + +if (b.c == c) { + console.log(c2); +} diff --git a/examples/simple/b.js b/examples/simple/b.js new file mode 100644 index 0000000..9068f39 --- /dev/null +++ b/examples/simple/b.js @@ -0,0 +1,6 @@ +var c = require('./c'); +var document = require('document'); + +document.title = c; + +this.c = c; diff --git a/examples/simple/c.js b/examples/simple/c.js new file mode 100644 index 0000000..de735c9 --- /dev/null +++ b/examples/simple/c.js @@ -0,0 +1,5 @@ +function a() { + this.b = true; +} + +module.exports = 'Hello, World'; diff --git a/examples/simple/index.html b/examples/simple/index.html new file mode 100644 index 0000000..bb478c0 --- /dev/null +++ b/examples/simple/index.html @@ -0,0 +1,11 @@ + + + + + Example + + + + + + diff --git a/examples/simple/output.amd.js b/examples/simple/output.amd.js new file mode 100644 index 0000000..47c179a --- /dev/null +++ b/examples/simple/output.amd.js @@ -0,0 +1,39 @@ +define(["document"], (function(__small$_mod_0) { +var exports = {}, __small$_moduleExports = exports; +var c = (__small$_1 = (function() { +var exports = {}; +function a() { + this.b = true; +} + +exports = 'Hello, World'; +return exports; +})()); +var b = ((function() { +var exports = {}; +var c = __small$_1; +var document = __small$_mod_0; + +document.title = c; + +exports.c = c; +return exports; +})()); + +var c2 = __small$_1; + +function hallo() { + this.c = c; +} +var hoi = (function() { + this.c = c; +}); + +__small$_moduleExports = c; +__small$_moduleExports.b = b; + +if (b.c == c) { + console.log(c2); +} +return __small$_moduleExports; +})); diff --git a/examples/simple/output.common.js b/examples/simple/output.common.js new file mode 100644 index 0000000..4f74412 --- /dev/null +++ b/examples/simple/output.common.js @@ -0,0 +1,39 @@ +module.exports = (function(__small$_mod_0) { +var exports = {}, __small$_moduleExports = exports; +var c = (__small$_1 = (function() { +var exports = {}; +function a() { + this.b = true; +} + +exports = 'Hello, World'; +return exports; +})()); +var b = ((function() { +var exports = {}; +var c = __small$_1; +var document = __small$_mod_0; + +document.title = c; + +exports.c = c; +return exports; +})()); + +var c2 = __small$_1; + +function hallo() { + this.c = c; +} +var hoi = (function() { + this.c = c; +}); + +__small$_moduleExports = c; +__small$_moduleExports.b = b; + +if (b.c == c) { + console.log(c2); +} +return __small$_moduleExports; +})(require("document")); diff --git a/examples/simple/output.standalone.js b/examples/simple/output.standalone.js new file mode 100644 index 0000000..896682c --- /dev/null +++ b/examples/simple/output.standalone.js @@ -0,0 +1,39 @@ +(function(__small$_mod_0) { +var exports = {}, __small$_moduleExports = exports; +var c = (__small$_1 = (function() { +var exports = {}; +function a() { + this.b = true; +} + +exports = 'Hello, World'; +return exports; +})()); +var b = ((function() { +var exports = {}; +var c = __small$_1; +var document = __small$_mod_0; + +document.title = c; + +exports.c = c; +return exports; +})()); + +var c2 = __small$_1; + +function hallo() { + this.c = c; +} +var hoi = (function() { + this.c = c; +}); + +__small$_moduleExports = c; +__small$_moduleExports.b = b; + +if (b.c == c) { + console.log(c2); +} +return __small$_moduleExports; +})(document); diff --git a/examples/simple/output.universal.js b/examples/simple/output.universal.js new file mode 100644 index 0000000..d847c45 --- /dev/null +++ b/examples/simple/output.universal.js @@ -0,0 +1,39 @@ +(function(__root, __factory) { if (typeof define === "function" && define.amd) { define("example", ["document"], __factory);} else if (typeof exports === "object") {module.exports = __factory(require("document"));} else {__root["example"] = __factory(document);}})(this, (function(__small$_mod_0) { +var exports = {}, __small$_moduleExports = exports; +var c = (__small$_1 = (function() { +var exports = {}; +function a() { + this.b = true; +} + +exports = 'Hello, World'; +return exports; +})()); +var b = ((function() { +var exports = {}; +var c = __small$_1; +var document = __small$_mod_0; + +document.title = c; + +exports.c = c; +return exports; +})()); + +var c2 = __small$_1; + +function hallo() { + this.c = c; +} +var hoi = (function() { + this.c = c; +}); + +__small$_moduleExports = c; +__small$_moduleExports.b = b; + +if (b.c == c) { + console.log(c2); +} +return __small$_moduleExports; +})) diff --git a/gulpfile.js b/gulpfile.js new file mode 100644 index 0000000..342df35 --- /dev/null +++ b/gulpfile.js @@ -0,0 +1,82 @@ +var gulp = require('gulp'); +var ts = require('gulp-type'); +var tslint = require('gulp-tslint'); +var rename = require('gulp-rename'); + +var tsProject = ts.createProject({ + noExternalResolve: true, + target: 'es5', + module: 'commonjs' +}); +var tslintConfig = require('./tslint.json'); + +var paths = { + lib: 'lib', + ref: 'definitions' +}; + +gulp.task('compile', function() { + var tsResult = + gulp.src([paths.lib + '/**.ts', paths.ref + '/**.ts']) + .pipe(ts(tsProject)); + + return tsResult.js.pipe(gulp.dest('release')); + + //tsResult.js.pipe(); +}); + +gulp.task('test-1', ['compile'], function() { + var lib = require('./release/index'); + + return gulp.src(['examples/simple/**.js']) + .pipe(lib.gulp('a.js', { + outputFileName: { + commonjs: 'output.common.js', + amd: 'output.amd.js', + standalone: 'output.standalone.js', + universal: 'output.universal.js' + }, + globalModules: { + 'document': { + universal: 'document' + } + }, + exportPackage: { + universal: 'example' + }, + externalResolve: [ + './node_modules' + ], + includeNode: true + })) + .pipe(gulp.dest('examples/simple')); +}); +gulp.task('test-2', ['compile'], function() { + var lib = require('./release/index'); + + return gulp.src(['examples/big/**.js']) + .pipe(lib.gulp('turpis.js', { + outputFileName: { + commonjs: 'output.common.js', + amd: 'output.amd.js', + standalone: 'output.standalone.js', + universal: 'output.universal.js' + } + })) + .pipe(gulp.dest('examples/big')); +}); +gulp.task('test', ['test-1', 'test-2']); + +gulp.task('lint', function() { + return gulp.src([paths.lib + '/**.ts']) + .pipe(tslint({ + configuration: tslintConfig + })) + .pipe(tslint.report('prose')); +}); + +gulp.task('watch', ['compile'], function() { + gulp.watch([paths.lib + '/**.ts', paths.ref + '/**.ts'], ['compile']); +}); + +gulp.task('default', ['compile']); diff --git a/lib/astWalker.ts b/lib/astWalker.ts new file mode 100644 index 0000000..2e5cc7f --- /dev/null +++ b/lib/astWalker.ts @@ -0,0 +1,271 @@ +/// + +import uglify = require('uglify-js'); +import file = require('./file'); +import exportNode = require('./exportNode'); +import importNode = require('./importNode'); + +export interface ExportsInfo { + style: exportNode.Style; + dotArray: string[]; + + exportAST: uglify.AST_Node; + ast: uglify.AST_Node; +} + +export function matchExportsAlias(node: uglify.AST_Node, isTopLevel: boolean): ExportsInfo { + // this + if (node instanceof uglify.AST_This && isTopLevel) { + return { + style: exportNode.Style.This, + dotArray: [], + exportAST: node, + ast: node + }; + } + + // exports + if (node instanceof uglify.AST_SymbolRef) { + var nodeVar = node; + if (nodeVar.thedef.name === 'exports' && nodeVar.thedef.undeclared) { + return { + style: exportNode.Style.Exports, + dotArray: [], + exportAST: nodeVar, + ast: nodeVar + }; + } + } + + if (node instanceof uglify.AST_PropAccess) { + var nodeAccess = node; + + // module.exports + if (nodeAccess.expression instanceof uglify.AST_SymbolRef && nodeAccess.property === 'exports') { + var expressionVal = nodeAccess.expression; + + if (expressionVal.thedef.name === 'module' && expressionVal.thedef.undeclared) { + return { + style: exportNode.Style.ModuleExports, + dotArray: [], + exportAST: nodeAccess, + ast: nodeAccess + }; + } + } + + // [some exports style].[property] + var exportAlias: ExportsInfo = matchExportsAlias(nodeAccess.expression, isTopLevel); + if (exportAlias) { + if (typeof nodeAccess.property === 'string') { + return { + style: exportAlias.style, + dotArray: exportAlias.dotArray.concat([nodeAccess.property]), + exportAST: exportAlias.exportAST, + ast: nodeAccess + }; + } + } + } +} + +export function walkAst(f: file.SourceFile) { + var impTopIndex = 0; + var expTopIndex = 0; + + var handleExportTopLevel = (exp: exportNode.Export, isTop: boolean) => { + exp.topLevel = isTop; + if (isTop) { + exp.topLevelIndex = expTopIndex++; + } + }; + + var walker = new uglify.TreeWalker((node: uglify.AST_Node, descend: () => void) => { + var isTop = walker.find_parent(uglify.AST_Lambda) ? false : true; + + // imports + if (node instanceof uglify.AST_Call) { + var nodeCall = node; + + if (nodeCall.expression instanceof uglify.AST_SymbolRef && nodeCall.args.length === 1) { + var funcVar = nodeCall.expression; + + if (funcVar.thedef.name === 'require' && funcVar.thedef.undeclared) { + var arg = nodeCall.args[0]; + + if (!(arg instanceof uglify.AST_String)) { + throw new Error('Statements in require calls are not allowed.'); + } + + var imp: importNode.Import; + if (parent instanceof uglify.AST_VarDef) { + // TODO: imports with properties, like var func require('name').someObj.someFunc; + var parentVar = parent; + + var impSimple = new importNode.SimpleImport(); + + impSimple.ast = parentVar; + impSimple.importAst = nodeCall; + impSimple.dotArray = []; + impSimple.varAst = parentVar.name; + + impSimple.safe = true; + + imp = impSimple; + } else { + imp = new importNode.Import(); + imp.ast = nodeCall; + imp.importAst = nodeCall; + + imp.safe = false; + } + + imp.conditional = (walker.find_parent(uglify.AST_Block) || walker.find_parent(uglify.AST_StatementWithBody) || walker.find_parent(uglify.AST_Conditional) || walker.find_parent(uglify.AST_Binary)) ? false : true; + imp.safe = imp.safe && !imp.conditional; + + imp.topLevel = isTop; + if (isTop) { + imp.topLevelIndex = impTopIndex++; + } + imp.relativePath = (arg).value; + + f.importNodes.push(imp); + + // if (arg instanceof uglify.AST_String) { + // var argStr = arg; + // } + } + } + } + + // exports + var match = matchExportsAlias(node, isTop); + if (!match) return; + + var parent: uglify.AST_Node = walker.parent(); + + if (parent instanceof uglify.AST_Assign) { + var parentAssign = parent; + if (match.dotArray.length === 0) { + if (match.style !== exportNode.Style.ModuleExports) { + throw new Error('Use "module.exports = " for export assignments instead of "exports = " or "this = "'); + } + var expF = new exportNode.FullExport(); + expF.style = match.style; + expF.ast = parentAssign; + expF.astLeft = match.ast; + expF.exportAst = match.exportAST; + expF.astRight = parentAssign.right; + + expF.safe = (walker.find_parent(uglify.AST_Block) || walker.find_parent(uglify.AST_StatementWithBody)) ? false : true; + + handleExportTopLevel(expF, isTop); + + f.exportNodes.push(expF); + + return true; + } else { + var expS = new exportNode.SingleExport(); + expS.style = match.style; + expS.ast = parentAssign; + expS.astLeft = match.ast; + expS.exportAst = match.exportAST; + expS.astRight = parentAssign.right; + + expS.dotArray = match.dotArray; + + expS.safe = (walker.find_parent(uglify.AST_Block) || walker.find_parent(uglify.AST_StatementWithBody)) ? false : true; + + handleExportTopLevel(expS, isTop); + + f.exportNodes.push(expS); + return true; + } + } else { + var expU = new exportNode.UnknownExport(); + expU.style = match.style; + expU.ast = node; + expU.exportAst = match.exportAST; + + expU.safe = false; + + handleExportTopLevel(expU, isTop); + + f.exportNodes.push(expU); + return true; + } + }); + + var walkerSafety = new uglify.TreeWalker((node: uglify.AST_Node, descend: () => void) => { + // import + var def: uglify.SymbolDef; + + if (node instanceof uglify.AST_VarDef) { + var nodeVarDef = node; + def = ( nodeVarDef.name).thedef; + } else if (node instanceof uglify.AST_Assign) { + var nodeAssign = node; + if (nodeAssign.left instanceof uglify.AST_SymbolVar) { + var nodeLeftVar = nodeAssign.left; + def = nodeLeftVar.thedef; + } + } + + if (def) { + for (var i = 0; i < f.importNodes.length; ++i) { + var imp = f.importNodes[i]; + if (imp instanceof importNode.SimpleImport) { + var impSimple = imp; + + if (!impSimple.safe) continue; + if (impSimple.varAst.thedef !== def) continue; + + if (impSimple.ast === node) continue; + + impSimple.safe = false; + } + } + } + }); + f.ast.walk(walker); + f.ast.walk(walkerSafety); + + // export safety + var unknownExps = f.getUnknownExportNodes(); + var singleExps = f.getSingleExportNodes(); + var fullExps = f.getFullExportNodes(); + + var expSafe: boolean; + + if (unknownExps.length !== 0) { + expSafe = false; + } else if (fullExps.length === 1) { + if (singleExps.length >= 1) { + expSafe = false; + } else { + expSafe = true; + } + } else if (fullExps.length >= 2) { + expSafe = false; + } + + if (expSafe === false || expSafe === true) { + for (var i = 0; i < f.exportNodes.length; ++i) { + f.exportNodes[i].safe = expSafe; + } + } else { + for (var i = 0; i < singleExps.length; ++i) { + var exp = singleExps[i]; + + if (exp.safe === false) continue; + + if (singleExps.filter((item) => { + return item.dotArray[0] === exp.dotArray[0]; + }).length === 1) { + exp.safe = true; + } else { + exp.safe = false; + } + } + } +} diff --git a/lib/bin.ts b/lib/bin.ts new file mode 100644 index 0000000..e4d187b --- /dev/null +++ b/lib/bin.ts @@ -0,0 +1,47 @@ +/// + +import lib = require('./index'); +import commander = require('commander'); +import path = require('path'); + +function list(val) { + return val.split(','); +} + +commander.version('0.1.0') + .option('-i, --input ', 'The input filename.') + .option('-o, --output ', 'The output filename.') + + .option('-m, --globalModules ', 'A comma-seperated list with external modules, in the form require-name=js-name, eg. doc=document,jquery=jquery. require(\'doc\') will now return document.', list) + .option('-e, --globalExport ', 'Exports the library to a global variable. Example: --globalExport "var test"') + .option('-p, --modulePath ', 'The path where to find external modules. Default: node_modules', list) + .option('-n, --includeNode', 'Add this option to include the node.js core modules that are required.') + .parse(process.argv); + +var options: lib.ProjectOptions = {}; + +options.exportPackage = { universal: commander['globalExport'] }; +options.modulesDirectories = commander['modulePath']; +options.includeNode = commander['includeNode'] !== undefined; +options.globalModules = {}; + +options.outputFileName = { standalone: path.join(process.cwd(), commander['output']) }; + +for (var i = 0; i < (commander['globalModules'] || []).length; ++i) { + var mod = commander['globalModules'][i]; + if (mod === '') continue; + + var ind = mod.indexOf('='); + + if (ind === -1) { + options.globalModules[mod] = { universal: mod }; + } else { + options.globalModules[mod.substr(0, ind)] = { universal: mod.substr(ind + 1) }; + } +} + +lib.compile(path.join(process.cwd(), commander['input']), options, (error) => { + if (error) { + throw error; + } +}); diff --git a/lib/bundle.ts b/lib/bundle.ts new file mode 100644 index 0000000..40ac91c --- /dev/null +++ b/lib/bundle.ts @@ -0,0 +1,27 @@ +import project = require('./project'); +import file = require('./file'); + +export function bundleFile(p: project.Project, f: file.SourceFile, includeFunctionCall: boolean = true, parameters: string[] = []): string { + if (f.compiled) return f.compiled; + + var compiled = f.source; + var replaces = f.rewriteData.replaces; + + replaces.forEach((replace) => { + if (replace.value) { + compiled = replaceRange(f, compiled, replace.pos, replace.endpos, replace.value); + } else if (replace.file) { + compiled = replaceRange(f, compiled, replace.pos, replace.endpos, replace.beforeFile + bundleFile(p, replace.file) + replace.afterFile); + } else { + compiled = replaceRange(f, compiled, replace.pos, replace.endpos, ''); + } + }); + + f.compiled = '(function(' + parameters.join(', ') + ') {\n' + f.rewriteData.top + '\n' + compiled + '\n' + f.rewriteData.bottom + '\n})' + (includeFunctionCall ? '()' : ''); + + return f.compiled; +} + +function replaceRange(f: file.SourceFile, str: string, start: number, end: number, substitute: string): string { + return str.substring(0, start) + substitute + str.substring(end); +} diff --git a/lib/combine.ts b/lib/combine.ts new file mode 100644 index 0000000..09d32d9 --- /dev/null +++ b/lib/combine.ts @@ -0,0 +1,34 @@ +/// + +import uglify = require('uglify-js'); +import file = require('./file'); + +/** + * Bundles the imports and exports of the file. + * @param file The file + */ +export function combine(f: file.SourceFile) { + var imports = f.getSimpleImportNodes(); + var exports = f.getSingleExportNodes(); + var fullExports = f.getFullExportNodes(); + + var findImport = (def: uglify.SymbolDef) => { + for (var i = 0; i < imports.length; ++i) { + var imp = imports[i]; + + if (imp.safe && imp.varAst.thedef === def) { + return imp; + } + } + return undefined; + }; + + if (fullExports.length === 1) { + fullExports[0].importNode = findImport(fullExports[0].def); + } else if (fullExports.length === 0) { + for (var i = 0; i < exports.length; ++i) { + var exp = exports[i]; + exp.importNode = findImport(exp.def); + } + } +} diff --git a/lib/exportNode.ts b/lib/exportNode.ts new file mode 100644 index 0000000..ece37d5 --- /dev/null +++ b/lib/exportNode.ts @@ -0,0 +1,61 @@ +/// +import uglify = require('uglify-js'); +import importNode = require('./importNode'); + +export enum Style { + Exports, // exports.[...] = + ModuleExports, // module.exports.[...] = OR module.exports = + This // this.[...] = +} + +export class Export { + style: Style; + + ast: uglify.AST_Node; + exportAst: uglify.AST_Node; + + importNode: importNode.SimpleImport; + + topLevel: boolean; + topLevelIndex: number; + safe: boolean; +} + +export class SingleExport extends Export { + ast: uglify.AST_Assign; + astLeft: uglify.AST_PropAccess; + astRight: uglify.AST_Node; + + dotArray: string[]; + + get def() { + return getDefFromNode(this.astRight); + } +} + +export class FullExport extends Export { + style = Style.ModuleExports; + + ast: uglify.AST_Assign; + astLeft: uglify.AST_PropAccess; + astRight: uglify.AST_Node; + + get def() { + return getDefFromNode(this.astRight); + } +} + +function getDefFromNode(ast: uglify.AST_Node): uglify.SymbolDef { + if (ast instanceof uglify.AST_SymbolRef) { + return ( ast).thedef; + } + return undefined; +} + +/** + * An export like: + * (function(exp) { exp.someVar = 'someValue' })(exports); + */ +export class UnknownExport extends Export { + +} diff --git a/lib/file.ts b/lib/file.ts new file mode 100644 index 0000000..b328a44 --- /dev/null +++ b/lib/file.ts @@ -0,0 +1,119 @@ +/// + +import uglify = require('uglify-js'); +import exportNode = require('./exportNode'); +import importNode = require('./importNode'); +import astWalker = require('./astWalker'); +import combine = require('./combine'); +import rewrite = require('./rewrite'); +import vinyl = require('vinyl'); + +export class SourceFile { + constructor(filename: string) { + this.filename = filename; + } + + id: number; + varName: string; + + file: vinyl.FileBuffer; + + failed: boolean = false; + + rewriteData: rewrite.RewriteData; + + parse(source: string) { + this.source = source; + this.ast = uglify.parse(this.source, { + filename: this.filename + }); + this.ast.figure_out_scope(); + } + + analyse() { + astWalker.walkAst(this); + combine.combine(this); + } + + filename: string; + extension: string; + source: string; + compiled: string; + + ast: uglify.AST_Toplevel; + + exportNodes: exportNode.Export[] = []; + importNodes: importNode.Import[] = []; + + getSingleExportNodes(): exportNode.SingleExport[] { + var result: exportNode.SingleExport[] = []; + for (var i = 0; i < this.exportNodes.length; ++i) { + if (this.exportNodes[i] instanceof exportNode.SingleExport) { + result.push( this.exportNodes[i]); + } + } + return result; + } + getFullExportNodes(): exportNode.FullExport[] { + var result: exportNode.FullExport[] = []; + for (var i = 0; i < this.exportNodes.length; ++i) { + if (this.exportNodes[i] instanceof exportNode.FullExport) { + result.push( this.exportNodes[i]); + } + } + return result; + } + getUnknownExportNodes(): exportNode.UnknownExport[] { + var result: exportNode.UnknownExport[] = []; + for (var i = 0; i < this.exportNodes.length; ++i) { + if (this.exportNodes[i] instanceof exportNode.UnknownExport) { + result.push( this.exportNodes[i]); + } + } + return result; + } + + getSimpleImportNodes(): importNode.SimpleImport[] { + var result: importNode.SimpleImport[] = []; + for (var i = 0; i < this.importNodes.length; ++i) { + if (this.importNodes[i] instanceof importNode.SimpleImport) { + result.push( this.importNodes[i]); + } + } + return result; + } + + setAllDependencies() { + this.allDependencies = []; + var helper = (other: SourceFile) => { + other.dependencies.forEach((dependency) => { + if (this.allDependencies.indexOf(dependency) === -1) { + this.allDependencies.push(dependency); + helper(dependency); + } + }); + }; + + helper(this); + } + + dependencies: SourceFile[] = []; + /** + * Dependencies and dependencies of dependencies (of dependencies ...) + */ + allDependencies: SourceFile[]; + dependants: SourceFile[] = []; + dependantImports: importNode.Import[] = []; + + unhandledDependencies: SourceFile[] = []; + + conditional: boolean = undefined; + + orderIndex: number; + + structureParent: SourceFile = undefined; + structureChildren: SourceFile[] = []; + structureLevel: number = undefined; + + defined: boolean = false; +} diff --git a/lib/importNode.ts b/lib/importNode.ts new file mode 100644 index 0000000..a055694 --- /dev/null +++ b/lib/importNode.ts @@ -0,0 +1,78 @@ +/// +import uglify = require('uglify-js'); +import exportNode = require('./exportNode'); +import file = require('./file'); +import project = require('./project'); + +export enum OutputStyle { + /** + * A closure. + * Only used when a file is imported once + */ + SINGLE, + + /** + * A first load. + * Example: + * require('events') + * becomes + * (__bundle$_1 = [...]); + */ + VAR_ASSIGN, + + /** + * A module variable reference. + * Example: + * require('events') becomes __bundle$_1 + */ + VAR_REFERENCE, + + /** + * Rename the variable to which the import is assigned to. + * Example: + * var events = require('events'); + * ... events ... + * becomes + * + * ... __bundle$_1 ... + */ + VAR_RENAME, + + /** + * Combines VAR_ASSIGN and VAR_RENAME + */ + VAR_ASSIGN_AND_RENAME +} + +export class Import { + ast: uglify.AST_Node; + importAst: uglify.AST_Call; + + relativePath: string; + absolutePath: string; + globalModule: project.PackageData; + + file: file.SourceFile; + + /** + * Whether the import is not inside a function + */ + topLevel: boolean; + topLevelIndex: number; + safe: boolean; + conditional: boolean; + + outputStyle: OutputStyle; +} + +/** + * An import like "var uglify = require('uglify-js');" + */ +export class SimpleImport extends Import { + ast: uglify.AST_VarDef; + varAst: uglify.AST_SymbolDeclaration; // AST_SymbolVar or AST_SymbolConst + + exportNode: exportNode.Export; + + dotArray: string[] = []; +} diff --git a/lib/index.ts b/lib/index.ts new file mode 100644 index 0000000..8a71431 --- /dev/null +++ b/lib/index.ts @@ -0,0 +1,119 @@ +/// + +import path = require('path'); +import Vinyl = require('vinyl'); +import chalk = require('chalk'); + +import project = require('./project'); +export import Project = project.Project; +export import ProjectOptions = project.ProjectOptions; + +export import io = require('./io'); +export import exportNode = require('./exportNode'); +export import importNode = require('./importNode'); + +export function compile(startFile: string, options?: ProjectOptions, callback?: (err?) => void) { + var p = new project.Project(startFile, new io.NodeIO(), options); + + p.on('error', (err) => { + if (callback) callback(err); + }); + p.on('written', () => { + if (callback) callback(); + }); + + p.start(); +} + +export interface GulpOptions extends ProjectOptions { + /** + * Resolve files that are not in the input list. + * Usefull for files in node_modules, so you don't have to list them all in the gulp.src call. + * Example: ['./node_modules'] + */ + externalResolve: string[]; +} + +export function error(err: Error) { + var message = err.message; + var index = message.indexOf('\n'); + + if (index === -1) { + message = chalk.red(message); + } else { + message = chalk.red(message.substring(0, index)) + message.substring(index); + } + + console.error(message); +} + +export function gulp(startFileName: string, options?: GulpOptions) { + var streamIO = new io.StreamIO(); + var stream = streamIO.stream; + + var usedIO: io.IIO; + + var externalResolve: string[] = []; + if (options.includeNode) { + externalResolve.push(path.join(__dirname, 'node_modules/browser-builtins')); + } + + if (options.externalResolve) { + externalResolve = externalResolve.concat(options.externalResolve.map(value => path.resolve(process.cwd(), value))); + } + if (externalResolve.length >= 0) { + usedIO = new io.HybridIO(streamIO, new io.NodeIO(), externalResolve, true); + } else { + usedIO = streamIO; + } + + var started = false; + var gulpCompile = (startFile: Vinyl) => { + if (started) return; + started = true; + + if (options.outputFileName) { + if (options.outputFileName.amd) { + options.outputFileName.amd = path.join(startFile.cwd, options.outputFileName.amd); + } + if (options.outputFileName.commonjs) { + options.outputFileName.commonjs = path.join(startFile.cwd, options.outputFileName.commonjs); + } + if (options.outputFileName.standalone) { + options.outputFileName.standalone = path.join(startFile.cwd, options.outputFileName.standalone); + } + if (options.outputFileName.universal) { + options.outputFileName.universal = path.join(startFile.cwd, options.outputFileName.universal); + } + } + + var p = new project.Project(startFile.path, usedIO, options); + + p.on('error', (err: Error) => { + error(err); + }); + p.on('written', () => { + stream.push(null); + }); + + p.start(); + }; + + streamIO.on('addFile', (err, file: Vinyl) => { + if (file.isNull()) return; + if (file.isStream()) { + this.emit('error', new Error('Streaming is not supported')); + } + + if (file.relative === startFileName) { + gulpCompile(file); + } + }); + streamIO.on('end', () => { + if (!started) { + error(new Error('The start file was not found!')); + } + }); + + return stream; +} diff --git a/lib/io.ts b/lib/io.ts new file mode 100644 index 0000000..4f5b285 --- /dev/null +++ b/lib/io.ts @@ -0,0 +1,309 @@ +/// + +import Vinyl = require('vinyl'); +import Promise = require('bluebird'); +// import path = require('path'); +import fs = require('fs'); +import stream = require('stream'); +import events = require('events'); + +enum ReadOperation { + FILE_EXISTS, + DIRECTORY_EXISTS, + READ_FILE +} + +export function normalizePath(path: string) { + if (!path) return path; + return path.toLowerCase().replace(/\\/, '/'); +} +export function pathsEqual(a: string, b: string) { + return normalizePath(a) === normalizePath(b); +} + +export interface IIO { + fileExists: (path: string) => Promise; + directoryExists: (path: string) => Promise; + + readFile: (path: string) => Promise; + writeFile: (file: Vinyl.FileBuffer) => Promise; +} + +export class NodeIO implements IIO { + cwd: string; + + constructor(cwd: string = process.cwd()) { + this.cwd = cwd; + } + + fileExists(path: string): Promise { + return new Promise((resolve: (exists) => void, reject) => { + fs.stat(path, (err, res) => { + if (err) return reject(err); + + if (!res) resolve(false); + + resolve(res.isFile()); + }); + }); + } + + directoryExists(path: string): Promise { + return new Promise((resolve: (exists) => void, reject) => { + fs.stat(path, (err, res) => { + if (err) return reject(err); + + if (!res) resolve(false); + + resolve(res.isDirectory()); + }); + }); + } + + readFile(path: string): Promise { + return new Promise((resolve: (file) => void, reject) => { + fs.readFile(path, (err, res) => { + if (err) return reject(err); + resolve(new Vinyl({ + path: path, + contents: res, + cwd: this.cwd + })); + }); + }); + } + + writeFile(file: Vinyl.FileBuffer): Promise { + return new Promise((resolve: (success) => void, reject) => { + fs.writeFile(file.path, file.contents, (err) => { + if (err) return reject(err); + + resolve(true); + }); + }); + } +} + +export class StreamIO extends events.EventEmitter implements IIO { + constructor() { + super(); + + this.stream = new StreamIO.DuplexStream((file: Vinyl) => { + this._addFile(file); + }, () => { + this._end(); + }); + } + + private _files: Vinyl[] = []; + private _queuedReads: QueuedRead[] = []; + private _finished: boolean; + stream: StreamIO.DuplexStream; + + private _findLocalFile(path: string): Vinyl { + for (var i = 0; i < this._files.length; ++i) { + var file = this._files[i]; + if (pathsEqual(file.path, path)) return file; + } + return undefined; + } + private _addFile(file: Vinyl) { + this._files.push(file); + + this._queuedReads = this._queuedReads.filter(read => { + if (pathsEqual(read.path, file.path)) { + switch (read.operation) { + case ReadOperation.FILE_EXISTS: + read.resolve(true); + break; + case ReadOperation.READ_FILE: + read.resolve(file); + break; + } + return false; // Remove from queue + } + var normalizedPath = normalizePath(read.path); + if (read.operation === ReadOperation.DIRECTORY_EXISTS && normalizePath(file.path).substr(0, normalizedPath.length) === normalizedPath) { + read.resolve(true); + return false; // Remove from queue + } + + return true; + }); + + this.emit('addFile', undefined, file); + } + private _end() { + this._finished = true; + this._queuedReads.forEach(read => { + var err: any = new Error('ENOENT, no such file or directory, ' + read.path); + err.code = 'ENOENT'; + read.reject(err); + }); + this._queuedReads = []; + this.emit('end'); + } + + fileExists(path: string): Promise { + if (this._findLocalFile(path)) { + return Promise.resolve(true); + } else if (this._finished) { + return Promise.resolve(false); + } else { + return new Promise((resolve, reject) => { + this._queuedReads.push({ + path: path, + operation: ReadOperation.FILE_EXISTS, + reject: reject, + resolve: resolve + }); + }); + } + } + directoryExists(path: string): Promise { + var normalizedPath = normalizePath(path); + if (normalizedPath.substr(normalizedPath.length - 1) !== '/') { + normalizedPath += '/'; + path += '/'; + } + + for (var i = 0; i < this._files.length; ++i) { + var file = this._files[i]; + if (normalizePath(file.path.substr(0, path.length)) === normalizedPath) { + return Promise.resolve(true); + } + } + + if (this._finished) { + return Promise.resolve(false); + } else { + return new Promise((resolve, reject) => { + this._queuedReads.push({ + path: normalizedPath, + operation: ReadOperation.DIRECTORY_EXISTS, + reject: reject, + resolve: resolve + }); + }); + } + } + + readFile(path: string): Promise { + var file = this._findLocalFile(path); + + if (file) { + return Promise.resolve(file); + } else if (this._finished) { + var err: any = new Error('ENOENT, no such file or directory, ' + path); + err.code = 'ENOENT'; + return Promise.reject(err); + } else { + return new Promise((resolve, reject) => { + this._queuedReads.push({ + path: path, + operation: ReadOperation.READ_FILE, + reject: reject, + resolve: resolve + }); + }); + } + } + + writeFile(file: Vinyl): Promise { + this.stream.push(file); + return Promise.resolve(true); + } +} +export module StreamIO { + export class DuplexStream extends stream.Duplex { + constructor(onFile: (file: Vinyl) => void, onEnd: () => void) { + super({ objectMode: true }); + this._onFile = onFile; + this._onEnd = onEnd; + } + + _onFile: (file: Vinyl) => void; + _onEnd: () => void; + + _write(file: Vinyl, encoding, cb = (err?) => { }): any { + if (!file) return cb(); + + if (file.isNull()) { + cb(); + return; + } + if (file.isStream()) { + return new Error('Stream not supported'); + } + + this._onFile(file); + cb(); + } + _read() { + + } + + end(chunk?, encoding?, callback?) { + this._write(chunk, encoding, callback); + this._onEnd(); + } + } +} + +interface QueuedRead { + path: string; + operation: ReadOperation; + reject: (err: any) => void; + resolve: (res: any) => void; +} + +export class HybridIO { + constructor(mainIO: IIO, altIO: IIO, altPaths: string[], altReadOnly = false) { + this.mainIO = mainIO; + this.altIO = altIO; + this.altPaths = altPaths; + this.altReadOnly = altReadOnly; + } + mainIO: IIO; + altIO: IIO; + altPaths: string[]; + altReadOnly: boolean; + + needsAltIO(path: string) { + path = normalizePath(path); + return this.altPaths.some((altPath) => { + altPath = normalizePath(altPath); + return path.substr(0, altPath.length) === altPath; + }); + } + + fileExists(path: string): Promise { + if (this.needsAltIO(path)) { + return this.altIO.fileExists(path); + } else { + return this.mainIO.fileExists(path); + } + } + directoryExists(path: string): Promise { + if (this.needsAltIO(path)) { + return this.altIO.directoryExists(path); + } else { + return this.mainIO.directoryExists(path); + } + } + + readFile(path: string): Promise { + if (this.needsAltIO(path)) { + return this.altIO.readFile(path); + } else { + return this.mainIO.readFile(path); + } + } + writeFile(file: Vinyl.FileBuffer): Promise { + if (this.needsAltIO(file.path) && !this.altReadOnly) { + return this.altIO.writeFile(file); + } else { + return this.mainIO.writeFile(file); + } + } +} diff --git a/lib/order.ts b/lib/order.ts new file mode 100644 index 0000000..3259b82 --- /dev/null +++ b/lib/order.ts @@ -0,0 +1,46 @@ +import project = require('./project'); +import file = require('./file'); + +export function generateOrder(proj: project.Project) { + var unhandledFiles: file.SourceFile[] = [].concat(proj.files); + + var prev: file.SourceFile; + var nextPrev: file.SourceFile; + var deleteIndex: number; + var ok: boolean; + + var index = 0; + + while (unhandledFiles.length !== 0) { + ok = false; + + for (var i = 0; i < unhandledFiles.length; ++i) { + var f = unhandledFiles[i]; + + // Remove previous file from unhandled dependencies. + var ind = f.unhandledDependencies.indexOf(prev); + if (ind !== -1) f.unhandledDependencies.splice(ind, 1); + + // If there are no unhandledDependencies + if (!ok && f.unhandledDependencies.length === 0) { + ok = true; + deleteIndex = i; + nextPrev = f; + f.orderIndex = index++; + proj.orderFiles.push(f); + } + } + + prev = nextPrev; + + if (ok) { + unhandledFiles.splice(deleteIndex, 1); + } else { + // Circular dependencies + // TODO: Implement circular dependencies + proj.emit('error', Error('Circular dependencies are not yet supported')); + proj.failed = true; + return; + } + } +} diff --git a/lib/project.ts b/lib/project.ts new file mode 100644 index 0000000..b7e6bfe --- /dev/null +++ b/lib/project.ts @@ -0,0 +1,395 @@ +/// + +import file = require('./file'); +import events = require('events'); +import resolve = require('./resolve'); +import order = require('./order'); +import structure = require('./structure'); +import rewrite = require('./rewrite'); +import bundle = require('./bundle'); +import importNode = require('./importNode'); +import io = require('./io'); +import Vinyl = require('vinyl'); + +export interface PackageData { + standalone?: string; + commonjs?: string; + amd?: string; + universal?: string; + + _varName?: string; +} + +export interface ProjectOptions { + /** + * Whether to load conditional imports, like 'if (someVar) var b = require(..)' + * Default: true + */ + alwaysLoadConditional?: boolean; // TODO: conditional imports + + exportPackage?: PackageData; + + /** + * Whether to include the node core packages, like utils, http and buffer. + * Packages will only be included if you use them. If you don't use them, they won't be included in the package. + * Default: false + */ + includeNode?: boolean; + + /** + * The directories to search for modules. + * Default: ['node_modules'] + */ + modulesDirectories?: string[]; + + /** + * require() modules in the global namespace. + * Example: { 'doc': { standalone: 'document' } } + * Then you can use require('doc') to get the document object. + * Default: {} + */ + globalModules?: { [name: string]: PackageData }; + + /** + * Whether to allow circular dependencies + * Default: false + */ + // allowCircular?: boolean; + // TODO: support circular dependencies + + /** + * Prefix used for variable names. + * Default: '__small$_' + */ + varPrefix?: string; + + /** + * The output filename(s) + * Example: + * { commonjs: 'output.commonjs.js', amd: 'output.amd.js', standalone: 'output.standalone.js' } + */ + outputFileName?: PackageData; +} + +export class Project extends events.EventEmitter { + startFileName: string; + startFile: file.SourceFile; + files: file.SourceFile[] = []; + orderFiles: file.SourceFile[] = []; + failed: boolean = false; + + io: io.IIO; + + compiled: PackageData = {}; + + options: ProjectOptions; + + constructor(startFileName: string, ioHost: io.IIO = new io.NodeIO(), options: ProjectOptions = {}) { + super(); + + this.io = ioHost; + + // Default options + if (options.alwaysLoadConditional === undefined) options.alwaysLoadConditional = true; + if (options.includeNode === undefined) options.includeNode = false; + if (options.modulesDirectories === undefined) options.modulesDirectories = ['node_modules']; + if (options.globalModules === undefined) options.globalModules = {}; + // if (options.allowCircular === undefined) options.allowCircular = false; + if (options.varPrefix === undefined) options.varPrefix = '__small$_'; + + this.options = options; + + this.startFileName = startFileName; + + var i = 0; + for (var name in options.globalModules) { + if (!Object.prototype.hasOwnProperty.call(options.globalModules, name)) continue; + + options.globalModules[name]._varName = options.varPrefix + 'mod_' + i; + i++; + } + } + + start() { + this.startFile = this.addFile(this.startFileName); + } + + private _fileQueue: number = 0; + addFile(filename: string): file.SourceFile { + var f = new file.SourceFile(filename); + f.id = this.files.length; + f.varName = this.options.varPrefix + f.id; + + this._fileQueue++; + this.files.push(f); + + this.io.readFile(filename).then((source) => { + if (this.failed) return; + + f.file = source; + + f.parse(source.contents.toString('utf8')); + + f.analyse(); + + this.resolveFile(f, (err) => { + if (err) { + this.emit('error', err); + } else { + this._fileQueue--; + if (this._fileQueue === 0) { + this.emit('read'); + this.setAllDependencies(); + this.generateOrder(); + this.generateStructure(); + this.importSetOuputStyles(); + this.rewrite(); + this.bundle(); + this.writeOutput(); + } + } + }); + }).catch((err) => { + this.emit('error', err); + }); + + return f; + } + getFile(filename: string): file.SourceFile { + for (var i = 0; i < this.files.length; ++i) { + if (this.files[i].filename === filename) { + return this.files[i]; + } + } + return undefined; + } + getOrAddFile(filename: string): file.SourceFile { + var f = this.getFile(filename); + + if (f) { + return f; + } else { + return this.addFile(filename); + } + } + + resolveFile(f: file.SourceFile, callback: (err) => void) { + var imports = f.importNodes; + + if (imports.length === 0) { + process.nextTick(() => { + callback(undefined); + }); + return; + } + + var queue = 0; + var done = false; + + imports.forEach((imp, i) => { + if (Object.prototype.hasOwnProperty.call(this.options.globalModules, imp.relativePath)) { + imp.globalModule = this.options.globalModules[imp.relativePath]; + } else { + queue++; + + this.resolveSingle(f, imp.relativePath).then(path => { + imp.absolutePath = path; + imp.file = this.getOrAddFile(imp.absolutePath); + + if (f.dependencies.indexOf(imp.file) === -1) { + f.dependencies.push(imp.file); + imp.file.dependants.push(f); + } + imp.file.dependantImports.push(imp); + + queue--; + + if (queue === 0) { + f.unhandledDependencies = [].concat(f.dependencies); + callback(undefined); + done = true; + } + }).catch((err) => { + this.failed = true; + f.failed = true; + done = true; + callback(err); + }); + } + }); + + if (queue === 0 && !done) { + callback(undefined); + } + } + resolveSingle(f: file.SourceFile, str: string): Promise { + return resolve.resolve(this, f.file, str); + } + setAllDependencies() { + this.files.forEach((file) => { + file.setAllDependencies(); + }); + } + generateOrder() { + order.generateOrder(this); + this.emit('generatedOrder'); + } + generateStructure() { + structure.generateStructure(this); + this.emit('generatedStructure'); + } + importSetOuputStyles() { + this.orderFiles.forEach((f) => { + f.importNodes.forEach((imp) => { + if (imp.globalModule) { + imp.outputStyle = importNode.OutputStyle.VAR_REFERENCE; + if (imp.file) imp.file.defined = true; + return; + } + + if (imp.file.dependantImports.length === 1) { + imp.outputStyle = importNode.OutputStyle.SINGLE; + imp.file.defined = true; + return; + } + + // TODO: Check whether it is secure to use VAR_ASSIGN or VAR_ASSIGN_AND_RENAME + if (imp.file.structureParent === f) { + if (f.importNodes.filter((item) => { + return item.file === imp.file; + })[0] === imp) { + imp.outputStyle = (imp instanceof importNode.SimpleImport) ? importNode.OutputStyle.VAR_ASSIGN_AND_RENAME : importNode.OutputStyle.VAR_ASSIGN; + imp.file.defined = true; + return; + } + } + + if (imp instanceof importNode.SimpleImport && imp.safe && (imp).dotArray.length === 0) { + imp.outputStyle = importNode.OutputStyle.VAR_RENAME; + return; + } + + imp.outputStyle = importNode.OutputStyle.VAR_REFERENCE; + }); + }); + } + rewrite() { + this.files.forEach((f) => { + rewrite.rewriteFile(this, f); + }); + this.emit('rewritten'); + } + bundle() { + // Convert Dictionary to Array + var globalModules = Object.keys(this.options.globalModules).map(key => this.options.globalModules[key]); + + var compiled = bundle.bundleFile(this, this.startFile, false, globalModules.map(mod => mod._varName)); + + var standaloneDeps = globalModules.map(mod => mod.standalone || mod.universal).join(', '); + var amdDeps = globalModules.map(mod => JSON.stringify(mod.amd || mod.universal)).join(', '); + var commonjsDeps = globalModules.map(mod => 'require(' + JSON.stringify(mod.amd || mod.universal) + ')').join(', '); + + if (!this.options.exportPackage) this.options.exportPackage = {}; + + if (this.options.exportPackage.standalone !== undefined) { + this.compiled.standalone = this.options.exportPackage.standalone + + ' = ' + + compiled + + '(' + standaloneDeps + ');'; + + if (this.options.exportPackage.standalone.indexOf('.') === -1) { + this.compiled.standalone = 'var ' + this.compiled.standalone; + } + } else { + this.compiled.standalone = compiled + + '(' + + standaloneDeps + + ');'; + } + + if (this.options.exportPackage.amd === undefined || this.options.exportPackage.amd === '') { + this.compiled.amd = 'define([' + + amdDeps + + '], ' + compiled + + ');'; + } else { + this.compiled.amd = 'define(' + + JSON.stringify(this.options.exportPackage.amd) + + ', [' + + amdDeps + + '], ' + compiled + + ');'; + } + + this.compiled.commonjs = 'module.exports = ' + compiled + '(' + commonjsDeps + ');'; + + if (this.options.exportPackage.universal !== undefined) { + var universalAMD = this.options.exportPackage.universal; + var universalCommonjs = this.options.exportPackage.universal; + var universalStandalone = this.options.exportPackage.universal; + + if (this.options.exportPackage.universal === '') { + universalAMD = this.options.exportPackage.amd; + universalCommonjs = this.options.exportPackage.commonjs; + universalStandalone = this.options.exportPackage.standalone; + } + + this.compiled.universal = '(function(__root, __factory) { if (typeof define === "function" && define.amd) { ' + + 'define(' + JSON.stringify(universalAMD) + ', [' + amdDeps + '], __factory);' + + '} else if (typeof exports === "object") {' + + 'module.exports = __factory(' + commonjsDeps + ');' + + '} else {' + + '__root[' + JSON.stringify(universalStandalone) + '] = __factory(' + standaloneDeps + ');' + + '}' + + '})(this, ' + compiled + ')'; + } else { + this.compiled.universal = '(function(__root, __factory) { if (typeof define === "function" && define.amd) { ' + + 'define([' + amdDeps + '], __factory);' + + '} else if (typeof exports === "object") {' + + '__factory(' + commonjsDeps + ');' + + '} else {' + + '__factory(' + standaloneDeps + ');' + + '}' + + '})(this, ' + compiled + ')'; + } + this.emit('bundled'); + } + writeOutput() { + if (this.options.outputFileName === undefined || this.options.outputFileName === null) return; // No output + + var queue = 0; + + var output = (filename, content) => { + var file = new Vinyl({ + path: filename, + cwd: this.startFile.file.cwd, + contents: new Buffer(content) + }); + + queue++; + + this.io.writeFile(file).then(() => { + queue--; + + process.nextTick(() => { + if (queue === 0) this.emit('written'); + }); + }).catch(err => { + this.emit('error', err); + }); + }; + + if (this.options.outputFileName.amd) { + output(this.options.outputFileName.amd, this.compiled.amd); + } + if (this.options.outputFileName.commonjs) { + output(this.options.outputFileName.commonjs, this.compiled.commonjs); + } + if (this.options.outputFileName.standalone) { + output(this.options.outputFileName.standalone, this.compiled.standalone); + } + if (this.options.outputFileName.universal) { + output(this.options.outputFileName.universal, this.compiled.universal); + } + } +} diff --git a/lib/resolve.ts b/lib/resolve.ts new file mode 100644 index 0000000..7cc8f22 --- /dev/null +++ b/lib/resolve.ts @@ -0,0 +1,169 @@ +/// + +import path = require('path'); +import project = require('./project'); +import io = require('./io'); +import Promise = require('bluebird'); +import Vinyl = require('vinyl'); +import browserBuiltins = require('browser-builtins'); + +export function resolve(proj: project.Project, from: Vinyl, ref: string): Promise { + /*var res = path.join(path.dirname(from), ref) + '.js'; + process.nextTick(() => { + callback(undefined, res); + });*/ + + var resolver = new Resolver(proj.io, proj.options); + resolver.resolve(ref, from); + + return resolver.value; +} + +export class Resolver { + options: project.ProjectOptions; + + io: io.IIO; + + str: string; + from: Vinyl; + value: Promise; + private _resolve: (path: string) => void; + private _reject: (err) => void; + + constructor(ioHost: io.IIO, options: project.ProjectOptions = {}) { + this.options = options; + this.io = ioHost; + + this.value = new Promise((resolve: (value: string) => void, reject: (err) => void) => { + this._resolve = resolve; + this._reject = reject; + }); + } + + resolve(str: string, from: Vinyl) { + this.str = str; + this.from = from; + + if (this.options.includeNode && browserBuiltins.hasOwnProperty(str) && str !== '') { + this.tryFiles([browserBuiltins[str]], () => { + this.notFound(); + }); + return; + } + + if (str.substring(0, 2) === './' || str.substring(0, 1) === '/' || str.substring(0, 3) === '../') { + this.resolveFile(path.resolve(path.dirname(from.path), str)); + } else { + this.resolveNodeModules(str, from); + } + } + + resolveFile(filename: string, failCallback?: () => void) { + this.tryFiles([ + filename, + filename + '.js' + ], () => { + this.resolveDirectory(filename, failCallback); + }); + } + resolveDirectory(pathStr: string, failCallback: () => void = () => this.notFound()) { + this.parseJSONFile(path.join(pathStr, 'package.json')).then(json => { + if (json['main']) { + this.tryFiles([ + path.join(pathStr, json['main']) + '.js', + path.join(pathStr, json['main']), + path.join(pathStr, 'index.js') + ], failCallback); + } else { + this.tryFiles([ + path.join(pathStr, 'index.js') + ], failCallback); + } + }).catch(() => { + this.tryFiles([ + path.join(pathStr, 'index.js') + ], failCallback); + }); + } + + resolveNodeModules(str: string, from: Vinyl) { + var paths = this.getAllNodeModules(from.path, str); + + var tryPath = (index: number) => { + var path = paths[index]; + this.tryFiles([ + path, + path + '.js' + ], () => { + this.resolveDirectory(path, () => { + if (index === paths.length - 1) { + this.notFound(); + } else { + tryPath(index + 1); + } + }); + }); + }; + + tryPath(0); + } + + getAllNodeModules(path: string, to: string): string[] { + if (this.options.modulesDirectories.length === 0) return []; + + var parts = path.split(/\\|\//); // '/' or '\' + var root = -1; + + this.options.modulesDirectories.forEach(path => { + var currentRoot = parts.indexOf(path); + + if (currentRoot !== -1) { + if (root === -1) { + root = currentRoot; + } else { + root = Math.min(root, currentRoot); + } + } + }); + + var dirs: string[] = []; + + for (var i = parts.length - 1; i > root; --i) { + if (this.options.modulesDirectories.indexOf(parts[i]) !== -1) continue; + + var base = parts.slice(0, i + 1).join('/'); + this.options.modulesDirectories.forEach((path) => { + dirs.push(base + '/' + path + '/' + to); + }); + } + + return dirs; + } + + private tryFiles(paths: string[], failCallback: () => void) { + if (paths.length === 0) { + failCallback(); + return; + } + + this.io.fileExists(paths[0]).then((found: boolean) => { + if (found) { + this._resolve(paths[0]); + } else { + this.tryFiles(paths.slice(1), failCallback); + } + }).catch(() => { + this.tryFiles(paths.slice(1), failCallback); + }); + } + + private notFound() { + this._reject(new Error('Reference not found:\n\t' + JSON.stringify(this.str) + ' from ' + this.from.path)); + } + + private parseJSONFile(path: string): Promise { + return this.io.readFile(path).then((file) => { + return JSON.parse(file.contents.toString('utf8')); + }); + } +} diff --git a/lib/rewrite.ts b/lib/rewrite.ts new file mode 100644 index 0000000..fed7871 --- /dev/null +++ b/lib/rewrite.ts @@ -0,0 +1,151 @@ +import project = require('./project'); +import file = require('./file'); +import exportNode = require('./exportNode'); +import importNode = require('./importNode'); + +export interface Replace { + pos: number; + endpos: number; + + secundarySort?: number; + + value?: string; + file?: file.SourceFile; + beforeFile?: string; + afterFile?: string; +} +export interface RewriteData { + replaces: Replace[]; + top: string; + bottom: string; + closureParameters: ClosureParameter[]; +} + +export interface ClosureParameter { + name: string; + value: string; +} + +export function rewriteFile(p: project.Project, f: file.SourceFile) { + var replaces: Replace[] = []; + + var top: string = ''; + var bottom: string = ''; + var closureParameters: ClosureParameter[] = []; + + var unknownExps = f.getUnknownExportNodes(); + var singleExps = f.getSingleExportNodes(); + var fullExps = f.getFullExportNodes(); + + var needsTwoExportVariables = (fullExps.length >= 1) && ((unknownExps.length >= 1) || (singleExps.length >= 1)); + + var varExports = 'exports'; + var varModuleExports = p.options.varPrefix + 'moduleExports'; + + if (needsTwoExportVariables) { + top = 'var ' + varExports + ' = {}, ' + varModuleExports + ' = ' + varExports + ';'; + bottom = 'return ' + varModuleExports + ';'; + } else { + top = 'var ' + varExports + ' = {};'; + bottom = 'return ' + varExports + ';'; + varModuleExports = varExports; + } + + f.exportNodes.forEach((exp) => { + replaces.push({ + pos: exp.exportAst.start.pos, + endpos: exp.exportAst.end.endpos, + value: (exp.style === exportNode.Style.ModuleExports) ? varModuleExports : varExports + }); + }); + + f.importNodes.forEach((imp) => { + switch (imp.outputStyle) { + case importNode.OutputStyle.SINGLE: + replaces.push({ + pos: imp.importAst.start.pos, + endpos: imp.importAst.end.endpos, + + beforeFile: '(', + file: imp.file, + afterFile: ')' + }); + return; + case importNode.OutputStyle.VAR_REFERENCE: + replaces.push({ + pos: imp.importAst.start.pos, + endpos: imp.importAst.end.endpos, + + value: imp.file ? imp.file.varName : imp.globalModule._varName + }); + return; + case importNode.OutputStyle.VAR_ASSIGN: + case importNode.OutputStyle.VAR_ASSIGN_AND_RENAME: + replaces.push({ + pos: imp.importAst.start.pos, + endpos: imp.importAst.end.endpos, + + beforeFile: '(' + imp.file.varName + ' = ', + file: imp.file, + afterFile: ')' + + }); + break; + } + + switch (imp.outputStyle) { + case importNode.OutputStyle.VAR_RENAME: + replaces.push({ + pos: imp.ast.start.pos, + endpos: imp.ast.end.endpos, + + value: '' + }); + case importNode.OutputStyle.VAR_ASSIGN_AND_RENAME: + var impSimple = imp; + impSimple.varAst.thedef.references.forEach((ref) => { + replaces.push({ + pos: ref.start.pos, + endpos: ref.end.endpos, + + value: imp.file.varName + }); + }); + } + }); + + var childTopId = 0; + f.structureChildren.forEach((other) => { + if (!other.defined) { + replaces.push({ + pos: 0, + endpos: 0, + + secundarySort: childTopId++, + + beforeFile: 'var ' + other.varName + ' = ', + file: other, + afterFile: ';\n' + }); + } + }); + + replaces.sort((a, b) => { // Sort ascending based on pos and secundarySort + if (a.pos === b.pos) { + if (a.endpos === b.endpos) { + return b.secundarySort - a.secundarySort; + } else { + return b.endpos - a.endpos; + } + } else { + return b.pos - a.pos; + } + }); + + f.rewriteData = { + replaces: replaces, + top: top, + bottom: bottom, + closureParameters: closureParameters + }; +} diff --git a/lib/structure.ts b/lib/structure.ts new file mode 100644 index 0000000..33a8a2d --- /dev/null +++ b/lib/structure.ts @@ -0,0 +1,67 @@ +import project = require('./project'); +import file = require('./file'); + +interface FindCommonParentResult { + parent: file.SourceFile; + level: number; +} + +function findCommonParent(files: file.SourceFile[]): FindCommonParentResult { + if (files.length === 0) return { + parent: undefined, + level: 0 + }; + + var parent: file.SourceFile = files[0]; + var parentParents: file.SourceFile[]; + + var setParentParents = () => { + parentParents = []; + var p = parent; + while (p) { + parentParents.push(p); + p = p.structureParent; + } + }; + + setParentParents(); + + for (var i = 1; i < files.length; ++i) { + var f = files[i]; + var p = f; + + while (p) { + var ind = parentParents.indexOf(p); + + if (ind === -1) { + p = p.structureParent; + } else { + parent = p; + setParentParents(); + break; + } + } + } + + return { + parent: parent, + level: parentParents.length + }; +} + +export function generateStructure(proj: project.Project) { + var files = proj.orderFiles; + + for (var i = files.length - 1; i>=0; --i) { + var f = files[i]; + + var commonParent = findCommonParent(f.dependants.filter((item) => { + return item.orderIndex > i; + })); + + f.structureParent = commonParent.parent; + f.structureLevel = commonParent.level; + + if (f.structureParent) f.structureParent.structureChildren.splice(0, 0, f); + } +} diff --git a/package.json b/package.json new file mode 100644 index 0000000..be78652 --- /dev/null +++ b/package.json @@ -0,0 +1,36 @@ +{ + "name": "small", + "version": "0.1.0", + "description": "A tool to bundle commonjs files. Designed to produce the smallest file size possible.", + "keywords": [ + "bundle", "commonjs", "browser", "gulpfriendly" + ], + "author": { + "name": "Ivo Gabe de Wolff", + "url": "http://ivogabe.com/" + }, + "dependencies": { + "uglify-js": "^2.3.6", + "commander": "^2.2.0", + "vinyl": "^0.2.3", + "bluebird": "^1.2.4", + "chalk": "^0.4.0", + "browser-builtins": "^3.1.0" + }, + "devDependencies": { + "gulp": "^3.6.2", + "gulp-rename": "^1.2.0", + "gulp-tslint": "^1.1.0", + "gulp-type": "^0.1.1" + }, + + "main": "./release/index.js", + "bin": { + "small": "./bin.js" + }, + + "repository": { + "type" : "git", + "url" : "https://github.com/ivogabe/small.git" + } +} diff --git a/readme.md b/readme.md new file mode 100644 index 0000000..c74fce1 --- /dev/null +++ b/readme.md @@ -0,0 +1,174 @@ +Small +===== + +Small is a CommonJS bundler that aims to generate the smallest bundle size. It supports commonjs files, and output as a standalone, commonjs, amd and universal package. + +How to install +-------------- +``` npm instal small ``` +or (for command line usage) +``` npm install small -g ``` + +How to use +---------- +Command line: +``` small -i index.js -o output.js ``` +(```small --help``` for more info) + +From node: +``` +var small = require('small'); +small.compile('filename.js', options, function(error) { + if (error) throw error; + console.log('Completed'); +}); +``` +Or, as a gulp plugin: +``` +var gulp = require('gulp'); +var small = require('small').gulp; // <-- notice the '.gulp' part + +gulp.task('scripts', function() { + return gulp.src('lib/*.js') + .pipe(small('index.js', options)) // start with lib/index.js + .pipe(gulp.dest('release')) +}); +``` + +Options +------- +```options``` in the examples above is an object with these properties: + +**exportPackage** - Export the package with the specified name. You can specify different names for different targets. Example: +``` +{ + commonjs: 'myCommonJSPackage', + amd: 'myAMDPackage', + standalone: 'myBrowserPackage' +} +``` +Or +``` +{ + universal: 'myPackage' +} +``` + +**globalModules** - Add external modules, which will not be included in the generated package. Example: +``` +{ + '$': { + commonjs: 'jquery', // Output will be require('jquery') + amd: 'jquery', // Output will be define(['jquery'], ...) + standalone: 'jquery' // Output will be jquery + } +} +``` +Which is equal to +``` +{ + '$': { + universal: 'jquery' + } +} +``` +Then you can do: +``` +var $ = require('$'); +``` + +**outputFileName** - The output filename(s). Example: +``` +{ + standalone: 'output.js', +} +``` +Or +``` +{ + commonjs: 'output.commonjs.js', + amd: 'output.amd.js', + standalone: 'output.standalone.js', + universal: 'output.universal.js' +} +``` + +**includeNode** (boolean) - Whether to include the node core packages, like ```path```. +**modulesDirectories** (string[]) - Folder names which contain modules. Default: ```['node_modules']```. You can specify multiple names. +**varPrefix** (string) - Small add some variables to the emitted code. These variables are prefixed with this prefix. Default: '__small$_' + +Loaders +------- +Small doesn't have loaders like browserify does. Instead you can use gulp. Example: +``` +var gulp = require('gulp'); +var small = require('small').gulp; +var type = require('gulp-type'); + +gulp.task('scripts', function() { + return gulp.src('lib/**.ts') + .pipe(ts({module: 'commonjs'})).js + .pipe(small('index.js', {}) + .pipe(gulp.dest('release')) +}); +``` + +Small file size +--------------- +Small is designed to generate a small file size. Because of this, it might not work with all the projects. You can use it if: +- You don't use expressions in ```require``` calls. +- You don't use circular dependencies (eg a.js requires b.js and b.js requires a.js, circular dependencies will be supported in the future). +- Your code doesn't modify globals (like String). If globals are modified, make sure every file that uses these changes also requires the file that modified the global. + +Small is designed to be used with TypeScript and TypeScript's ```import``` and ```export``` statements, but it also works with normal JavaScript. + +The following parts from CommonJS are not and (probably) won't be supported: +- module.id +- module.uri +- require(...expression...) +- require.main +- require.paths + +About the generated JavaScript +------------------------------ +Every module is wrapped in a closure. Every module looks like this: +``` +(function() { + var exports = {}; + // ... + return exports; +})(); +``` +If necessary, Small automaticly adds a module.exports variable (```__small$_moduleExports```), but first Small tries to replace ```module.exports``` (and toplevel ```this```) with ```exports```. If that's not safe, Small renames ```module.exports``` to ```__small$_moduleExports```. + +If possible, modules are placed in modules that use them, like this: +``` +(function() { + var exports = {}; + var otherFile = (function() { // was: var otherFile = require('./otherFile.js'); + var exports = {}; + // ... + return exports; + })(); + // ... + return exports; +})(); +``` +This way it's the easiest for minifier to understand the code. + +If a file is required more then once, it will be assigned to a variable like ```__small$_1``` (but that name will be mangled if you use a minifier). + +Include Node +------------ +Set the includeNode option to true and you can require the default modules (like path). Node's globals are not yet supported. + +Todo +---- +- Sourcemaps +- Conditional imports (like if (...) require('...')) +- Circular dependencies (depends on conditional imports) +- Include node globals when includeNode is set + +License +------- +Small is licensed under the MIT license. \ No newline at end of file diff --git a/tslint.json b/tslint.json new file mode 100644 index 0000000..baad943 --- /dev/null +++ b/tslint.json @@ -0,0 +1,50 @@ +{ + "rules": { + "class-name": true, + "comment-format": [true, + "check-space" + ], + "jsdoc-format": true, + "label-position": true, + "label-undefined": true, + "no-arg": true, + "no-construct": true, + "no-debugger": true, + "no-duplicate-key": true, + "no-eval": true, + "no-trailing-comma": true, + "no-trailing-whitespace": true, + "no-unused-expression": true, + "no-unused-variable": true, + "no-unreachable": true, + "no-var-requires": true, + "one-line": [true, + "check-open-brace", + "check-catch", + "check-else", + "check-whitespace" + ], + "quotemark": [true, "single"], + "radix": true, + "semicolon": true, + "triple-equals": [true, "allow-null-check"], + "typedef": [true, + "indexSignature", + "propertySignature" + ], + "typedef-whitespace": [true, + ["callSignature", "noSpace"], + ["catchClause", "noSpace"], + ["indexSignature", "space"] + ], + "variable-name": [true, + "allow-leading-underscore" + ], + "whitespace": [true, + "check-branch", + "check-decl", + "check-separator", + "check-type" + ] + } +}