@proteinjs/reflection-build 1.2.1 → 1.4.0

package/test/examples/source-repository/a/node_modules/@proteinjs/reflection/src/SourceRepository.ts

@@ -1,250 +0,0 @@
-import { Graph } from '@dagrejs/graphlib';
-import { graphSerializer, isInstanceOf } from '@proteinjs/util';
-import { SourceType } from './sourceGraphTypes';
-import {
-  VariableDeclaration,
-  TypeAliasDeclaration,
-  ClassDeclaration,
-  InterfaceDeclaration,
-  Class,
-  Variable,
-  TypeAlias,
-  Interface,
-  PackageScope,
-} from './types';
-import { FlattenedSourceGraph, flattenSourceGraph } from './FlattenedSourceGraph';
-import { SOURCE_REPOSITORY_FILTER_QUALIFIED_NAME, getSourceRepositoryFilters } from './SourceRepositoryFilter';
-
-type TypeMap = { [qualifiedName: string]: Interface | TypeAlias | Class | Variable };
-
-export class SourceRepository {
-  public readonly sourceGraph = new Graph();
-  private readonly sourceLinks: { [qualifiedName: string]: any } = {};
-  public flattenedSourceGraph: FlattenedSourceGraph = { variables: {}, typeAliases: {}, classes: {}, interfaces: {} };
-  // private readonly typeCache: { [type: string]: (ClassDeclaration|VariableDeclaration)[] } = {};
-  private readonly objectCache: { [type: string]: any[] } = {};
-
-  private constructor() {}
-
-  static get(): SourceRepository {
-    if (!SourceRepository.getGlobal().__proteinjs_reflection_SourceRepository) {
-      SourceRepository.getGlobal().__proteinjs_reflection_SourceRepository = new SourceRepository();
-    }
-
-    return SourceRepository.getGlobal().__proteinjs_reflection_SourceRepository;
-  }
-
-  private static getGlobal(): any {
-    if (typeof window !== 'undefined') {
-      return window;
-    }
-
-    return globalThis;
-  }
-
-  interface(qualifiedInterfaceName: string) {
-    return this.flattenedSourceGraph.interfaces[qualifiedInterfaceName];
-  }
-
-  interfaceExtends(_interface: Interface, type: string) {
-    return typeof _interface.allParents[type] !== 'undefined';
-  }
-
-  /**
-   * Same as SourceRepository.objects except assumes it will find only 1 object.
-   *
-   * @param extendingType a Type or Interface that the Class or Variable extends
-   * @return variable or instantiated class that extends `extendingType`
-   */
-  object<T>(extendingType: string): T {
-    return this.objects<T>(extendingType)[0];
-  }
-
-  /**
-   * @param extendingType a Type, Interface, or Class that the Class or Variable extends
-   * @return variables and instantiated classes that extend `extendingType`
-   */
-  objects<T>(extendingType: string): T[] {
-    if (this.objectCache[extendingType]) {
-      return this.objectCache[extendingType];
-    }
-
-    const baseChildren = this.baseChildren(extendingType);
-    const extendingObjects: T[] = [];
-    for (const baseChildQualifiedName in baseChildren) {
-      const child = baseChildren[baseChildQualifiedName];
-      if (isInstanceOf(child, Class)) {
-        extendingObjects.push(new (child as any)._constructor());
-      } else if (isInstanceOf(child, Variable)) {
-        extendingObjects.push((child as any).value);
-      }
-    }
-
-    this.objectCache[extendingType] = extendingObjects;
-    return extendingObjects;
-  }
-
-  /**
-   * @param extendingType a Type, Interface, or Class that the Class or Variable extends
-   * @returns a hashmap (key is qualified name) of base child types (vs the instantiated objects provided by the objects method) that extend `extendingType`
-   */
-  baseChildren(extendingType: string): TypeMap {
-    const _interface = SourceRepository.get().flattenedSourceGraph.interfaces[extendingType];
-    const typeAlias = SourceRepository.get().flattenedSourceGraph.typeAliases[extendingType];
-    const _class = SourceRepository.get().flattenedSourceGraph.classes[extendingType];
-    let baseChildren: TypeMap;
-    if (_interface) {
-      baseChildren = _interface.baseChildren;
-    } else if (typeAlias) {
-      baseChildren = typeAlias.baseChildren;
-    } else if (_class) {
-      baseChildren = _class.baseChildren;
-    } else {
-      throw new Error(`Unable to find type: ${extendingType}`);
-    }
-
-    if (extendingType === SOURCE_REPOSITORY_FILTER_QUALIFIED_NAME) {
-      return baseChildren;
-    }
-
-    return this.filterObjects(baseChildren);
-  }
-
-  /**
-   * @param extendingType a Type, Interface, or Class that the Class or Variable extends
-   * @returns a hashmap (key is qualified name) of direct child types (vs the instantiated objects provided by the objects method) that extend `extendingType`
-   */
-  directChildren(extendingType: string): TypeMap {
-    const _interface = SourceRepository.get().flattenedSourceGraph.interfaces[extendingType];
-    const typeAlias = SourceRepository.get().flattenedSourceGraph.typeAliases[extendingType];
-    const _class = SourceRepository.get().flattenedSourceGraph.classes[extendingType];
-    let directChildren: any;
-    if (_interface) {
-      directChildren = _interface.directChildren;
-    } else if (typeAlias) {
-      directChildren = typeAlias.directChildren;
-    } else if (_class) {
-      directChildren = _class.directChildren;
-    } else {
-      throw new Error(`Unable to find type: ${extendingType}`);
-    }
-
-    if (extendingType === SOURCE_REPOSITORY_FILTER_QUALIFIED_NAME) {
-      return directChildren;
-    }
-
-    return this.filterObjects(directChildren);
-  }
-
-  private filterObjects(typeMap: TypeMap): TypeMap {
-    const filteredTypeMap: TypeMap = {};
-    const filters = getSourceRepositoryFilters();
-    for (const qualifiedName of Object.keys(typeMap)) {
-      const packageScope = typeMap[qualifiedName];
-      let filtered = true;
-      for (const filter of filters) {
-        if (!filter.filterObject(qualifiedName)) {
-          filtered = false;
-          break;
-        }
-      }
-
-      if (filtered) {
-        filteredTypeMap[qualifiedName] = packageScope;
-      }
-    }
-
-    return filteredTypeMap;
-  }
-
-  static merge(serializedSourceGraph: string, sourceLinks: { [qualifiedName: string]: any }) {
-    const unescapedSerializedSourceGraph = serializedSourceGraph.replace(/\\'/g, "'");
-    const sourceGraph = graphSerializer.deserialize(unescapedSerializedSourceGraph);
-    for (const nodeName of sourceGraph.nodes()) {
-      const nodeValue = sourceGraph.node(nodeName);
-      if (!nodeValue) {
-        continue;
-      }
-
-      SourceRepository.get().sourceGraph.setNode(nodeName, SourceRepository.deserializeClass(nodeValue));
-    }
-
-    for (const edge of sourceGraph.edges()) {
-      const edgeValue = sourceGraph.edge(edge);
-      SourceRepository.get().sourceGraph.setEdge(edge, edgeValue);
-    }
-
-    Object.assign(SourceRepository.get().sourceLinks, sourceLinks);
-    SourceRepository.get().flattenedSourceGraph = flattenSourceGraph(
-      SourceRepository.get().sourceGraph,
-      SourceRepository.get().sourceLinks
-    );
-  }
-
-  private static deserializeClass(classJson: any): any {
-    if (classJson.sourceType === SourceType.variable) {
-      return VariableDeclaration.deserialize(classJson);
-    } else if (classJson.sourceType === SourceType.typeAlias) {
-      return TypeAliasDeclaration.deserialize(classJson);
-    } else if (classJson.sourceType === SourceType.class) {
-      return ClassDeclaration.deserialize(classJson);
-    } else if (classJson.sourceType === SourceType.interface) {
-      return InterfaceDeclaration.deserialize(classJson);
-    }
-
-    return classJson;
-  }
-
-  // objects<T>(type: string): T[] {
-  // 	if (!this.objectCache[type]) {
-  // 		this.objectCache[type] = this.types(type).map((type) => {
-  // 			if (type instanceof VariableDeclaration)
-  // 				return type.value;
-
-  // 			if (type instanceof ClassDeclaration)
-  // 				return new type._constructor();
-
-  // 			return null;
-  // 		});
-  // 	}
-
-  // 	return this.objectCache[type];
-  // }
-
-  // types(parentType: string): (ClassDeclaration|VariableDeclaration)[] {
-  // 	if (!this.typeCache[parentType]) {
-  // 		const node = this.sourceGraph.node(parentType);
-  // 		if (!node)
-  // 			throw new Error(`Failed to find types, reason: parent type does not exist: ${parentType}`);
-
-  // 		const collectedTypes: (ClassDeclaration|VariableDeclaration)[] = [];
-  // 		this.collectTypes(parentType, collectedTypes);
-  // 		this.typeCache[parentType] = collectedTypes;
-  // 	}
-
-  // 	return this.typeCache[parentType];
-  // }
-
-  // private collectTypes(type: string, collectedTypes: (ClassDeclaration|VariableDeclaration)[]): void {
-  // 	const childTypes = this.sourceGraph.successors(type);
-  // 	if (!childTypes)
-  // 		return;
-
-  // 	for (const childType of childTypes) {
-  // 		const childNode = this.sourceGraph.node(childType);
-  // 		if (!childNode)
-  // 			continue;
-
-  // 		const sourceLink = this.sourceLinks[childNode.qualifiedName];
-  // 		if (childNode instanceof VariableDeclaration) {
-  // 			childNode.value = sourceLink;
-  // 			collectedTypes.push(childNode);
-  // 		} else if (childNode instanceof ClassDeclaration && !childNode.isAbstract) {
-  // 			childNode._constructor = sourceLink;
-  // 			collectedTypes.push(childNode);
-  // 		}
-
-  // 		this.collectTypes(childType, collectedTypes);
-  // 	}
-  // }
-}

package/test/examples/source-repository/a/node_modules/@proteinjs/reflection/src/SourceRepositoryFilter.ts

@@ -1,15 +0,0 @@
-import { Loadable } from './Loadable';
-import { SourceRepository } from './SourceRepository';
-
-export const SOURCE_REPOSITORY_FILTER_QUALIFIED_NAME = '@proteinjs/reflection/SourceRepositoryFilter';
-export const getSourceRepositoryFilters = () =>
-  SourceRepository.get().objects<SourceRepositoryFilter>(SOURCE_REPOSITORY_FILTER_QUALIFIED_NAME);
-
-export interface SourceRepositoryFilter extends Loadable {
-  /**
-   * Filter objects that would be returned by `SourceRepository.object` and `SourceRepository.objects`
-   * @param qualifiedName the package-qualified name of the object to be filtered (ie. `@dependency/package/ClassName`)
-   * @return true if the object should be returned by the `SourceRepository`
-   */
-  filterObject(qualifiedName: string): boolean;
-}

package/test/examples/source-repository/a/node_modules/@proteinjs/reflection/src/sourceGraphTypes.ts

@@ -1,14 +0,0 @@
-export enum SourceType {
-  variable,
-  typeAlias,
-  class,
-  interface,
-}
-
-export enum SourceRelationship {
-  hasType = 'has type',
-  extendsType = 'extends type',
-  extendsClass = 'extends class',
-  implementsInterface = 'implements interface',
-  extendsInterface = 'extends interface',
-}

package/test/examples/source-repository/a/node_modules/@proteinjs/reflection/src/types.ts

@@ -1,236 +0,0 @@
-export abstract class PackageScope {
-  public readonly qualifiedName: string;
-
-  constructor(
-    public readonly packageName: string,
-    public readonly name: string,
-    public readonly filePath?: string
-  ) {
-    this.qualifiedName = `${packageName}/${name}`;
-  }
-}
-
-export class Variable extends PackageScope {
-  constructor(
-    packageName: string,
-    name: string,
-    filePath: string,
-    public readonly isExported: boolean,
-    public readonly isConst: boolean,
-    public readonly value: any,
-    public readonly typeParameters: { [qualifiedName: string]: (TypeAlias | Interface)[] } = {},
-    public directParentTypes: { [qualifiedName: string]: TypeAlias | Interface } = {},
-    public allParentTypes: { [qualifiedName: string]: TypeAlias | Interface } = {},
-    public rootParentTypes: { [qualifiedName: string]: TypeAlias | Interface } = {}
-  ) {
-    super(packageName, name, filePath);
-  }
-}
-
-export class TypeAlias extends PackageScope {
-  constructor(
-    packageName: string,
-    name: string,
-    filePath?: string,
-    public readonly typeParameters: { [qualifiedName: string]: (TypeAlias | Interface)[] } = {},
-    public readonly directParents: { [qualifiedName: string]: TypeAlias | Interface } = {},
-    public allParents: { [qualifiedName: string]: TypeAlias | Interface } = {},
-    public rootParents: { [qualifiedName: string]: TypeAlias | Interface } = {},
-    public directChildren: { [qualifiedName: string]: TypeAlias | Variable } = {},
-    public allChildren: { [qualifiedName: string]: TypeAlias | Variable } = {},
-    public baseChildren: { [qualifiedName: string]: TypeAlias | Variable } = {}
-  ) {
-    super(packageName, name, filePath);
-  }
-}
-
-export class Class extends PackageScope {
-  constructor(
-    packageName: string,
-    name: string,
-    filePath: string,
-    public readonly isAbstract: boolean,
-    public readonly isStatic: boolean,
-    public readonly visibility: Visibility,
-    public readonly properties: Property[],
-    public readonly methods: Method[],
-    public readonly _constructor: any,
-    public readonly directParents: { [qualifiedName: string]: Class | Interface | TypeAlias } = {},
-    public readonly typeParameters: { [qualifiedName: string]: (TypeAlias | Interface | TypeAlias)[] } = {},
-    public allParents: { [qualifiedName: string]: Class | Interface | TypeAlias } = {},
-    public rootParents: { [qualifiedName: string]: Class | Interface | TypeAlias } = {},
-    public directChildren: { [qualifiedName: string]: Class } = {},
-    public allChildren: { [qualifiedName: string]: Class } = {},
-    public baseChildren: { [qualifiedName: string]: Class } = {}
-  ) {
-    super(packageName, name, filePath);
-  }
-}
-
-export class Interface extends PackageScope {
-  constructor(
-    packageName: string,
-    name: string,
-    public readonly properties: Property[],
-    public readonly methods: Method[],
-    filePath?: string,
-    public readonly typeParameters: { [qualifiedName: string]: (TypeAlias | Interface)[] } = {},
-    public readonly directParents: { [qualifiedName: string]: Interface | TypeAlias } = {},
-    public allParents: { [qualifiedName: string]: Interface | TypeAlias } = {},
-    public rootParents: { [qualifiedName: string]: Interface | TypeAlias } = {},
-    public readonly directChildren: { [qualifiedName: string]: Interface | TypeAlias | Class | Variable } = {},
-    public allChildren: { [qualifiedName: string]: Interface | TypeAlias | Class | Variable } = {},
-    public baseChildren: { [qualifiedName: string]: Interface | TypeAlias | Class | Variable } = {}
-  ) {
-    super(packageName, name, filePath);
-  }
-}
-
-export class Method {
-  constructor(
-    public readonly name: string,
-    public readonly returnType: TypeAliasDeclaration | undefined,
-    public readonly isAsync: boolean,
-    public readonly isOptional: boolean,
-    public readonly isAbstract: boolean,
-    public readonly isStatic: boolean,
-    public readonly visibility: Visibility,
-    public readonly parameters: Parameter[]
-    // public readonly variables: VariableDeclaration[]
-  ) {}
-}
-
-export type Visibility = 'public' | 'protected' | 'private' | undefined;
-
-export class Property {
-  constructor(
-    public readonly name: string,
-    public readonly type: TypeAliasDeclaration | undefined,
-    public readonly isOptional: boolean,
-    public readonly isAbstract: boolean,
-    public readonly isStatic: boolean,
-    public readonly visibility: Visibility
-  ) {}
-}
-
-export class Parameter {
-  constructor(
-    public readonly name: string,
-    public readonly type: TypeAliasDeclaration | undefined
-    // public readonly isOptional: boolean
-  ) {}
-}
-
-/**
- * Declarations are intermediary types created by the parser. They do not contain the deeply-nested, relational
- * information possible at runtime.
- *
- * Note: The declaration types specified in typescript-parser are not used because they are not package-scoped.
- * The typescript-parser package is a file-level parser, and reflection is a package-level parser.
- */
-
-export class VariableDeclaration extends PackageScope {
-  constructor(
-    packageName: string,
-    name: string,
-    filePath: string,
-    public type: TypeAliasDeclaration,
-    public isExported: boolean,
-    public isConst: boolean
-  ) {
-    super(packageName, name, filePath);
-  }
-
-  static deserialize(json: any): VariableDeclaration {
-    return new VariableDeclaration(
-      json.packageName,
-      json.name,
-      json.filePath,
-      json.type,
-      json.isExported,
-      json.isConst
-    );
-  }
-}
-
-export class TypeAliasDeclaration extends PackageScope {
-  constructor(
-    packageName: string,
-    name: string,
-    public typeParameters?: string[],
-    public directParents?: TypeAliasDeclaration[],
-    filePath?: string
-  ) {
-    super(packageName, name, filePath);
-  }
-
-  static deserialize(json: any): TypeAliasDeclaration {
-    return new TypeAliasDeclaration(
-      json.packageName,
-      json.name,
-      json.typeParameters,
-      json.directParents,
-      json.filePath
-    );
-  }
-}
-
-export class ClassDeclaration extends PackageScope {
-  constructor(
-    packageName: string,
-    name: string,
-    public readonly isAbstract: boolean,
-    public readonly isStatic: boolean,
-    public readonly visibility: Visibility,
-    public readonly properties: Property[],
-    public readonly methods: Method[],
-    public readonly typeParameters: string[],
-    public readonly directParentInterfaces: InterfaceDeclaration[],
-    public readonly directParentClasses: ClassDeclaration[],
-    filePath?: string
-  ) {
-    super(packageName, name, filePath);
-  }
-
-  static deserialize(json: any): ClassDeclaration {
-    return new ClassDeclaration(
-      json.packageName,
-      json.name,
-      json.isAbstract,
-      json.isStatic,
-      json.visibility,
-      json.properties,
-      json.methods,
-      json.typeParameters,
-      json.directParentInterfaces,
-      json.directParentClasses,
-      json.filePath
-    );
-  }
-}
-
-export class InterfaceDeclaration extends PackageScope {
-  constructor(
-    packageName: string,
-    name: string,
-    public readonly properties: Property[],
-    public readonly methods: Method[],
-    public readonly typeParameters: string[],
-    public readonly directParents: InterfaceDeclaration[],
-    filePath?: string
-  ) {
-    super(packageName, name, filePath);
-  }
-
-  static deserialize(json: any): InterfaceDeclaration {
-    return new InterfaceDeclaration(
-      json.packageName,
-      json.name,
-      json.properties,
-      json.methods,
-      json.typeParameters,
-      json.directParents,
-      json.filePath
-    );
-  }
-}

package/test/examples/source-repository/a/node_modules/@proteinjs/reflection/tsconfig.json

@@ -1,19 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "es5",
-    "module": "commonjs",
-    "declaration": true,
-    "sourceMap": true,
-    "outDir": "./dist/",
-    "strict": true,
-    "noImplicitAny": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "resolveJsonModule": true,
-    "baseUrl": "./",
-    "paths": { "*": ["types/*"] },
-    "types": ["node", "jest"]
-  },
-  "include": ["./index.ts"]
-}

