dtable-ui-component 0.3.20 → 0.3.21

package/lib/HtmlLongTextFormatter/unified/index.js

@@ -1,32 +1,23 @@
 // eslint-disable-next-line
 'use strict';
-/* Dependencies. */
 
+/* Dependencies. */
 var extend = require('extend');
-
 var bail = require('bail');
-
 var trough = require('trough');
-
 var string = require('x-is-string');
-
 var plain = require('is-plain-obj');
-
 var vfile = require('../vfile').default;
-
 var slice = [].slice;
 var own = {}.hasOwnProperty;
-/* Process pipeline. */
 
+/* Process pipeline. */
 var pipeline = trough().use(pipelineParse).use(pipelineRun).use(pipelineStringify);
-
 function pipelineParse(p, ctx) {
   ctx.tree = p.parse(ctx.file);
 }
-
 function pipelineRun(p, ctx, next) {
   p.run(ctx.tree, ctx.file, done);
-
   function done(err, tree, file) {
     if (err) {
       next(err);
@@ -37,55 +28,52 @@ function pipelineRun(p, ctx, next) {
     }
   }
 }
-
 function pipelineStringify(p, ctx) {
   ctx.file.contents = p.stringify(ctx.tree, ctx.file);
 }
-/* Function to create the first processor. */
-
 
+/* Function to create the first processor. */
 function unified() {
   var attachers = [];
   var transformers = trough();
   var namespace = {};
   var frozen = false;
   var freezeIndex = -1;
-  /* Data management. */
 
+  /* Data management. */
   processor.data = data;
-  /* Lock. */
 
+  /* Lock. */
   processor.freeze = freeze;
-  /* Plug-ins. */
 
+  /* Plug-ins. */
   processor.attachers = attachers;
   processor.use = use;
-  /* API. */
 
+  /* API. */
   processor.parse = parse;
   processor.stringify = stringify;
   processor.run = run;
   processor.runSync = runSync;
   processor.process = process;
   processor.processSync = processSync;
-  /* Expose. */
 
+  /* Expose. */
   return processor;
+
   /* Create a new processor based on the processor
    * in the current scope. */
-
   function processor() {
     var destination = unified();
     var length = attachers.length;
     var index = -1;
-
     while (++index < length) {
       destination.use.apply(null, attachers[index]);
     }
-
     destination.data(extend(true, {}, namespace));
     return destination;
   }
+
   /* Freeze: used to signal a processor that has finished
    * configuration.
    *
@@ -95,47 +83,37 @@ function unified() {
    *
    * In essence, always invoke this when exporting a
    * processor. */
-
-
   function freeze() {
     var values;
     var plugin;
     var options;
     var transformer;
-
     if (frozen) {
       return processor;
     }
-
     while (++freezeIndex < attachers.length) {
       values = attachers[freezeIndex];
       plugin = values[0];
       options = values[1];
       transformer = null;
-
       if (options === false) {
         continue;
       }
-
       if (options === true) {
         values[1] = undefined;
       }
-
       transformer = plugin.apply(processor, values.slice(1));
-
       if (typeof transformer === 'function') {
         transformers.use(transformer);
       }
     }
-
     frozen = true;
     freezeIndex = Infinity;
     return processor;
   }
+
   /* Data management.
    * Getter / setter for processor-specific informtion. */
-
-
   function data(key, value) {
     if (string(key)) {
       /* Set `key`. */
@@ -144,24 +122,22 @@ function unified() {
         namespace[key] = value;
         return processor;
       }
-      /* Get `key`. */
-
 
+      /* Get `key`. */
       return own.call(namespace, key) && namespace[key] || null;
     }
-    /* Set space. */
-
 
+    /* Set space. */
     if (key) {
       assertUnfrozen('data', frozen);
       namespace = key;
       return processor;
     }
-    /* Get space. */
-
 
+    /* Get space. */
     return namespace;
   }
+
   /* Plug-in management.
    *
    * Pass it:
@@ -169,12 +145,9 @@ function unified() {
    * *   a preset,
    * *   a list of presets, attachers, and arguments (list
    *     of attachers and options). */
-
-
   function use(value) {
     var settings;
     assertUnfrozen('use', frozen);
-
     if (value === null || value === undefined) {
       /* Empty */
     } else if (typeof value === 'function') {
@@ -188,21 +161,16 @@ function unified() {
     } else {
       throw new Error('Expected usable value, not `' + value + '`');
     }
-
     if (settings) {
       namespace.settings = extend(namespace.settings || {}, settings);
     }
-
     return processor;
-
     function addPreset(result) {
       addList(result.plugins);
-
       if (result.settings) {
         settings = extend(settings || {}, result.settings);
       }
     }
-
     function add(value) {
       if (typeof value === 'function') {
         addPlugin(value);
@@ -216,17 +184,14 @@ function unified() {
         throw new Error('Expected usable value, not `' + value + '`');
       }
     }
-
     function addList(plugins) {
       var length;
       var index;
-
       if (plugins === null || plugins === undefined) {
         /* Empty */
       } else if (typeof plugins === 'object' && 'length' in plugins) {
         length = plugins.length;
         index = -1;
-
         while (++index < length) {
           add(plugins[index]);
         }
@@ -234,78 +199,62 @@ function unified() {
         throw new Error('Expected a list of plugins, not `' + plugins + '`');
       }
     }
-
     function addPlugin(plugin, value) {
       var entry = find(plugin);
-
       if (entry) {
         if (plain(entry[1]) && plain(value)) {
           value = extend(entry[1], value);
         }
-
         entry[1] = value;
       } else {
         attachers.push(slice.call(arguments));
       }
     }
   }
-
   function find(plugin) {
     var length = attachers.length;
     var index = -1;
     var entry;
-
     while (++index < length) {
       entry = attachers[index];
-
       if (entry[0] === plugin) {
         return entry;
       }
     }
   }
+
   /* Parse a file (in string or VFile representation)
    * into a Unist node using the `Parser` on the
    * processor. */
-
-
   function parse(doc) {
     var file = vfile(doc);
     var Parser;
     freeze();
     Parser = processor.Parser;
     assertParser('parse', Parser);
-
     if (newable(Parser)) {
       return new Parser(String(file), file).parse();
     }
-
     return Parser(String(file), file); // eslint-disable-line new-cap
   }
+
   /* Run transforms on a Unist node representation of a file
    * (in string or VFile representation), async. */
-
-
   function run(node, file, cb) {
     assertNode(node);
     freeze();
-
     if (!cb && typeof file === 'function') {
       cb = file;
       file = null;
     }
-
     if (!cb) {
       return new Promise(executor);
     }
-
     executor(null, cb);
-
     function executor(resolve, reject) {
       transformers.run(node, vfile(file), done);
-
       function done(err, tree, file) {
         tree = tree || node;
-
         if (err) {
           reject(err);
         } else if (resolve) {
@@ -316,28 +265,25 @@ function unified() {
       }
     }
   }
+
   /* Run transforms on a Unist node representation of a file
    * (in string or VFile representation), sync. */
-
-
   function runSync(node, file) {
     var complete = false;
     var result;
     run(node, file, done);
     assertDone('runSync', 'run', complete);
     return result;
-
     function done(err, tree) {
       complete = true;
       bail(err);
       result = tree;
     }
   }
+
   /* Stringify a Unist node representation of a file
    * (in string or VFile representation) into a string
    * using the `Compiler` on the processor. */
-
-
   function stringify(node, doc) {
     var file = vfile(doc);
     var Compiler;
@@ -345,37 +291,30 @@ function unified() {
     Compiler = processor.Compiler;
     assertCompiler('stringify', Compiler);
     assertNode(node);
-
     if (newable(Compiler)) {
       return new Compiler(node, file).compile();
     }
-
     return Compiler(node, file); // eslint-disable-line new-cap
   }
+
   /* Parse a file (in string or VFile representation)
    * into a Unist node using the `Parser` on the processor,
    * then run transforms on that node, and compile the
    * resulting node using the `Compiler` on the processor,
    * and store that result on the VFile. */
-
-
   function process(doc, cb) {
     freeze();
     assertParser('process', processor.Parser);
     assertCompiler('process', processor.Compiler);
-
     if (!cb) {
       return new Promise(executor);
     }
-
     executor(null, cb);
-
     function executor(resolve, reject) {
       var file = vfile(doc);
       pipeline.run(processor, {
         file: file
       }, done);
-
       function done(err) {
         if (err) {
           reject(err);
@@ -387,10 +326,9 @@ function unified() {
       }
     }
   }
+
   /* Process the given document (in string or VFile
    * representation), sync. */
-
-
   function processSync(doc) {
     var complete = false;
     var file;
@@ -401,73 +339,62 @@ function unified() {
     process(file, done);
     assertDone('processSync', 'process', complete);
     return file;
-
     function done(err) {
       complete = true;
       bail(err);
     }
   }
 }
-/* Check if `func` is a constructor. */
-
 
+/* Check if `func` is a constructor. */
 function newable(value) {
   return typeof value === 'function' && keys(value.prototype);
 }
-/* Check if `value` is an object with keys. */
-
 
+/* Check if `value` is an object with keys. */
 function keys(value) {
   var key;
-
   for (key in value) {
     return true;
   }
-
   return false;
 }
-/* Assert a parser is available. */
-
 
+/* Assert a parser is available. */
 function assertParser(name, Parser) {
   if (typeof Parser !== 'function') {
     throw new Error('Cannot `' + name + '` without `Parser`');
   }
 }
-/* Assert a compiler is available. */
-
 
+/* Assert a compiler is available. */
 function assertCompiler(name, Compiler) {
   if (typeof Compiler !== 'function') {
     throw new Error('Cannot `' + name + '` without `Compiler`');
   }
 }
-/* Assert the processor is not frozen. */
-
 
+/* Assert the processor is not frozen. */
 function assertUnfrozen(name, frozen) {
   if (frozen) {
     throw new Error(['Cannot invoke `' + name + '` on a frozen processor.\nCreate a new ', 'processor first, by invoking it: use `processor()` instead of ', '`processor`.'].join(''));
   }
 }
-/* Assert `node` is a Unist node. */
-
 
+/* Assert `node` is a Unist node. */
 function assertNode(node) {
   if (!node || !string(node.type)) {
     throw new Error('Expected node, got `' + node + '`');
   }
 }
-/* Assert that `complete` is `true`. */
-
 
+/* Assert that `complete` is `true`. */
 function assertDone(name, asyncName, complete) {
   if (!complete) {
     throw new Error('`' + name + '` finished async. Use `' + asyncName + '` instead');
   }
 }
-/* Expose a frozen processor. */
-
 
+/* Expose a frozen processor. */
 var unified_freeze = unified().freeze();
 export default unified_freeze;

package/lib/HtmlLongTextFormatter/vfile/core.js

@@ -2,30 +2,25 @@
 'use strict';
 
 var path = require('path');
-
 var replace = require('replace-ext');
-
 var buffer = require('is-buffer');
-
 var own = {}.hasOwnProperty;
 var proto = VFile.prototype;
 proto.toString = toString;
+
 /* Order of setting (least specific to most), we need this because
  * otherwise `{stem: 'a', path: '~/b.js'}` would throw, as a path
  * is needed before a stem can be set. */
-
 var order = ['history', 'path', 'basename', 'stem', 'extname', 'dirname'];
-/* Construct a new file. */
 
+/* Construct a new file. */
 function VFile(options) {
   var prop;
   var index;
   var length;
-
   if (typeof options === 'number') {
     options = options.toString();
   }
-
   if (!options) {
     options = {};
   } else if (typeof options === 'string' || buffer(options)) {
@@ -35,53 +30,46 @@ function VFile(options) {
   } else if ('message' in options && 'messages' in options) {
     return options;
   }
-
   if (!(this instanceof VFile)) {
     return new VFile(options);
   }
-
   this.data = {};
   this.messages = [];
   this.history = [];
   this.cwd = process.cwd();
-  /* Set path related properties in the correct order. */
 
+  /* Set path related properties in the correct order. */
   index = -1;
   length = order.length;
-
   while (++index < length) {
     prop = order[index];
-
     if (own.call(options, prop)) {
       this[prop] = options[prop];
     }
   }
-  /* Set non-path related properties. */
-
 
+  /* Set non-path related properties. */
   for (prop in options) {
     if (order.indexOf(prop) === -1) {
       this[prop] = options[prop];
     }
   }
 }
-/* Access full path (`~/index.min.js`). */
-
 
+/* Access full path (`~/index.min.js`). */
 Object.defineProperty(proto, 'path', {
   get: function get() {
     return this.history[this.history.length - 1];
   },
   set: function set(path) {
     assertNonEmpty(path, 'path');
-
     if (path !== this.path) {
       this.history.push(path);
     }
   }
 });
-/* Access parent path (`~`). */
 
+/* Access parent path (`~`). */
 Object.defineProperty(proto, 'dirname', {
   get: function get() {
     return typeof this.path === 'string' ? path.dirname(this.path) : undefined;
@@ -91,8 +79,8 @@ Object.defineProperty(proto, 'dirname', {
     this.path = path.join(dirname || '', this.basename);
   }
 });
-/* Access basename (`index.min.js`). */
 
+/* Access basename (`index.min.js`). */
 Object.defineProperty(proto, 'basename', {
   get: function get() {
     return typeof this.path === 'string' ? path.basename(this.path) : undefined;
@@ -103,8 +91,8 @@ Object.defineProperty(proto, 'basename', {
     this.path = path.join(this.dirname || '', basename);
   }
 });
-/* Access extname (`.js`). */
 
+/* Access extname (`.js`). */
 Object.defineProperty(proto, 'extname', {
   get: function get() {
     return typeof this.path === 'string' ? path.extname(this.path) : undefined;
@@ -113,22 +101,19 @@ Object.defineProperty(proto, 'extname', {
     var ext = extname || '';
     assertPart(ext, 'extname');
     assertPath(this.path, 'extname');
-
     if (ext) {
       if (ext.charAt(0) !== '.') {
         throw new Error('`extname` must start with `.`');
       }
-
       if (ext.indexOf('.', 1) !== -1) {
         throw new Error('`extname` cannot contain multiple dots');
       }
     }
-
     this.path = replace(this.path, ext);
   }
 });
-/* Access stem (`index.min`). */
 
+/* Access stem (`index.min`). */
 Object.defineProperty(proto, 'stem', {
   get: function get() {
     return typeof this.path === 'string' ? path.basename(this.path, this.extname) : undefined;
@@ -139,36 +124,32 @@ Object.defineProperty(proto, 'stem', {
     this.path = path.join(this.dirname || '', stem + (this.extname || ''));
   }
 });
-/* Get the value of the file. */
 
+/* Get the value of the file. */
 function toString(encoding) {
   var value = this.contents || '';
   return buffer(value) ? value.toString(encoding) : String(value);
 }
+
 /* Assert that `part` is not a path (i.e., does
  * not contain `path.sep`). */
-
-
 function assertPart(part, name) {
   if (part.indexOf(path.sep) !== -1) {
     throw new Error('`' + name + '` cannot be a path: did not expect `' + path.sep + '`');
   }
 }
-/* Assert that `part` is not empty. */
-
 
+/* Assert that `part` is not empty. */
 function assertNonEmpty(part, name) {
   if (!part) {
     throw new Error('`' + name + '` cannot be empty');
   }
 }
-/* Assert `path` exists. */
-
 
+/* Assert `path` exists. */
 function assertPath(path, name) {
   if (!path) {
     throw new Error('Setting `' + name + '` requires `path` to be set too');
   }
 }
-
 export default VFile;

package/lib/HtmlLongTextFormatter/vfile/index.js

@@ -1,47 +1,40 @@
 var VMessage = require('vfile-message');
-
 var VFile = require('./core.js').default;
-
 var proto = VFile.prototype;
 proto.message = message;
 proto.info = info;
 proto.fail = fail;
-/* Slight backwards compatibility.  Remove in the future. */
 
+/* Slight backwards compatibility.  Remove in the future. */
 proto.warn = message;
+
 /* Create a message with `reason` at `position`.
  * When an error is passed in as `reason`, copies the stack. */
-
 function message(reason, position, origin) {
   var filePath = this.path;
   var message = new VMessage(reason, position, origin);
-
   if (filePath) {
     message.name = filePath + ':' + message.name;
     message.file = filePath;
   }
-
   message.fatal = false;
   this.messages.push(message);
   return message;
 }
+
 /* Fail. Creates a vmessage, associates it with the file,
  * and throws it. */
-
-
 function fail() {
   var message = this.message.apply(this, arguments);
   message.fatal = true;
   throw message;
 }
+
 /* Info. Creates a vmessage, associates it with the file,
  * and marks the fatality as null. */
-
-
 function info() {
   var message = this.message.apply(this, arguments);
   message.fatal = null;
   return message;
 }
-
 export default VFile;