jass 0.9.1

data/vendor/node_modules/rollup/dist/typings/utils/callIfFunction.d.ts

@@ -0,0 +1 @@
+export default function callIfFunction<T>(thing: T | (() => T)): T;

data/vendor/node_modules/rollup/dist/typings/utils/collapseSourcemaps.d.ts

@@ -0,0 +1,5 @@
+import Module from '../Module';
+import { RawSourceMap } from 'source-map';
+import Chunk from '../Chunk';
+import { SourceMap, DecodedSourceMap } from 'magic-string';
+export default function collapseSourcemaps(bundle: Chunk, file: string, map: DecodedSourceMap, modules: Module[], bundleSourcemapChain: RawSourceMap[]): SourceMap;

data/vendor/node_modules/rollup/dist/typings/utils/commondir.d.ts

@@ -0,0 +1 @@
+export default function commondir(files: string[]): string;

data/vendor/node_modules/rollup/dist/typings/utils/defaults.d.ts

@@ -0,0 +1,6 @@
+import Module from '../Module';
+import { InputOptions } from '../rollup';
+export declare function load(id: string): string;
+export declare function resolveId(options: InputOptions): (importee: string, importer: string) => string | void;
+export declare function makeOnwarn(): (warning: any) => void;
+export declare function handleMissingExport(exportName: string, importingModule: Module, importedModule: string, importerStart?: number): void;

data/vendor/node_modules/rollup/dist/typings/utils/deprecateOptions.d.ts

@@ -0,0 +1,6 @@
+import { GenericConfigObject } from './mergeOptions';
+export declare type Deprecation = {
+    old: string;
+    new: string;
+};
+export default function deprecateOptions(options: GenericConfigObject, deprecateConfig: GenericConfigObject): Deprecation[];

data/vendor/node_modules/rollup/dist/typings/utils/ensureArray.d.ts

@@ -0,0 +1,2 @@
+export default function ensureArray<T>(thing: T[]): T[];
+export default function ensureArray(thing: any): any[];

data/vendor/node_modules/rollup/dist/typings/utils/entryHashing.d.ts

@@ -0,0 +1,3 @@
+export declare function Uint8ArrayToHexString(buffer: Uint8Array): string;
+export declare function Uint8ArrayXor(to: Uint8Array, from: Uint8Array): Uint8Array;
+export declare function randomUint8Array(len: number): Uint8Array;

data/vendor/node_modules/rollup/dist/typings/utils/error.d.ts

@@ -0,0 +1,18 @@
+export interface RollupError {
+    message: string;
+    code?: string;
+    name?: string;
+    url?: string;
+    id?: string;
+    loc?: {
+        file?: string;
+        line: number;
+        column: number;
+    };
+    stack?: string;
+    frame?: string;
+    pos?: number;
+    plugin?: string;
+    pluginCode?: string;
+}
+export default function error(props: Error | RollupError): void;

data/vendor/node_modules/rollup/dist/typings/utils/first-sync.d.ts

@@ -0,0 +1 @@
+export default function firstSync<T>(candidates: ((...args: any[]) => T | void)[]): (...args: any[]) => T | void;

data/vendor/node_modules/rollup/dist/typings/utils/first.d.ts

@@ -0,0 +1 @@
+export default function first<T>(candidates: ((...args: any[]) => Promise<T | void> | T | void)[]): (...args: any[]) => Promise<T | void>;

data/vendor/node_modules/rollup/dist/typings/utils/flushTime.d.ts

@@ -0,0 +1,5 @@
+export declare function timeStart(label: string): void;
+export declare function timeEnd(label: string): void;
+export declare function flushTime(log?: typeof defaultLog): void;
+/** @interal */
+export declare function defaultLog(label: string, time: number): void;

data/vendor/node_modules/rollup/dist/typings/utils/fs.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="node" />
+export * from 'fs';
+export declare function writeFile(dest: string, data: string | Buffer): Promise<{}>;