package/test/examples/source-repository/a/node_modules/@proteinjs/reflection/types/@dagrejs/graphlib.d.ts

@@ -1 +0,0 @@
-export * from 'graphlib';

package/test/examples/source-repository/a/node_modules/bindings/LICENSE.md

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

package/test/examples/source-repository/a/node_modules/bindings/README.md

@@ -1,98 +0,0 @@
-node-bindings
-=============
-### Helper module for loading your native module's `.node` file
-
-This is a helper module for authors of Node.js native addon modules.
-It is basically the "swiss army knife" of `require()`ing your native module's
-`.node` file.
-
-Throughout the course of Node's native addon history, addons have ended up being
-compiled in a variety of different places, depending on which build tool and which
-version of node was used. To make matters worse, now the `gyp` build tool can
-produce either a __Release__ or __Debug__ build, each being built into different
-locations.
-
-This module checks _all_ the possible locations that a native addon would be built
-at, and returns the first one that loads successfully.
-
-
-Installation
-------------
-
-Install with `npm`:
-
-``` bash
-$ npm install --save bindings
-```
-
-Or add it to the `"dependencies"` section of your `package.json` file.
-
-
-Example
--------
-
-`require()`ing the proper bindings file for the current node version, platform
-and architecture is as simple as:
-
-``` js
-var bindings = require('bindings')('binding.node')
-
-// Use your bindings defined in your C files
-bindings.your_c_function()
-```
-
-
-Nice Error Output
------------------
-
-When the `.node` file could not be loaded, `node-bindings` throws an Error with
-a nice error message telling you exactly what was tried. You can also check the
-`err.tries` Array property.
-
-```
-Error: Could not load the bindings file. Tried:
- → /Users/nrajlich/ref/build/binding.node
- → /Users/nrajlich/ref/build/Debug/binding.node
- → /Users/nrajlich/ref/build/Release/binding.node
- → /Users/nrajlich/ref/out/Debug/binding.node
- → /Users/nrajlich/ref/Debug/binding.node
- → /Users/nrajlich/ref/out/Release/binding.node
- → /Users/nrajlich/ref/Release/binding.node
- → /Users/nrajlich/ref/build/default/binding.node
- → /Users/nrajlich/ref/compiled/0.8.2/darwin/x64/binding.node
-    at bindings (/Users/nrajlich/ref/node_modules/bindings/bindings.js:84:13)
-    at Object.<anonymous> (/Users/nrajlich/ref/lib/ref.js:5:47)
-    at Module._compile (module.js:449:26)
-    at Object.Module._extensions..js (module.js:467:10)
-    at Module.load (module.js:356:32)
-    at Function.Module._load (module.js:312:12)
-    ...
-```
-
-The searching for the `.node` file will originate from the first directory in which has a `package.json` file is found.
-
-License
--------
-
-(The MIT License)
-
-Copyright (c) 2012 Nathan Rajlich &lt;nathan@tootallnate.net&gt;
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-'Software'), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
-IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
-TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
-SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.