updated static resources

src/plone/staticresources/static/components/ace-builds/README.md

@@ -0,0 +1,21 @@
+Ace (Ajax.org Cloud9 Editor)
+============================
+
+Ace is a code editor written in JavaScript.
+
+This repository has only generated files.
+If you want to work on ace please go to https://github.com/ajaxorg/ace instead.
+
+
+here you can find pre-built files for convenience of embedding.
+it contains 4 versions
+ * [src](https://github.com/ajaxorg/ace-builds/tree/master/src)              concatenated but not minified
+ * [src-min](https://github.com/ajaxorg/ace-builds/tree/master/src-min)      concatenated and minified with uglify.js
+ * [src-noconflict](https://github.com/ajaxorg/ace-builds/tree/master/src-noconflict)      uses ace.require instead of require
+ * [src-min-noconflict](https://github.com/ajaxorg/ace-builds/tree/master/src-min-noconflict)      -
+
+
+For a simple way of embedding ace into webpage see [editor.html](https://github.com/ajaxorg/ace-builds/blob/master/editor.html) or list of other [simple examples](https://github.com/ajaxorg/ace-builds/tree/master/demo)
+To see ace in action go to [kitchen-sink-demo](http://ajaxorg.github.com/ace-builds/kitchen-sink.html), [scrollable-page-demo](http://ajaxorg.github.com/ace-builds/demo/scrollable-page.html) or [minimal demo](http://ajaxorg.github.com/ace-builds/editor.html),
+
+

src/plone/staticresources/static/components/ace-builds/bower.json

@@ -0,0 +1,21 @@
+{
+    "name": "ace-builds",
+    "version": "1.2.3",
+    "description": "Ace (Ajax.org Cloud9 Editor)",
+    "scripts": {
+        "test": "echo \"Error: no test specified\" && exit 1"
+    },
+    "ignore": [
+        "demo"
+    ],
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/ajaxorg/ace-builds.git"
+    },
+    "author": "",
+    "license": "BSD",
+    "bugs": {
+        "url": "https://github.com/ajaxorg/ace-builds/issues"
+    },
+    "homepage": "https://github.com/ajaxorg/ace-builds"
+}

src/plone/staticresources/static/components/ace-builds/package.json

@@ -0,0 +1,18 @@
+{
+    "name": "ace-builds",
+    "version": "1.2.6",
+    "description": "Ace (Ajax.org Cloud9 Editor)",
+    "scripts": {
+        "test": "echo \"Error: no test specified\" && exit 1"
+    },
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/ajaxorg/ace-builds.git"
+    },
+    "author": "",
+    "license": "BSD",
+    "bugs": {
+        "url": "https://github.com/ajaxorg/ace-builds/issues"
+    },
+    "homepage": "https://github.com/ajaxorg/ace-builds"
+}

src/plone/staticresources/static/components/ajv/lib/ajv.d.ts

@@ -0,0 +1,284 @@
+declare var ajv: { 
+  (options?: ajv.Options): ajv.Ajv;
+  new (options?: ajv.Options): ajv.Ajv;
+}
+
+declare namespace ajv {
+  interface Ajv {
+    /**
+    * Validate data using schema
+    * Schema will be compiled and cached (using serialized JSON as key. [json-stable-stringify](https://github.com/substack/json-stable-stringify) is used to serialize.
+    * @param  {String|Object} schemaKeyRef key, ref or schema object
+    * @param  {Any} data to be validated
+    * @return {Boolean} validation result. Errors from the last validation will be available in `ajv.errors` (and also in compiled schema: `schema.errors`).
+    */
+    validate(schemaKeyRef: Object | string, data: any): boolean;
+    /**
+    * Create validating function for passed schema.
+    * @param  {Object} schema schema object
+    * @return {Function} validating function
+    */
+    compile(schema: Object): ValidateFunction;
+    /**
+    * Creates validating function for passed schema with asynchronous loading of missing schemas.
+    * `loadSchema` option should be a function that accepts schema uri and node-style callback.
+    * @this  Ajv
+    * @param {Object}   schema schema object
+    * @param {Function} callback node-style callback, it is always called with 2 parameters: error (or null) and validating function.
+    */
+    compileAsync(schema: Object, callback: (err: Error, validate: ValidateFunction) => any): void;
+    /**
+    * Adds schema to the instance.
+    * @param {Object|Array} schema schema or array of schemas. If array is passed, `key` and other parameters will be ignored.
+    * @param {String} key Optional schema key. Can be passed to `validate` method instead of schema object or id/ref. One schema per instance can have empty `id` and `key`.
+    */
+    addSchema(schema: Array<Object> | Object, key?: string): void;
+    /**
+    * Add schema that will be used to validate other schemas
+    * options in META_IGNORE_OPTIONS are alway set to false
+    * @param {Object} schema schema object
+    * @param {String} key optional schema key
+    */
+    addMetaSchema(schema: Object, key?: string): void;
+    /**
+    * Validate schema
+    * @param {Object} schema schema to validate
+    * @return {Boolean} true if schema is valid
+    */
+    validateSchema(schema: Object): boolean;
+    /**
+    * Get compiled schema from the instance by `key` or `ref`.
+    * @param  {String} keyRef `key` that was passed to `addSchema` or full schema reference (`schema.id` or resolved id).
+    * @return {Function} schema validating function (with property `schema`).
+    */
+    getSchema(keyRef: string): ValidateFunction;
+    /**
+    * Remove cached schema(s).
+    * If no parameter is passed all schemas but meta-schemas are removed.
+    * If RegExp is passed all schemas with key/id matching pattern but meta-schemas are removed.
+    * Even if schema is referenced by other schemas it still can be removed as other schemas have local references.
+    * @param  {String|Object|RegExp} schemaKeyRef key, ref, pattern to match key/ref or schema object
+    */
+    removeSchema(schemaKeyRef?: Object | string | RegExp): void;
+    /**
+    * Add custom format
+    * @param {String} name format name
+    * @param {String|RegExp|Function} format string is converted to RegExp; function should return boolean (true when valid)
+    */
+    addFormat(name: string, format: FormatValidator | FormatDefinition): void;
+    /**
+    * Define custom keyword
+    * @this  Ajv
+    * @param {String} keyword custom keyword, should be a valid identifier, should be different from all standard, custom and macro keywords.
+    * @param {Object} definition keyword definition object with properties `type` (type(s) which the keyword applies to), `validate` or `compile`.
+    */
+    addKeyword(keyword: string, definition: KeywordDefinition): void;
+    /**
+    * Get keyword definition
+    * @this  Ajv
+    * @param {String} keyword pre-defined or custom keyword.
+    * @return {Object|Boolean} custom keyword definition, `true` if it is a predefined keyword, `false` otherwise.
+    */
+    getKeyword(keyword: string): Object | boolean;
+    /**
+    * Remove keyword
+    * @this  Ajv
+    * @param {String} keyword pre-defined or custom keyword.
+    */
+    removeKeyword(keyword: string): void;
+    /**
+    * Convert array of error message objects to string
+    * @param  {Array<Object>} errors optional array of validation errors, if not passed errors from the instance are used.
+    * @param  {Object} options optional options with properties `separator` and `dataVar`.
+    * @return {String} human readable string with all errors descriptions
+    */
+    errorsText(errors?: Array<ErrorObject>, options?: ErrorsTextOptions): string;
+    errors?: Array<ErrorObject>;
+  }
+
+  interface Thenable <R> {
+    then <U> (onFulfilled?: (value: R) => U | Thenable<U>, onRejected?: (error: any) => U | Thenable<U>): Thenable<U>;
+  }
+
+  interface ValidateFunction {
+    (
+      data: any,
+      dataPath?: string,
+      parentData?: Object | Array<any>,
+      parentDataProperty?: string | number,
+      rootData?: Object | Array<any>
+    ): boolean | Thenable<boolean>;
+    errors?: Array<ErrorObject>;
+    schema?: Object;
+  }
+
+  interface Options {
+    v5?: boolean;
+    allErrors?: boolean;
+    verbose?: boolean;
+    jsonPointers?: boolean;
+    uniqueItems?: boolean;
+    unicode?: boolean;
+    format?: string;
+    formats?: Object;
+    unknownFormats?: boolean | string | Array<string>;
+    schemas?: Array<Object> | Object;
+    ownProperties?: boolean;
+    missingRefs?: boolean | string;
+    extendRefs?: boolean | string;
+    loadSchema?: (uri: string, cb: (err: Error, schema: Object) => any) => any;
+    removeAdditional?: boolean | string;
+    useDefaults?: boolean | string;
+    coerceTypes?: boolean | string;
+    async?: boolean | string;
+    transpile?: string | ((code: string) => string);
+    meta?: boolean | Object;
+    validateSchema?: boolean | string;
+    addUsedSchema?: boolean;
+    inlineRefs?: boolean | number;
+    passContext?: boolean;
+    loopRequired?: number;
+    multipleOfPrecision?: number;
+    errorDataPath?: string;
+    messages?: boolean;
+    sourceCode?: boolean;
+    beautify?: boolean | Object;
+    cache?: Object;
+  }
+
+  type FormatValidator = string | RegExp | ((data: string) => boolean);
+
+  interface FormatDefinition {
+    validate: FormatValidator;
+    compare: (data1: string, data2: string) => number;
+    async?: boolean;
+  }
+
+  interface KeywordDefinition {
+    type?: string | Array<string>;
+    async?: boolean;
+    errors?: boolean | string;
+    // schema: false makes validate not to expect schema (ValidateFunction)
+    schema?: boolean;
+    modifying?: boolean;
+    valid?: boolean;
+    // one and only one of the following properties should be present
+    validate?: ValidateFunction | SchemaValidateFunction;
+    compile?: (schema: Object, parentSchema: Object) => ValidateFunction;
+    macro?: (schema: Object, parentSchema: Object) => Object;
+    inline?: (it: Object, keyword: string, schema: Object, parentSchema: Object) => string;
+  }
+
+  interface SchemaValidateFunction {
+    (
+      schema: Object,
+      data: any,
+      parentSchema?: Object,
+      dataPath?: string,
+      parentData?: Object | Array<any>,
+      parentDataProperty?: string | number
+    ): boolean | Thenable<boolean>;
+    errors?: Array<ErrorObject>;
+  }
+
+  interface ErrorsTextOptions {
+    separator?: string;
+    dataVar?: string;
+  }
+
+  interface ErrorObject {
+    keyword: string;
+    dataPath: string;
+    schemaPath: string;
+    params: ErrorParameters;
+    // Excluded if messages set to false.
+    message?: string;
+    // These are added with the `verbose` option.
+    schema?: Object;
+    parentSchema?: Object;
+    data?: any;
+  }
+
+  type ErrorParameters = RefParams | LimitParams | AdditionalPropertiesParams |
+                          DependenciesParams | FormatParams | ComparisonParams |
+                          MultipleOfParams | PatternParams | RequiredParams |
+                          TypeParams | UniqueItemsParams | CustomParams |
+                          PatternGroupsParams | PatternRequiredParams |
+                          SwitchParams | NoParams | EnumParams;
+
+  interface RefParams {
+    ref: string;
+  }
+
+  interface LimitParams {
+    limit: number;
+  }
+
+  interface AdditionalPropertiesParams {
+    additionalProperty: string;
+  }
+
+  interface DependenciesParams {
+    property: string;
+    missingProperty: string;
+    depsCount: number;
+    deps: string;
+  }
+
+  interface FormatParams {
+    format: string
+  }
+
+  interface ComparisonParams {
+    comparison: string;
+    limit: number | string;
+    exclusive: boolean;
+  }
+
+  interface MultipleOfParams {
+    multipleOf: number;
+  }
+
+  interface PatternParams {
+    pattern: string;
+  }
+
+  interface RequiredParams {
+    missingProperty: string;
+  }
+
+  interface TypeParams {
+    type: string;
+  }
+
+  interface UniqueItemsParams {
+    i: number;
+    j: number;
+  }
+
+  interface CustomParams {
+    keyword: string;
+  }
+
+  interface PatternGroupsParams {
+    reason: string;
+    limit: number;
+    pattern: string;
+  }
+
+  interface PatternRequiredParams {
+    missingPattern: string;
+  }
+
+  interface SwitchParams {
+    caseIndex: number;
+  }
+
+  interface NoParams {}
+
+  interface EnumParams {
+    allowedValues: Array<any>;
+  }
+}
+
+export = ajv;

src/plone/staticresources/static/components/ajv/lib/dotjs/README.md

@@ -0,0 +1,3 @@
+These files are compiled dot templates from dot folder.
+
+Do NOT edit them directly, edit the templates and run `npm run build` from main ajv folder.