data/vendor/node_modules/rollup/dist/typings/utils/getCodeFrame.d.ts

@@ -0,0 +1 @@
+export default function getCodeFrame(source: string, line: number, column: number): string;

data/vendor/node_modules/rollup/dist/typings/utils/getExportMode.d.ts

@@ -0,0 +1,3 @@
+import Chunk from '../Chunk';
+import { OutputOptions } from '../rollup/index';
+export default function getExportMode(chunk: Chunk, {exports: exportMode, name, format}: OutputOptions): "default" | "named" | "none";

data/vendor/node_modules/rollup/dist/typings/utils/getIndentString.d.ts

@@ -0,0 +1,4 @@
+import Module from '../Module';
+export default function getIndentString(modules: Module[], options: {
+    indent?: boolean;
+}): string;

data/vendor/node_modules/rollup/dist/typings/utils/identifierHelpers.d.ts

@@ -0,0 +1,3 @@
+export declare const reservedWords: string[];
+export declare function isLegal(str: string): boolean;
+export declare function makeLegal(str: string): string;

data/vendor/node_modules/rollup/dist/typings/utils/mergeOptions.d.ts

@@ -0,0 +1,19 @@
+import { Deprecation } from './deprecateOptions';
+import { WarningHandler } from '../rollup/index';
+export declare type GenericConfigObject = {
+    [key: string]: any;
+};
+export declare const commandAliases: {
+    [key: string]: string;
+};
+export default function mergeOptions({config, command: rawCommandOptions, deprecateConfig, defaultOnWarnHandler}: {
+    config: GenericConfigObject;
+    command?: GenericConfigObject;
+    deprecateConfig?: GenericConfigObject;
+    defaultOnWarnHandler?: WarningHandler;
+}): {
+    inputOptions: any;
+    outputOptions: any;
+    deprecations: Deprecation[];
+    optionError: string | null;
+};

data/vendor/node_modules/rollup/dist/typings/utils/object.d.ts

@@ -0,0 +1,7 @@
+export declare const keys: (o: {}) => string[];
+export declare function blank(): any;
+export declare const BLANK: any;
+export declare function forOwn<T>(object: {
+    [key: string]: T;
+}, func: (value: T, key: string) => void): void;
+export declare function assign<T, U>(target: T, source: U): T & U;

data/vendor/node_modules/rollup/dist/typings/utils/path.d.ts

@@ -0,0 +1,6 @@
+export declare const absolutePath: RegExp;
+export declare const relativePath: RegExp;
+export declare function isAbsolute(path: string): boolean;
+export declare function isRelative(path: string): boolean;
+export declare function normalize(path: string): string;
+export { basename, dirname, extname, relative, resolve } from 'path';

data/vendor/node_modules/rollup/dist/typings/utils/promise.d.ts

@@ -0,0 +1,2 @@
+export declare function mapSequence<T, U>(array: T[], fn: (member: T) => Promise<U> | U): Promise<U[]>;
+export declare function runSequence<T>(array: T[]): Promise<T[]>;

data/vendor/node_modules/rollup/dist/typings/utils/relativeId.d.ts

@@ -0,0 +1 @@
+export default function relativeId(id: string): string;

data/vendor/node_modules/rollup/dist/typings/utils/renderHelpers.d.ts

@@ -0,0 +1,26 @@
+import { Node } from '../ast/nodes/shared/Node';
+import MagicString from 'magic-string';
+import { DynamicImportMechanism } from '../Chunk';
+export interface RenderOptions {
+    legacy: boolean;
+    freeze: boolean;
+    namespaceToStringTag: boolean;
+    indent: string;
+    importMechanism?: DynamicImportMechanism;
+    systemBindings: boolean;
+}
+export interface NodeRenderOptions {
+    start?: number;
+    end?: number;
+    isNoStatement?: boolean;
+}
+export declare const NO_SEMICOLON: NodeRenderOptions;
+export declare function findFirstOccurrenceOutsideComment(code: string, searchString: string, start?: number): number;
+export declare function renderStatementList(statements: Node[], code: MagicString, start: number, end: number, options: RenderOptions): void;
+export declare function getCommaSeparatedNodesWithBoundaries<N extends Node>(nodes: N[], code: MagicString, start: number, end: number): ({
+    node: N;
+    start: number;
+    separator: number | null;
+    contentEnd: number;
+    end: number;
+})[];

data/vendor/node_modules/rollup/dist/typings/utils/sourceMappingURL.d.ts

@@ -0,0 +1,3 @@
+declare let SOURCEMAPPING_URL: string;
+declare const SOURCEMAPPING_URL_RE: RegExp;
+export { SOURCEMAPPING_URL, SOURCEMAPPING_URL_RE };

data/vendor/node_modules/rollup/dist/typings/utils/timers.d.ts

@@ -0,0 +1,7 @@
+import { InputOptions } from '../rollup';
+export declare type SerializedTimings = {
+    [label: string]: number;
+};
+export declare function getTimings(): SerializedTimings;
+export declare let timeStart: (label: string, level?: number) => void, timeEnd: (label: string, level?: number) => void;
+export declare function initialiseTimers(inputOptions: InputOptions): void;

data/vendor/node_modules/rollup/dist/typings/utils/transform.d.ts

@@ -0,0 +1,25 @@
+/// <reference types="acorn" />
+import { IParse } from 'acorn';
+import { RollupError } from './error';
+import Graph from '../Graph';
+import { RawSourceMap } from 'source-map';
+import { Plugin, RollupWarning, SourceDescription } from '../rollup/index';
+import Program from '../ast/nodes/Program';
+export interface TransformContext {
+    parse: IParse;
+    warn(warning: RollupWarning, pos?: {
+        line: number;
+        column: number;
+    }): void;
+    error(err: RollupError, pos?: {
+        line: number;
+        column: number;
+    }): void;
+}
+export default function transform(graph: Graph, source: SourceDescription, id: string, plugins: Plugin[]): Promise<{
+    code: string;
+    originalCode: string;
+    originalSourcemap: any;
+    ast: Program;
+    sourcemapChain: RawSourceMap[];
+}>;

data/vendor/node_modules/rollup/dist/typings/utils/transformBundle.d.ts

@@ -0,0 +1,3 @@
+import { RawSourceMap } from 'source-map';
+import { OutputOptions, Plugin } from '../rollup/index';
+export default function transformBundle(code: string, plugins: Plugin[], sourcemapChain: RawSourceMap[], options: OutputOptions): Promise<string | void>;

data/vendor/node_modules/rollup/dist/typings/watch/chokidar.d.ts

@@ -0,0 +1,3 @@
+import * as chokidarType from 'chokidar';
+declare let chokidar: typeof chokidarType;
+export default chokidar;

data/vendor/node_modules/rollup/dist/typings/watch/fileWatchers.d.ts

@@ -0,0 +1,14 @@
+/// <reference types="node" />
+import * as fs from 'fs';
+import { WatchOptions, FSWatcher } from 'chokidar';
+import { Task } from './index';
+export declare function addTask(id: string, task: Task, chokidarOptions: WatchOptions, chokidarOptionsHash: string): void;
+export declare function deleteTask(id: string, target: Task, chokidarOptionsHash: string): void;
+export default class FileWatcher {
+    fileExists: boolean;
+    fsWatcher: FSWatcher | fs.FSWatcher;
+    tasks: Set<Task>;
+    constructor(id: string, chokidarOptions: WatchOptions, dispose: () => void);
+    close(): void;
+    trigger(): void;
+}

data/vendor/node_modules/rollup/dist/typings/watch/index.d.ts

@@ -0,0 +1,47 @@
+/// <reference types="node" />
+import { EventEmitter } from 'events';
+import { CachedChunk, CachedChunkSet, InputOptions, OutputOptions } from '../rollup/index';
+import { WatchOptions } from 'chokidar';
+export interface WatcherOptions {
+    chokidar?: boolean | WatchOptions;
+    include?: string[];
+    exclude?: string[];
+    clearScreen?: boolean;
+}
+export interface RollupWatchOptions extends InputOptions {
+    output?: OutputOptions;
+    watch?: WatcherOptions;
+}
+export declare class Watcher extends EventEmitter {
+    dirty: boolean;
+    running: boolean;
+    tasks: Task[];
+    succeeded: boolean;
+    constructor(configs: RollupWatchOptions[]);
+    close(): void;
+    _makeDirty(): void;
+    _run(): void;
+}
+export declare class Task {
+    watcher: Watcher;
+    dirty: boolean;
+    closed: boolean;
+    watched: Set<string>;
+    inputOptions: InputOptions;
+    cache: CachedChunk | CachedChunkSet;
+    chokidarOptions: WatchOptions;
+    chokidarOptionsHash: string;
+    outputFiles: string[];
+    outputs: OutputOptions[];
+    deprecations: {
+        old: string;
+        new: string;
+    }[];
+    filter: (id: string) => boolean;
+    constructor(watcher: Watcher, config: RollupWatchOptions);
+    close(): void;
+    makeDirty(): void;
+    run(): Promise<void>;
+    watchFile(id: string): void;
+}
+export default function watch(configs: RollupWatchOptions[]): Watcher;

data/vendor/node_modules/rollup/package.json

@@ -0,0 +1,122 @@
+{
+  "name": "rollup",
+  "version": "0.57.1",
+  "description": "Next-generation ES6 module bundler",
+  "main": "dist/rollup.js",
+  "module": "dist/rollup.es.js",
+  "jsnext:main": "dist/rollup.es.js",
+  "typings": "dist/typings/node-entry.d.ts",
+  "bin": {
+    "rollup": "./bin/rollup"
+  },
+  "scripts": {
+    "pretest": "npm run build",
+    "test": "npm run test:only && npm run test:typescript",
+    "test:only": "mocha",
+    "test:leak": "node --expose-gc test/leak/index.js",
+    "test:quick": "mocha -b",
+    "pretest:typescript": "rm -rf test/typescript/dist && rm -rf test/typescript/typings && cp -r dist test/typescript/ && cp -r typings test/typescript/",
+    "test:typescript": "tsc -p test/typescript",
+    "pretest-coverage": "npm run build",
+    "test-coverage": "rm -rf coverage/* && istanbul cover --report json node_modules/.bin/_mocha -- -u exports -R spec test/test.js",
+    "posttest-coverage": "remap-istanbul -i coverage/coverage-final.json -o coverage/coverage-remapped.json -b dist && remap-istanbul -i coverage/coverage-final.json -o coverage/coverage-remapped.lcov -t lcovonly -b dist && remap-istanbul -i coverage/coverage-final.json -o coverage/coverage-remapped -t html -b dist",
+    "ci": "npm run test-coverage && codecov < coverage/coverage-remapped.lcov",
+    "prebuild": "rm -rf dist",
+    "build": "git rev-parse HEAD > .commithash && rollup -c && tsc -p tsconfig-types.json && chmod a+x bin/rollup",
+    "watch": "rollup -cw",
+    "prepublishOnly": "npm run lint && npm run test && npm run test:leak",
+    "prepare": "npm run build",
+    "lint": "eslint src browser bin test/test.js test/*/index.js test/utils test/**/_config.js",
+    "precommit": "lint-staged",
+    "postcommit": "git reset",
+    "perf": "node --expose-gc scripts/perf.js",
+    "perf:init": "node scripts/perf-init.js",
+    "perf:debug": "node --inspect-brk scripts/perf-debug.js"
+  },
+  "repository": "rollup/rollup",
+  "keywords": [
+    "modules",
+    "bundler",
+    "bundling",
+    "es6",
+    "optimizer"
+  ],
+  "author": "Rich Harris",
+  "contributors": [
+    "Oskar Segersvärd <victorystick@gmail.com>",
+    "Bogdan Chadkin <trysound@yandex.ru>"
+  ],
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/rollup/rollup/issues"
+  },
+  "homepage": "https://github.com/rollup/rollup",
+  "dependencies": {
+    "@types/acorn": "^4.0.3",
+    "acorn": "^5.5.3",
+    "acorn-dynamic-import": "^3.0.0",
+    "locate-character": "^2.0.5",
+    "pretty-ms": "^3.1.0",
+    "signal-exit": "^3.0.2",
+    "date-time": "^2.1.0",
+    "is-reference": "^1.1.0",
+    "sourcemap-codec": "^1.4.1",
+    "require-relative": "^0.8.7",
+    "rollup-pluginutils": "^2.0.1"
+  },
+  "devDependencies": {
+    "@types/chokidar": "^1.7.5",
+    "@types/minimist": "^1.2.0",
+    "@types/node": "^9.4.7",
+    "@types/pretty-ms": "^3.0.0",
+    "ansi-escapes": "^3.0.0",
+    "buble": "^0.19.3",
+    "cash-cp": "^0.2.0",
+    "cash-rm": "^0.2.0",
+    "chalk": "^2.3.2",
+    "codecov.io": "^0.1.6",
+    "console-group": "^0.3.1",
+    "eslint": "^4.18.2",
+    "eslint-plugin-import": "^2.9.0",
+    "execa": "^0.9.0",
+    "fixturify": "^0.3.4",
+    "husky": "^0.14.3",
+    "immutable": "^3.8.2",
+    "istanbul": "^0.4.3",
+    "lint-staged": "^7.0.0",
+    "magic-string": "^0.23.2",
+    "minimist": "^1.2.0",
+    "mocha": "^5.0.4",
+    "prettier": "^1.10.2",
+    "remap-istanbul": "^0.10.1",
+    "rollup": "^0.56.5",
+    "rollup-plugin-buble": "^0.19.2",
+    "rollup-plugin-commonjs": "^9.1.0",
+    "rollup-plugin-json": "^2.3.0",
+    "rollup-plugin-node-resolve": "^3.2.0",
+    "rollup-plugin-replace": "^2.0.0",
+    "rollup-plugin-string": "^2.0.0",
+    "rollup-plugin-typescript": "^0.8.1",
+    "rollup-watch": "^4.3.1",
+    "sander": "^0.6.0",
+    "source-map": "^0.6.1",
+    "source-map-support": "^0.5.3",
+    "typescript": "^2.7.2",
+    "uglify-js": "^3.3.14"
+  },
+  "files": [
+    "dist/rollup.browser.js",
+    "dist/rollup.es.js",
+    "dist/rollup.js",
+    "dist/**/*.d.ts",
+    "typings/package.json.d.ts",
+    "bin/rollup",
+    "README.md"
+  ],
+  "lint-staged": {
+    "*.ts": [
+      "prettier --write",
+      "git add"
+    ]
+  }
+}

data/vendor/node_modules/rollup/typings/package.json.d.ts

@@ -0,0 +1,3 @@
+declare module 'package.json' {
+	const version: string;
+}

data/vendor/node_modules/signal-exit/index.js

@@ -0,0 +1,157 @@
+// Note: since nyc uses this module to output coverage, any lines
+// that are in the direct sync flow of nyc's outputCoverage are
+// ignored, since we can never get coverage for them.
+var assert = require('assert')
+var signals = require('./signals.js')
+
+var EE = require('events')
+/* istanbul ignore if */
+if (typeof EE !== 'function') {
+  EE = EE.EventEmitter
+}
+
+var emitter
+if (process.__signal_exit_emitter__) {
+  emitter = process.__signal_exit_emitter__
+} else {
+  emitter = process.__signal_exit_emitter__ = new EE()
+  emitter.count = 0
+  emitter.emitted = {}
+}
+
+// Because this emitter is a global, we have to check to see if a
+// previous version of this library failed to enable infinite listeners.
+// I know what you're about to say.  But literally everything about
+// signal-exit is a compromise with evil.  Get used to it.
+if (!emitter.infinite) {
+  emitter.setMaxListeners(Infinity)
+  emitter.infinite = true
+}
+
+module.exports = function (cb, opts) {
+  assert.equal(typeof cb, 'function', 'a callback must be provided for exit handler')
+
+  if (loaded === false) {
+    load()
+  }
+
+  var ev = 'exit'
+  if (opts && opts.alwaysLast) {
+    ev = 'afterexit'
+  }
+
+  var remove = function () {
+    emitter.removeListener(ev, cb)
+    if (emitter.listeners('exit').length === 0 &&
+        emitter.listeners('afterexit').length === 0) {
+      unload()
+    }
+  }
+  emitter.on(ev, cb)
+
+  return remove
+}
+
+module.exports.unload = unload
+function unload () {
+  if (!loaded) {
+    return
+  }
+  loaded = false
+
+  signals.forEach(function (sig) {
+    try {
+      process.removeListener(sig, sigListeners[sig])
+    } catch (er) {}
+  })
+  process.emit = originalProcessEmit
+  process.reallyExit = originalProcessReallyExit
+  emitter.count -= 1
+}
+
+function emit (event, code, signal) {
+  if (emitter.emitted[event]) {
+    return
+  }
+  emitter.emitted[event] = true
+  emitter.emit(event, code, signal)
+}
+
+// { <signal>: <listener fn>, ... }
+var sigListeners = {}
+signals.forEach(function (sig) {
+  sigListeners[sig] = function listener () {
+    // If there are no other listeners, an exit is coming!
+    // Simplest way: remove us and then re-send the signal.
+    // We know that this will kill the process, so we can
+    // safely emit now.
+    var listeners = process.listeners(sig)
+    if (listeners.length === emitter.count) {
+      unload()
+      emit('exit', null, sig)
+      /* istanbul ignore next */
+      emit('afterexit', null, sig)
+      /* istanbul ignore next */
+      process.kill(process.pid, sig)
+    }
+  }
+})
+
+module.exports.signals = function () {
+  return signals
+}
+
+module.exports.load = load
+
+var loaded = false
+
+function load () {
+  if (loaded) {
+    return
+  }
+  loaded = true
+
+  // This is the number of onSignalExit's that are in play.
+  // It's important so that we can count the correct number of
+  // listeners on signals, and don't wait for the other one to
+  // handle it instead of us.
+  emitter.count += 1
+
+  signals = signals.filter(function (sig) {
+    try {
+      process.on(sig, sigListeners[sig])
+      return true
+    } catch (er) {
+      return false
+    }
+  })
+
+  process.emit = processEmit
+  process.reallyExit = processReallyExit
+}
+
+var originalProcessReallyExit = process.reallyExit
+function processReallyExit (code) {
+  process.exitCode = code || 0
+  emit('exit', process.exitCode, null)
+  /* istanbul ignore next */
+  emit('afterexit', process.exitCode, null)
+  /* istanbul ignore next */
+  originalProcessReallyExit.call(process, process.exitCode)
+}
+
+var originalProcessEmit = process.emit
+function processEmit (ev, arg) {
+  if (ev === 'exit') {
+    if (arg !== undefined) {
+      process.exitCode = arg
+    }
+    var ret = originalProcessEmit.apply(this, arguments)
+    emit('exit', process.exitCode, null)
+    /* istanbul ignore next */
+    emit('afterexit', process.exitCode, null)
+    return ret
+  } else {
+    return originalProcessEmit.apply(this, arguments)
+  }
+}