<commit_before>const {Node} = require("prosemirror-model")

const {Selection} = require("./selection")
const {Transaction} = require("./transaction")

function bind(f, self) {
  return !self || !f ? f : f.bind(self)
}

class FieldDesc {
  constructor(name, desc, self) {
    this.name = name
    this.init = bind(desc.init, self)
    this.apply = bind(desc.apply, self)
  }
}

const baseFields = [
  new FieldDesc("doc", {
    init(config) { return config.doc || config.schema.topNodeType.createAndFill() },
    apply(tr) { return tr.doc }
  }),

  new FieldDesc("selection", {
    init(config, instance) { return config.selection || Selection.atStart(instance.doc) },
    apply(tr) { return tr.selection }
  }),

  new FieldDesc("storedMarks", {
    init() { return null },
    apply(tr, _marks, _old, state) { return state.selection.$cursor ? tr.storedMarks : null }
  }),

  new FieldDesc("scrollToSelection", {
    init() { return 0 },
    apply(tr, prev) { return tr.scrolledIntoView ? prev + 1 : prev }
  })
]

// Object wrapping the part of a state object that stays the same
// across transactions. Stored in the state's `config` property.
class Configuration {
  constructor(schema, plugins) {
    this.schema = schema
    this.fields = baseFields.concat()
    this.plugins = []
    this.pluginsByKey = Object.create(null)
    if (plugins) plugins.forEach(plugin => {
      if (this.pluginsByKey[plugin.key])
        throw new RangeError("Adding different instances of a keyed plugin (" + plugin.key + ")")
      this.plugins.push(plugin)
      this.pluginsByKey[plugin.key] = plugin
      if (plugin.spec.state)
        this.fields.push(new FieldDesc(plugin.key, plugin.spec.state, plugin))
    })
  }
}

// ::- The state of a ProseMirror editor is represented by an object
// of this type. This is a persistent data structure—it isn't updated,
// but rather a new state value is computed from an old one with the
// [`apply`](#state.EditorState.apply) method.
//
// In addition to the built-in state fields, plugins can define
// additional pieces of state.
class EditorState {
  constructor(config) {
    this.config = config
  }

  // doc:: Node
  // The current document.

  // selection:: Selection
  // The selection.

  // storedMarks:: ?[Mark]
  // A set of marks to apply to the next character that's typed. Will
  // be null whenever no explicit marks have been set.

  // :: Schema
  // The schema of the state's document.
  get schema() {
    return this.config.schema
  }

  // :: [Plugin]
  // The plugins that are active in this state.
  get plugins() {
    return this.config.plugins
  }

  // :: (Transaction) → EditorState
  // Apply the given transaction to produce a new state.
  apply(tr) {
    return this.applyTransaction(tr).state
  }

  // : (Transaction) → ?Transaction
  filterTransaction(tr, ignore = -1) {
    for (let i = 0; i < this.config.plugins.length; i++) if (i != ignore) {
      let plugin = this.config.plugins[i]
      if (plugin.spec.filterTransaction && !plugin.spec.filterTransaction.call(plugin, tr, this))
        return false
    }
    return true
  }

  // :: (Transaction) → {state: EditorState, transactions: [Transaction]}
  // Verbose variant of [`apply`](#state.EditorState.apply) that
  // returns the precise transactions that were applied (which might
  // be influenced by the [transaction
  // hooks](#state.PluginSpec.filterTransaction) of
  // plugins) along with the new state.
  applyTransaction(tr) {
    if (!this.filterTransaction(tr)) return {state: this, transactions: []}

    let trs = [tr], newState = this.applyInner(tr), seen = null
    // This loop repeatedly gives plugins a chance to respond to
    // transactions as new transactions are added, making sure to only
    // pass the transactions the plugin did not see before.
    outer: for (;;) {
      let haveNew = false
      for (let i = 0; i < this.config.plugins.length; i++) {
        let plugin = this.config.plugins[i]
        if (plugin.spec.appendTransaction) {
          let n = seen ? seen[i].n : 0, oldState = seen ? seen[i].state : this
          let tr = n < trs.length &&
              plugin.spec.appendTransaction.call(plugin, n ? trs.slice(n) : trs, oldState, newState)
          if (tr && newState.filterTransaction(tr, i)) {
            tr.setMeta("appendedTransaction", tr)
            if (!seen) {
              seen = []
              for (let j = 0; j < this.config.plugins.length; j++)
                seen.push(j < i ? {state: newState, n: trs.length} : {state: this, n: 0})
            }
            trs.push(tr)
            newState = newState.applyInner(tr)
            haveNew = true
          }
          if (seen) seen[i] = {state: newState, n: trs.length}
        }
      }
      if (!haveNew) return {state: newState, transactions: trs}
    }
  }

  // : (Transaction) → EditorState
  applyInner(tr) {
    if (!tr.before.eq(this.doc)) throw new RangeError("Applying a mismatched transaction")
    let newInstance = new EditorState(this.config), fields = this.config.fields
    for (let i = 0; i < fields.length; i++) {
      let field = fields[i]
      newInstance[field.name] = field.apply(tr, this[field.name], this, newInstance)
    }
    for (let i = 0; i < applyListeners.length; i++) applyListeners[i](this, tr, newInstance)
    return newInstance
  }

  // :: Transaction
  // Start a [transaction](#state.Transaction) from this state.
  get tr() { return new Transaction(this) }

  // :: (Object) → EditorState
  // Create a state.
  //
  //   config::- Configuration options. Must contain `schema` or `doc` (or both).
  //
  //      schema:: ?Schema
  //      The schema to use.
  //
  //      doc:: ?Node
  //      The starting document.
  //
  //      selection:: ?Selection
  //      A valid selection in the document.
  //
  //      plugins:: ?[Plugin]
  //      The plugins that should be active in this state.
  static create(config) {
    let $config = new Configuration(config.schema || config.doc.type.schema, config.plugins)
    let instance = new EditorState($config)
    for (let i = 0; i < $config.fields.length; i++)
      instance[$config.fields[i].name] = $config.fields[i].init(config, instance)
    return instance
  }

  // :: (Object) → EditorState
  // Create a new state based on this one, but with an adjusted set of
  // active plugins. State fields that exist in both sets of plugins
  // are kept unchanged. Those that no longer exist are dropped, and
  // those that are new are initialized using their
  // [`init`](#state.StateField.init) method, passing in the new
  // configuration object..
  //
  //   config::- configuration options
  //
  //     schema:: ?Schema
  //     New schema to use.
  //
  //     plugins:: ?[Plugin]
  //     New set of active plugins.
  reconfigure(config) {
    let $config = new Configuration(config.schema || this.schema, config.plugins)
    let fields = $config.fields, instance = new EditorState($config)
    for (let i = 0; i < fields.length; i++) {
      let name = fields[i].name
      instance[name] = this.hasOwnProperty(name) ? this[name] : fields[i].init(config, instance)
    }
    return instance
  }

  // :: (?Object<Plugin>) → Object
  // Serialize this state to JSON. If you want to serialize the state
  // of plugins, pass an object mapping property names to use in the
  // resulting JSON object to plugin objects.
  toJSON(pluginFields) {
    let result = {doc: this.doc.toJSON(), selection: this.selection.toJSON()}
    if (pluginFields) for (let prop in pluginFields) {
      if (prop == "doc" || prop == "selection")
        throw new RangeError("The JSON fields `doc` and `selection` are reserved")
      let plugin = pluginFields[prop], state = plugin.spec.state
      if (state && state.toJSON) result[prop] = state.toJSON.call(plugin, this[plugin.key])
    }
    return result
  }

  // :: (Object, Object, ?Object<Plugin>) → EditorState
  // Deserialize a JSON representation of a state. `config` should
  // have at least a `schema` field, and should contain array of
  // plugins to initialize the state with. `pluginFields` can be used
  // to deserialize the state of plugins, by associating plugin
  // instances with the property names they use in the JSON object.
  //
  //   config::- configuration options
  //
  //     schema:: Schema
  //     The schema to use.
  //
  //     plugins:: ?[Plugin]
  //     The set of active plugins.
  static fromJSON(config, json, pluginFields) {
    if (!config.schema) throw new RangeError("Required config field 'schema' missing")
    let $config = new Configuration(config.schema, config.plugins)
    let instance = new EditorState($config)
    $config.fields.forEach(field => {
      if (field.name == "doc") {
        instance.doc = Node.fromJSON(config.schema, json.doc)
      } else if (field.name == "selection") {
        instance.selection = Selection.fromJSON(instance.doc, json.selection)
      } else {
        if (pluginFields) for (let prop in pluginFields) {
          let plugin = pluginFields[prop], state = plugin.spec.state
          if (plugin.key == field.name && state && state.fromJSON &&
              Object.prototype.hasOwnProperty.call(json, prop)) {
            // This field belongs to a plugin mapped to a JSON field, read it from there.
            instance[field.name] = state.fromJSON.call(plugin, config, json[prop], instance)
            return
          }
        }
        instance[field.name] = field.init(config, instance)
      }
    })
    return instance
  }

  // Kludge to allow the view to track mappings between different
  // instances of a state.
  static addApplyListener(f) {
    applyListeners.push(f)
  }
  static removeApplyListener(f) {
    let found = applyListeners.indexOf(f)
    if (found > -1) applyListeners.splice(found, 1)
  }
}
exports.EditorState = EditorState

const applyListeners = []
<commit_msg>Remove trailing whitespace<commit_after>const {Node} = require("prosemirror-model")

const {Selection} = require("./selection")
const {Transaction} = require("./transaction")

function bind(f, self) {
  return !self || !f ? f : f.bind(self)
}

class FieldDesc {
  constructor(name, desc, self) {
    this.name = name
    this.init = bind(desc.init, self)
    this.apply = bind(desc.apply, self)
  }
}

const baseFields = [
  new FieldDesc("doc", {
    init(config) { return config.doc || config.schema.topNodeType.createAndFill() },
    apply(tr) { return tr.doc }
  }),

  new FieldDesc("selection", {
    init(config, instance) { return config.selection || Selection.atStart(instance.doc) },
    apply(tr) { return tr.selection }
  }),

  new FieldDesc("storedMarks", {
    init() { return null },
    apply(tr, _marks, _old, state) { return state.selection.$cursor ? tr.storedMarks : null }
  }),

  new FieldDesc("scrollToSelection", {
    init() { return 0 },
    apply(tr, prev) { return tr.scrolledIntoView ? prev + 1 : prev }
  })
]

// Object wrapping the part of a state object that stays the same
// across transactions. Stored in the state's `config` property.
class Configuration {
  constructor(schema, plugins) {
    this.schema = schema
    this.fields = baseFields.concat()
    this.plugins = []
    this.pluginsByKey = Object.create(null)
    if (plugins) plugins.forEach(plugin => {
      if (this.pluginsByKey[plugin.key])
        throw new RangeError("Adding different instances of a keyed plugin (" + plugin.key + ")")
      this.plugins.push(plugin)
      this.pluginsByKey[plugin.key] = plugin
      if (plugin.spec.state)
        this.fields.push(new FieldDesc(plugin.key, plugin.spec.state, plugin))
    })
  }
}

// ::- The state of a ProseMirror editor is represented by an object
// of this type. This is a persistent data structure—it isn't updated,
// but rather a new state value is computed from an old one with the
// [`apply`](#state.EditorState.apply) method.
//
// In addition to the built-in state fields, plugins can define
// additional pieces of state.
class EditorState {
  constructor(config) {
    this.config = config
  }

  // doc:: Node
  // The current document.

  // selection:: Selection
  // The selection.

  // storedMarks:: ?[Mark]
  // A set of marks to apply to the next character that's typed. Will
  // be null whenever no explicit marks have been set.

  // :: Schema
  // The schema of the state's document.
  get schema() {
    return this.config.schema
  }

  // :: [Plugin]
  // The plugins that are active in this state.
  get plugins() {
    return this.config.plugins
  }

  // :: (Transaction) → EditorState
  // Apply the given transaction to produce a new state.
  apply(tr) {
    return this.applyTransaction(tr).state
  }

  // : (Transaction) → ?Transaction
  filterTransaction(tr, ignore = -1) {
    for (let i = 0; i < this.config.plugins.length; i++) if (i != ignore) {
      let plugin = this.config.plugins[i]
      if (plugin.spec.filterTransaction && !plugin.spec.filterTransaction.call(plugin, tr, this))
        return false
    }
    return true
  }

  // :: (Transaction) → {state: EditorState, transactions: [Transaction]}
  // Verbose variant of [`apply`](#state.EditorState.apply) that
  // returns the precise transactions that were applied (which might
  // be influenced by the [transaction
  // hooks](#state.PluginSpec.filterTransaction) of
  // plugins) along with the new state.
  applyTransaction(tr) {
    if (!this.filterTransaction(tr)) return {state: this, transactions: []}

    let trs = [tr], newState = this.applyInner(tr), seen = null
    // This loop repeatedly gives plugins a chance to respond to
    // transactions as new transactions are added, making sure to only
    // pass the transactions the plugin did not see before.
    outer: for (;;) {
      let haveNew = false
      for (let i = 0; i < this.config.plugins.length; i++) {
        let plugin = this.config.plugins[i]
        if (plugin.spec.appendTransaction) {
          let n = seen ? seen[i].n : 0, oldState = seen ? seen[i].state : this
          let tr = n < trs.length &&
              plugin.spec.appendTransaction.call(plugin, n ? trs.slice(n) : trs, oldState, newState)
          if (tr && newState.filterTransaction(tr, i)) {
            tr.setMeta("appendedTransaction", tr)
            if (!seen) {
              seen = []
              for (let j = 0; j < this.config.plugins.length; j++)
                seen.push(j < i ? {state: newState, n: trs.length} : {state: this, n: 0})
            }
            trs.push(tr)
            newState = newState.applyInner(tr)
            haveNew = true
          }
          if (seen) seen[i] = {state: newState, n: trs.length}
        }
      }
      if (!haveNew) return {state: newState, transactions: trs}
    }
  }

  // : (Transaction) → EditorState
  applyInner(tr) {
    if (!tr.before.eq(this.doc)) throw new RangeError("Applying a mismatched transaction")
    let newInstance = new EditorState(this.config), fields = this.config.fields
    for (let i = 0; i < fields.length; i++) {
      let field = fields[i]
      newInstance[field.name] = field.apply(tr, this[field.name], this, newInstance)
    }
    for (let i = 0; i < applyListeners.length; i++) applyListeners[i](this, tr, newInstance)
    return newInstance
  }

  // :: Transaction
  // Start a [transaction](#state.Transaction) from this state.
  get tr() { return new Transaction(this) }

  // :: (Object) → EditorState
  // Create a state.
  //
  //   config::- Configuration options. Must contain `schema` or `doc` (or both).
  //
  //      schema:: ?Schema
  //      The schema to use.
  //
  //      doc:: ?Node
  //      The starting document.
  //
  //      selection:: ?Selection
  //      A valid selection in the document.
  //
  //      plugins:: ?[Plugin]
  //      The plugins that should be active in this state.
  static create(config) {
    let $config = new Configuration(config.schema || config.doc.type.schema, config.plugins)
    let instance = new EditorState($config)
    for (let i = 0; i < $config.fields.length; i++)
      instance[$config.fields[i].name] = $config.fields[i].init(config, instance)
    return instance
  }

  // :: (Object) → EditorState
  // Create a new state based on this one, but with an adjusted set of
  // active plugins. State fields that exist in both sets of plugins
  // are kept unchanged. Those that no longer exist are dropped, and
  // those that are new are initialized using their
  // [`init`](#state.StateField.init) method, passing in the new
  // configuration object..
  //
  //   config::- configuration options
  //
  //     schema:: ?Schema
  //     New schema to use.
  //
  //     plugins:: ?[Plugin]
  //     New set of active plugins.
  reconfigure(config) {
    let $config = new Configuration(config.schema || this.schema, config.plugins)
    let fields = $config.fields, instance = new EditorState($config)
    for (let i = 0; i < fields.length; i++) {
      let name = fields[i].name
      instance[name] = this.hasOwnProperty(name) ? this[name] : fields[i].init(config, instance)
    }
    return instance
  }

  // :: (?Object<Plugin>) → Object
  // Serialize this state to JSON. If you want to serialize the state
  // of plugins, pass an object mapping property names to use in the
  // resulting JSON object to plugin objects.
  toJSON(pluginFields) {
    let result = {doc: this.doc.toJSON(), selection: this.selection.toJSON()}
    if (pluginFields) for (let prop in pluginFields) {
      if (prop == "doc" || prop == "selection")
        throw new RangeError("The JSON fields `doc` and `selection` are reserved")
      let plugin = pluginFields[prop], state = plugin.spec.state
      if (state && state.toJSON) result[prop] = state.toJSON.call(plugin, this[plugin.key])
    }
    return result
  }

  // :: (Object, Object, ?Object<Plugin>) → EditorState
  // Deserialize a JSON representation of a state. `config` should
  // have at least a `schema` field, and should contain array of
  // plugins to initialize the state with. `pluginFields` can be used
  // to deserialize the state of plugins, by associating plugin
  // instances with the property names they use in the JSON object.
  //
  //   config::- configuration options
  //
  //     schema:: Schema
  //     The schema to use.
  //
  //     plugins:: ?[Plugin]
  //     The set of active plugins.
  static fromJSON(config, json, pluginFields) {
    if (!config.schema) throw new RangeError("Required config field 'schema' missing")
    let $config = new Configuration(config.schema, config.plugins)
    let instance = new EditorState($config)
    $config.fields.forEach(field => {
      if (field.name == "doc") {
        instance.doc = Node.fromJSON(config.schema, json.doc)
      } else if (field.name == "selection") {
        instance.selection = Selection.fromJSON(instance.doc, json.selection)
      } else {
        if (pluginFields) for (let prop in pluginFields) {
          let plugin = pluginFields[prop], state = plugin.spec.state
          if (plugin.key == field.name && state && state.fromJSON &&
              Object.prototype.hasOwnProperty.call(json, prop)) {
            // This field belongs to a plugin mapped to a JSON field, read it from there.
            instance[field.name] = state.fromJSON.call(plugin, config, json[prop], instance)
            return
          }
        }
        instance[field.name] = field.init(config, instance)
      }
    })
    return instance
  }

  // Kludge to allow the view to track mappings between different
  // instances of a state.
  static addApplyListener(f) {
    applyListeners.push(f)
  }
  static removeApplyListener(f) {
    let found = applyListeners.indexOf(f)
    if (found > -1) applyListeners.splice(found, 1)
  }
}
exports.EditorState = EditorState

const applyListeners = []
<|endoftext|>


<commit_before>const canvas = document.createElement('canvas');
const ctx = canvas.getContext('2d');
ctx.fillRect(10, 10, 120, 60);
const imageData = ctx.getImageData(0, 0, 180, 180);

const initialState = {
  isDragOver: false,
  imageList: [
    {id: 0, isShow: true, imageData},
    {id: 1, isShow: true, imageData},
  ],
  display: {
    width: 500,
    height: 500,
    magnificationPercent: 100,
  },
};

export default initialState;
<commit_msg>imageList は generateImageList を使って生成する。<commit_after>import {generateImageList, CREATE_IMAGE} from './generateImageList';

const canvas = document.createElement('canvas');
const ctx = canvas.getContext('2d');
ctx.fillRect(10, 10, 120, 60);
const imageData = ctx.getImageData(0, 0, 180, 180);

const initialState = {
  isDragOver: false,
  imageList: generateImageList(
    CREATE_IMAGE,
    {id: 0, isShow: true, imageData},
    []
  ),
  display: {
    width: 500,
    height: 500,
    magnificationPercent: 100,
  },
};

export default initialState;
<|endoftext|>


<commit_before>import { dispatch } from './middleware'
import { addAction } from './actions'

export default function (...args) {
  // Detect Optional Config Object
  const isSandboxed = args.length > 1
  let sandboxName = isSandboxed ? args[0] : undefined
  const actions = isSandboxed ? args[1] : args[0]

  // Checks
  if (sandboxName && typeof sandboxName === 'string' && !sandboxName.length) {
    throw new Error('Sandboxed states names must be a valid string')
  }

  // set the current state to the initial value
  const initialState = actions.initial
  delete actions.initial

  const namedActions = {}

  let currentState

  const reducerWithActions = (state = initialState, action = {}) => {
    if (namedActions[action.type]) {
      // For namespaced actions, look for the prefixedAction
      const nextState = namedActions[action.type](state, action.payload)
      // Extend the state to avoid mutation
      currentState = Object.assign({}, state, nextState)
    }
    return currentState
  }

  // Loop through the actions and proxy them to do awesome stuff
  Object.keys(actions).forEach((actionName) => {
    const resolvedActionName = sandboxName ? `${sandboxName}_${actionName}` : actionName

    // Keep a reference to the original action for the reducer to reference
    namedActions[resolvedActionName] = actions[actionName]

    // Create a namespaced action
    const actionMethod = (payload) => {
      const action = {
        type: resolvedActionName,
        payload
      }
      // Otherwise, proxy the action through the attached redux dispatcher
      return dispatch(action)
    }

    // Attach the method to the reducer
    reducerWithActions[actionName] = actionMethod

    // If global, add the actionMethod to the global Actions list
    if (!sandboxName) {
      addAction(actionName, actionMethod)
    }

    // makes actions available directly when testing with an _ prefix
    if (typeof process !== 'undefined' && process.env.NODE_ENV === 'testing') {
      reducerWithActions[`_${actionName}`] = actions[actionName]
    }
  })

  return reducerWithActions
}
<commit_msg>Use initial state correctly<commit_after>import { dispatch } from './middleware'
import { addAction } from './actions'

export default function (...args) {
  // Detect Optional Config Object
  const isSandboxed = args.length > 1
  let sandboxName = isSandboxed ? args[0] : undefined
  const actions = isSandboxed ? args[1] : args[0]

  // Checks
  if (sandboxName && typeof sandboxName === 'string' && !sandboxName.length) {
    throw new Error('Sandboxed states names must be a valid string')
  }

  // set the current state to the initial value
  const initialState = actions.initial
  delete actions.initial

  const namedActions = {}

  let currentState = initialState

  const reducerWithActions = (state = initialState, action = {}) => {
    if (namedActions[action.type]) {
      // For namespaced actions, look for the prefixedAction
      const nextState = namedActions[action.type](state, action.payload)
      // Extend the state to avoid mutation
      currentState = Object.assign({}, state, nextState)
    }
    return currentState
  }

  // Loop through the actions and proxy them to do awesome stuff
  Object.keys(actions).forEach((actionName) => {
    const resolvedActionName = sandboxName ? `${sandboxName}_${actionName}` : actionName

    // Keep a reference to the original action for the reducer to reference
    namedActions[resolvedActionName] = actions[actionName]

    // Create a namespaced action
    const actionMethod = (payload) => {
      const action = {
        type: resolvedActionName,
        payload
      }
      // Otherwise, proxy the action through the attached redux dispatcher
      return dispatch(action)
    }

    // Attach the method to the reducer
    reducerWithActions[actionName] = actionMethod

    // If global, add the actionMethod to the global Actions list
    if (!sandboxName) {
      addAction(actionName, actionMethod)
    }

    // makes actions available directly when testing with an _ prefix
    if (typeof process !== 'undefined' && process.env.NODE_ENV === 'testing') {
      reducerWithActions[`_${actionName}`] = actions[actionName]
    }
  })

  return reducerWithActions
}
<|endoftext|>


<commit_before>export class Store {
  constructor() {
    this._store = {}
  }
  register(id, data) {
    this._store[id] = data;
  }
  unregister(id) {
    delete this._store[id];
  }
  get(id) {
    return this._store[id];
  }
  has(id) {
    return !!this.get(id);
  }
}
<commit_msg>various fixes<commit_after><|endoftext|>


<commit_before>var fs = require("fs");
var file = "./test.db";
var exists = fs.existsSync(file);

if(!exists) {
  console.log("Creating DB file.");
  fs.openSync(file, "w");
}

var sqlite3 = require("sqlite3").verbose();
var db = new sqlite3.Database(file);

db.serialize(function() {
  if(!exists) {
    db.run("CREATE TABLE Stuff (thing TEXT)");
  }

  var stmt = db.prepare("INSERT INTO Stuff VALUES (?)");

  //Insert random data
  var rnd;
  for (var i = 0; i < 10; i++) {
    rnd = Math.floor(Math.random() * 10000000);
    stmt.run("Thing #" + rnd);
  }

  stmt.finalize();
    db.each("SELECT rowid AS id, thing FROM Stuff", function(err, row) {
      console.log(row.id + ": " + row.thing);
    });
});

db.close();
<commit_msg>dont insert test data on every app start<commit_after>var fs = require("fs");
var file = "./test.db";
var exists = fs.existsSync(file);

if(!exists) {
  console.log("Creating DB file.");
  fs.openSync(file, "w");
}

var sqlite3 = require("sqlite3").verbose();
var db = new sqlite3.Database(file);

db.serialize(function() {
  if(!exists) {
    db.run("CREATE TABLE Stuff (thing TEXT)");

    var stmt = db.prepare("INSERT INTO Stuff VALUES (?)");

    //Insert random data
    var rnd;
    for (var i = 0; i < 10; i++) {
      rnd = Math.floor(Math.random() * 10000000);
      stmt.run("Thing #" + rnd);
    }
    stmt.finalize();
  }

  db.each("SELECT rowid AS id, thing FROM Stuff", function(err, row) {
    console.log(row.id + ": " + row.thing);
  });
});

db.close();
<|endoftext|>


<commit_before>import reduceCSSCalc from "reduce-css-calc";

/**
 * Given an object with CSS/SVG transform definitions, return the string value
 * for use with the `transform` CSS property or SVG attribute. Note that we
 * can't always guarantee the order will match the author's intended order, so
 * authors should only use the object notation if they know that their transform
 * is commutative or that there is only one.
 * @param {Object} obj An object of transform definitions.
 * @returns {String} The generated transform string.
 */
export const toTransformString = function (obj) {
  if (!obj || typeof obj === "string") {
    return obj;
  }
  const transforms = [];
  for (const key in obj) {
    if (obj.hasOwnProperty(key)) {
      const value = obj[key];
      transforms.push(`${key}(${value})`);
    }
  }
  return transforms.join(" ");
};

export const calc = function (expr, precision) {
  return reduceCSSCalc(`calc(${expr})`, precision);
};

/**
 * Given the name of a color scale, getColorScale will return an array
 * of 5 hex string values in that color scale. If no 'name' parameter
 * is given, it will return the Victory default grayscale.
 * @param {String} name The name of the color scale to return (optional).
 * @returns {Array} An array of 5 hex string values composing a color scale.
 */
export const getColorScale = function (name) {
  const scales = {
    greyscale: [
      "#7d7d7d", "#5e5e5e", "#404040", "#969696",
      "#2b2b2b", "#bdbdbd", "d6d6d6", "#000000"
    ],
    qualitative: [
      "#334D5C", "#45B29D", "#EFC94C", "#E27A3F", "#DF5A49",
      "#4F7DA1", "#55DBC1", "#EFDA97", "#E2A37F", "#DF948A"
    ],
    diverging: [
      "#A83800", "#D64700", "#D66C00", "#FFB403", "#C6B403",
      "#36A69A", "#297F8D", "#17576D", "#073C58", "#002A4A"
    ],
    diverging2: [
      "#7E1E28", "#962E3D", "#B5374E", "#E54663",
      "#0368F5", "#0229AB", "#011454", "#000133"
    ],
    heatmap: ["#BE2805", "#EC5519", "#DC8505", "#717400", "#32450C"],
    warm: ["#5C110F", "#901811", "#BF5C00", "#E2AD3B", "#F0C755"],
    cool: ["#272433", "#343F4F", "#3D6066", "#77994C", "#B2D249"],
    red: ["#360000", "#600000", "#790000", "#AD1414", "#D91919"],
    blue: ["#00295A", "#00427D", "#006ECF", "#3590DE", "#65B4F4"],
    green: ["#28361A", "#354C25", "#4A6B33", "#678544", "#8BA663"]
  };
  return name ? scales[name] : scales.victory;
};
<commit_msg>lighten colors, remove divergent scales temporarily<commit_after>import reduceCSSCalc from "reduce-css-calc";

/**
 * Given an object with CSS/SVG transform definitions, return the string value
 * for use with the `transform` CSS property or SVG attribute. Note that we
 * can't always guarantee the order will match the author's intended order, so
 * authors should only use the object notation if they know that their transform
 * is commutative or that there is only one.
 * @param {Object} obj An object of transform definitions.
 * @returns {String} The generated transform string.
 */
export const toTransformString = function (obj) {
  if (!obj || typeof obj === "string") {
    return obj;
  }
  const transforms = [];
  for (const key in obj) {
    if (obj.hasOwnProperty(key)) {
      const value = obj[key];
      transforms.push(`${key}(${value})`);
    }
  }
  return transforms.join(" ");
};

export const calc = function (expr, precision) {
  return reduceCSSCalc(`calc(${expr})`, precision);
};

/**
 * Given the name of a color scale, getColorScale will return an array
 * of 5 hex string values in that color scale. If no 'name' parameter
 * is given, it will return the Victory default grayscale.
 * @param {String} name The name of the color scale to return (optional).
 * @returns {Array} An array of 5 hex string values composing a color scale.
 */
export const getColorScale = function (name) {
  const scales = {
    greyscale: [
      "#7d7d7d", "#5e5e5e", "#404040", "#969696",
      "#2b2b2b", "#bdbdbd", "d6d6d6", "#000000"
    ],
    qualitative: [
      "#334D5C", "#45B29D", "#EFC94C", "#E27A3F", "#DF5A49",
      "#4F7DA1", "#55DBC1", "#EFDA97", "#E2A37F", "#DF948A"
    ],
    heatmap: ["#428517", "#77D200", "#D6D305", "#EC8E19", "#C92B05"],
    warm: ["#940031", "#C43343", "#DC5429", "#FF821D", "#FFAF55"],
    cool: ["#2746B9", "#0B69D4", "#2794DB", "#31BB76", "#60E83B"],
    red: ["#611310", "#7D1D1D", "#B02928", "#B02928", "#D86B67"],
    blue: ["#002C61", "#004B8F", "#006BC9", "#3795E5", "#65B4F4"],
    green: ["#354722", "#466631", "#649146", "#8AB25C", "#A9C97E"]
  };
  return name ? scales[name] : scales.victory;
};
<|endoftext|>


<commit_before>import Reader from "./shift-reader";
import { List } from "immutable";
import Syntax from "./syntax";
import Env from "./env";
import reduce from "shift-reducer";
import ParseReducer from "./parse-reducer";
import codegen, { FormattedCodeGen } from "shift-codegen";
import { Scope, freshScope } from "./scope";

import BindingMap from "./binding-map.js";

import Term from "./terms";
import { Modules } from './modules';

export function expand(source, options = {}) {
  let bindings = new BindingMap();
  let modules = new Modules({
    cwd: options.cwd,
    filename: options.filename,
    transform: options.transform ? options.transform : function(x) { return {code: x}; },
    moduleResolver: options.moduleResolver,
    moduleLoader: options.moduleLoader,
    bindings
  });
  let compiledMod = modules.compileEntrypoint(source, options.filename, options.enforcePragma);
  let nativeImports = compiledMod.importEntries.filter(imp => !modules.has(imp.moduleSpecifier.val()));
  return new Term("Module", {
    directives: List(),
    items: nativeImports.concat(compiledMod.body).concat(compiledMod.exportEntries)
  });
}

export function parse(source, options, includeImports = true) {
  return reduce(new ParseReducer({phase: 0}), expand(source, options).gen({includeImports}));
}

export function compile(source, options = {}) {
  let ast = parse(source, options, options.includeImports);
  let gen = codegen(ast, new FormattedCodeGen());
  return options.transform && (!options.noBabel) ? options.transform(gen, {
    babelrc: true,
    filename: options.filename
  }) : { code: gen };
}
<commit_msg>Separate exports with EmptyStatements<commit_after>import Reader from "./shift-reader";
import { List } from "immutable";
import Syntax from "./syntax";
import Env from "./env";
import reduce from "shift-reducer";
import ParseReducer from "./parse-reducer";
import codegen, { FormattedCodeGen } from "shift-codegen";
import { Scope, freshScope } from "./scope";

import BindingMap from "./binding-map.js";

import Term from "./terms";
import { Modules } from './modules';

export function expand(source, options = {}) {
  let bindings = new BindingMap();
  let modules = new Modules({
    cwd: options.cwd,
    filename: options.filename,
    transform: options.transform ? options.transform : function(x) { return {code: x}; },
    moduleResolver: options.moduleResolver,
    moduleLoader: options.moduleLoader,
    bindings
  });
  let compiledMod = modules.compileEntrypoint(source, options.filename, options.enforcePragma);
  let nativeImports = compiledMod.importEntries.filter(imp => !modules.has(imp.moduleSpecifier.val()));
  return new Term("Module", {
    directives: List(),
    items: nativeImports.concat(compiledMod.body).concat(compiledMod.exportEntries.interpose(new Term('EmptyStatement', {})))
  });
}

export function parse(source, options, includeImports = true) {
  return reduce(new ParseReducer({phase: 0}), expand(source, options).gen({includeImports}));
}

export function compile(source, options = {}) {
  let ast = parse(source, options, options.includeImports);
  let gen = codegen(ast, new FormattedCodeGen());
  return options.transform && (!options.noBabel) ? options.transform(gen, {
    babelrc: true,
    filename: options.filename
  }) : { code: gen };
}
<|endoftext|>


<commit_before>var bullshitTerms = [
    '(market|goal|community|quality|results|sales|user|customer|object|subject|aspect|role|service|client)' +
    '.(centric|facing|oriented|service|driven|focused)',
    '24/7',
    'a-b testing',
    'accessib(le|ility)',
    'acquisition',
    'action items?',
    'advantages?',
    'aggregate',
    '(framework|platform).agnostic',
    'analytics?',
    'application service providers?',
    'assets?',
    'authoritative',
    'automated',
    'b2b',
    'back to the drawing board',
    'ball.?park',
    'band.aid',
    'bandwidth',
    'benchmark',
    'benefit analysis',
    'best.of.breed',
    'best.practice',
    'big.data',
    'big picture',
    'bottom line',
    'bottom.up',
    'brain.?storm',
    'brain.?dump',
    'brand(s?|ing|ed)',
    'burn.rates?',
    'business.(cases|plans)?',
    'business.centric(ity)?',
    'buzz',
    'call to action',
    'capacity',
    'capitalize',
    'center of excellence',
    'challenges?',
    'change agent',
    'circle the wagons',
    'cloud.based',
    'collaborat(e|ion)',
    'communicat(e|ion)',
    'compelling',
    'competitive( advantage)?',
    'connect the dots',
    'content management',
    'contingency plan',
    'control group',
    'convergent',
    'conversion',
    'core business',
    'core competenc(y|ies)',
    'cost-effective',
    'cost/benefit',
    'craftsmanship',
    'critical path',
    'crm',
    'cross.sell',
    'crowd.?(fund(s?|ed|ing)|sourc(ed|e|ing))',
    'customer service',
    'cutting.edge',
    'data mining',
    'deep dive',
    'delight the customers?',
    'deliverables?',
    'demographic',
    'discovery',
    'diversity',
    'downsize',
    'drill down',
    'drink the kool-aid',
    'drop.?in',
    'drop the ball',
    'due dilligence',
    'dynamic',
    'e-?(business|commerce|tailers)',
    'ecosystems?',
    'efficien(t|cy)',
    'elaboration',
    'elephant in the room',
    'elevator pitch',
    'emerging markets',
    'empower(ment)?',
    'end of the day',
    'end to end',
    'engage',
    'enhance',
    'enterprise',
    'eta',
    'etched in stone',
    'exceed expectations',
    'expectations',
    'experiences',
    'exposure',
    'eyeballs',
    'facilitate',
    'facilitator',
    'fast track',
    'fault.tolerant',
    'first to market',
    'flexibility',
    'focused',
    'followup',
    'foot view',
    '(front.?end.|ui.)?frame.?work',
    'front lines',
    'functional',
    'full benefit',
    'game plan',
    'gap analysis',
    'go public',
    'go to market',
    'goals',
    'going forward',
    'google juice',
    'graceful.degradation',
    'gradual.enhancement',
    'granular',
    'growth',
    'grow',
    'guidance',
    'hardball',
    'having said that',
    'heads.up',
    'heavy.lifting',
    'herding cats',
    'high.level',
    '(high|mass).impact',
    'html5',
    'impactful',
    'implementation',
    'in a nutshell',
    'incent',
    'incentivize',
    'innovat(e|ed|ion|ive|ing)',
    'integrat(e|ed|ion)',
    'internet of things',
    'intellectual property',
    'intuitive',
    'knowledge base',
    'knowledge transfer',
    'landing pages?',
    'lead the field',
    'leadership',
    'legacy',
    'lessons learned',
    'level playing field',
    'level set',
    'leverage',
    'low-hanging fruit',
    'look.(&|and).feel',
    'market leader',
    'market window',
    'marketing collateral',
    'maximize',
    'measurement',
    'methodolog(y|ies)',
    'metrics',
    'middleware',
    'milestone',
    'mind share',
    'mind shower',
    'mindset',
    'mindshare',
    'mission.critical',
    'monetize',
    'moving forward',
    'multitask',
    'multitasking',
    'mvc',
    'mvp',
    'negotiated',
    'networking',
    'new economy',
    'next level',
    'niche',
    'niches',
    'no-brainer',
    'non-traditional management',
    'nosql',
    'objectives',
    'occupy the field',
    'off.site meeting',
    'off.the.(radar|shelf)',
    'off-?line',
    'on board',
    'on the (back end|radar screen|same page)',
    'one to one',
    'oop',
    'opportunit(y|ies)',
    'optimization',
    'out(side)?.of.the.(box|loop)',
    'outsourc(e|ed|ing)',
    'ownership',
    'paradigm shift',
    'paradigms?',
    'partnerships?',
    'partner',
    'patent',
    'performance indicators',
    'personalization',
    'perspective',
    'phase',
    'phased approach',
    'pipeline',
    'planning horizon',
    'plug.?in',
    'prioritized?',
    'proactive',
    'problem space',
    'process assessment',
    'processes',
    'process-centric',
    'profitability',
    'profit',
    'promotional collateral',
    'promotion',
    'proprietary',
    'proof.of.concept',
    'push the envelope',
    'pushback',
    'quick win',
    'rais(e|ing) the bar',
    'ramp.up',
    'relationship management',
    'responsive',
    'engagements?',
    'engage',
    'reach out',
    'reactivation',
    'real.time',
    'real.world',
    'reconfigure',
    'red flag',
    'reengineering',
    'reinvent(ing)? the(.square)? wheel',
    'reinvigorate',
    'relevance',
    'repurpose',
    'resource allocation',
    'restructuring',
    'retention',
    'return on investment',
    'reusability',
    'reuse',
    'revenue',
    'reverse.engineer',
    'revisit',
    'road ?map',
    'robust',
    'roi',
    'run the numbers',
    'scale',
    'scenarios?',
    'scope',
    'seamless',
    'search engine optimization',
    'secret sauce',
    'segment',
    'self-managed team',
    'seo',
    'shareholder value',
    'single-source responsibility',
    'skill sets?',
    'smoke (&|and) mirrors',
    'social(.media|.gaming|.networks?)',
    'solutions?',
    'soup to nuts',
    'sow',
    'stakeholder',
    'startup',
    'statement of work',
    'sticky-?ness',
    'strateg(y|ic|ize)',
    'streamline',
    'success',
    'sustainab(le|ility)',
    'synerg(y|ies)',
    'tailwinds?',
    'take offline',
    'talking points',
    'target (audience|group)',
    'targeted',
    'tasked',
    'tco',
    'team building',
    'team player',
    'teamwork',
    'technologies',
    'technology solutions',
    'that being said',
    'time.to.market',
    'time.critical',
    'timelines?',
    'top.down',
    'top of the game',
    'total cost of ownership',
    'total quality',
    'touch.base',
    'touchpoints',
    'traction',
    'turnkey',
    'up.to.speed',
    'up-?sell',
    'upside',
    'user.friendly',
    'user.experience',
    'utiliz(e|ation)',
    'unique approach',
    'values?',
    'value-added',
    'vertical market',
    'viral',
    'virtual(ization)?',
    'visibility',
    'vision',
    'walk the talk',
    'web (2|3)\\.0',
    'web.enabled',
    'win-win',
    'window of opportunity',
    'wisdom of crowds',
    'workflow',
    'workshop',
    'world.?class',
    'wow.factor'
];
<commit_msg>cleanup terms more, start categorizing<commit_after>var bullshitTerms = [
    '(market|goal|community|quality|results|sales|user|customer' +
        '|subject|role|service|client|process|business)' +
        '.(centric(ity)?)|facing|oriented|driven|focused|assessment|service)',
    '24/7',
    'a-b testing',
    'accessib(le|ility)',
    'acquisition',
    'action items?',
    'advantages?',
    'aggregate',
    'analytics?',
    'application service providers?',
    'assets?',
    'authoritative',
    'automated',
    'b2b',
    'back to the drawing board',
    'ball.?park',
    'band.aid',
    'bandwidth',
    'benchmark',
    '(benefit|gap) analysis',
    'best.of.breed',
    'best.practice',
    'big.data',
    'big picture',
    'bottom line',
    'bottom.up',
    'brain.?storm',
    'brain.?dump',
    'brand(s?|ing|ed)',
    'burn.rates?',
    'business.(cases|plans)?',
    'buzz',
    'call to action',
    'capacity',
    'capitalize',
    'center of excellence',
    'challenges?',
    'change agent',
    'circle the wagons',
    'collaborat(e|ion)',
    'communicat(e|ion)',
    'compelling',
    'competitive( advantage)?',
    'connect the dots',
    'content management',
    'contingency plan',
    'control group',
    'convergent',
    'conversion',
    'core business',
    'core competenc(y|ies)',
    'cost-effective',
    'cost/benefit',
    'craftsmanship',
    'critical path',
    'crm',
    'cross.sell',
    'crowd.?(fund(s?|ed|ing)|sourc(ed|e|ing))',
    'cutting.edge',
    'data mining',
    'deep dive',
    'delight the customers?',
    'deliverables?',
    'demographic',
    'discovery',
    'diversity',
    'downsize',
    'drill down',
    'drink the kool-aid',
    'drop.?in',
    'drop the ball',
    'due dilligence',
    'dynamic',
    'e-?(business|commerce|tailers)',
    'ecosystems?',
    'efficien(t|cy)',
    'elaboration',
    'elephant in the room',
    'elevator pitch',
    'emerging markets',
    'empower(ment)?',
    'end of the day',
    'end to end',
    'engage',
    'enhance',
    'enterprise',
    'eta',
    'etched in stone',
    'exceed expectations',
    'expectations',
    'experiences',
    'exposure',
    'eyeballs',
    'facilitat(e|or)',
    'fast track',
    'fault.tolerant',
    'first to market',
    'flexibility',
    'followup',
    'foot view',
    'front lines',
    'functional',
    'full benefit',
    'game plan',
    'go public',
    'go to market',
    'goals?',
    'going forward',
    'google juice',
    'graceful.degradation',
    'gradual.enhancement',
    'granular',
    'growth',
    'grow',
    'guidance',
    'hardball',
    'having said that',
    'heads.up',
    'heavy.lifting',
    'herding cats',
    'high.level',
    '(high|mass).impact',
    'impactful',
    'implementation',
    'in a nutshell',
    'incent',
    'incentivize',
    'innovat(e|ed|ion|ive|ing)',
    'integrat(e|ed|ion)',
    'internet of things',
    'intellectual property',
    'intuitive',
    'knowledge base',
    'knowledge transfer',
    'landing pages?',
    'lead the field',
    'leadership',
    'legacy',
    'lessons learned',
    'level playing field',
    'level set',
    'leverage',
    'low-hanging fruit',
    'look.(&|and).feel',
    'market leader',
    'market window',
    'marketing collateral',
    'maximize',
    'measurement',
    'methodolog(y|ies)',
    'metrics',
    'middleware',
    'milestone',
    'mind share',
    'mind shower',
    'mindset',
    'mindshare',
    '(mission|time).critical',
    'monetize',
    'moving forward',
    'multitask(ing?)',
    'negotiated',
    'networking',
    'new economy',
    'next level',
    'niches?',
    'no-brainer',
    'non-traditional management',
    'objectives',
    'occupy the field',
    'off.site',
    'off.the.(radar|shelf)',
    'on board',
    'on the (back end|radar screen|same page)',
    'one to one',
    'opportunit(y|ies)',
    '(search engine )?optimization',
    'out(side)?.of.the.(box|loop)',
    'outsourc(e|ed|ing)',
    '(total cost of )?ownership',
    'paradigms?( shift)?',
    'partner(ships?)?',
    'patent',
    'performance indicators',
    'personalization',
    'perspective',
    'phase',
    'phased approach',
    'pipeline',
    'planning horizon',
    'plug.?in',
    'prioritized?',
    'proactive',
    'problem space',
    'processes',
    'profit(ability)?',
    'promotion',
    'promotional collateral',
    'proprietary',
    'proof.of.concept',
    'push the envelope',
    'push.back',
    'quick win',
    'rais(e|ing) the bar',
    'ramp.up',
    'relationship management',
    'responsive',
    'engage(ments?)?',
    'reach out',
    'reactivation',
    'real.time',
    'real.world',
    'reconfigure',
    'red flag',
    'reengineering',
    'reinvent(ing)? the(.square)? wheel',
    'reinvigorate',
    'relevance',
    'repurpose',
    'resource allocation',
    'restructuring',
    'retention',
    'return on investment',
    'reus(e|ability)',
    'revenue',
    'reverse.engineer',
    'revisit',
    'road ?map',
    'robust',
    'roi',
    'run the numbers',
    'scale',
    'scenarios?',
    'scope',
    'seamless',
    'secret sauce',
    'segment',
    'self-managed team',
    'seo',
    'shareholder value',
    'single-source responsibility',
    'skill sets?',
    'smoke (&|and) mirrors',
    'social(.media|.gaming|.networks?)',
    'solutions?',
    'soup to nuts',
    'sow',
    'stakeholder',
    'startup',
    'statement of work',
    'sticky-?ness',
    'strateg(y|ic|ize)',
    'streamline',
    'success',
    'sustainab(le|ility)',
    'synerg(y|ies)',
    'tailwinds?',
    'take offline',
    'talking points',
    'target (audience|group)',
    'targeted',
    'tasked',
    'tco',
    'team.building',
    'team.player',
    'teamwork',
    'technologies',
    'that being said',
    'time.to.market',
    'timelines?',
    'top.down',
    'top of the game',
    'total quality',
    'touch.base',
    'touchpoints',
    'traction',
    'turnkey',
    'up.to.speed',
    'up-?sell',
    'upside',
    'user.friendly',
    'user.experience',
    'utiliz(e|ation)',
    'unique approach',
    'values?',
    'value-added',
    'vertical market',
    'viral',
    'virtual(ization)?',
    'visibility',
    'vision',
    'walk the talk',
    'web.enabled',
    'win-win',
    'wisdom of crowds',
    'workflow',
    'workshop',
    'world.?class',
    'wow.factor',

    // technical bullshit
    'cloud',
    '(object|aspect).oriented',
    '(framework|platform).agnostic',
    '(front.?end.|ui.)?framework',
    'html5',
    'mv(c|p)',
    'nosql',
    'off-?line',
    'oop',
    'web (2|3)\\.0'
];
<|endoftext|>


<commit_before>export default [
    '(business|client|community|culture|customer|data|goal|intelligence|market' +
        '|process|quality|results|role|sales|subject|service|user)' +
        '.(centric(ity)?|facing|oriented|driven|focused|assessment|service|process)',
    '24/7',
    'ai',
    'agile',
    'artificial intelligence',
    'at (your|their) fingertips',
    'autonomous',
    'a[-/]b testing',
    'acquisition',
    'action items?',
    'advantages?',
    'aggregate',
    'accelerate',
    'all.in.one',
    'analytics?',
    'application service providers?',
    'assets?',
    'authoritative',
    'automated',
    'augmented',
    'extended reality',
    'award.winning',
    'b2b',
    'back to the drawing board',
    'ball.?park',
    'band.aid',
    'bandwidth',
    '(benefit|gap) analysis',
    'bespoke',
    'best-in-class',
    'best.of.breed',
    'best.practice',
    'big.data',
    'big picture',
    'big thinkers?',
    'blockchain',
    'blazingly fast',
    'bottom line',
    'bottom.up',
    'boost(s|ing)?',
    'brain.?storm(ing)?',
    'brain.?dump',
    'brand(s?|ing|ed)',
    'bright',
    'burn.rates?',
    'business( cases| plans)?',
    'buzz',
    'call to action',
    'capacity',
    'capabilit(y|ies)',
    'capitali(s|z)e',
    'centers? of excellence',
    'challenges?',
    'change agents?',
    'circle the wagons',
    'cloud',
    'collaborat(e|ion|ive)s?',
    'communicat(e|ion)s?',
    'company-employee.fit',
    'compelling',
    'competitive( advantage)?',
    'connected systems?',
    'complex',
    'comprehensive',
    'connect the dots',
    'containerizat(e|ion|ing)',
    'content management',
    'contextual(ly)?',
    'contingency plans?',
    'control groups?',
    'convergence',
    'convergent',
    'conversions?',
    'core business',
    'core competenc(y|ies)',
    'core.to.edge',
    'cost-effective',
    'cost/benefit',
    'cost control',
    'craftsmanship',
    'critical path',
    'crypto.currency',
    'crypto(?!graphy).\\w+',
    'crm',
    'cross.sell',
    'crowd.?(fund(s?|ed|ing)|sourc(ed|e|ing))',
    'customer obsession',
    'cutting.edge',
    'cyber',
    'data mining',
    'de-dupe',
    'deep dive',
    'deep learning',
    'delight',
    'deliverables?',
    'demographic',
    'devops',
    'digital transformation',
    'discovery',
    'distributed ledgers?',
    'disrupt(ive)?',
    'dollar.productive',
    'downsi(s|z)e',
    'drill down',
    'drink the kool-aid',
    'drop.?in',
    'drop the ball',
    'due dilligence',
    'dynamic(s|ally)?',
    'e-?(business|commerce|tailers)',
    'easily',
    'easy',
    'ecosystems?',
    'efficien(t|cy)',
    'elaboration',
    'elephant in the room',
    'elevator pitch',
    'enabl(e|ing)',
    'emerging markets?',
    'empower(ing|ment|s)?',
    'enablement',
    'end of the day',
    'end.to.end',
    'engulf',
    'engag(e|ing)',
    'enhanced?',
    'enterprise',
    'erp',
    'estimate',
    'eta',
    'etched in stone',
    'exceed expectations',
    'exhaustive',
    'expedite',
    'experiences',
    'experts?',
    'expertise',
    'exposure',
    'facilitat(e|or)',
    'fast track',
    'fault.tolerant',
    'first.to.market',
    'flexibility',
    'foot view',
    'four pillars',
    'front lines',
    'functional',
    'futurist',
    'full benefit',
    'game changer',
    'game plan',
    'behavioral',
    'go public',
    'go.to.market',
    'goals?',
    'going forward',
    'granular',
    'ground.?breaking',
    'growth',
    'grow',
    'guidance',
    'guru',
    'hackathon',
    'hacker( mindset)?',
    'happiness manage(ment|rs?)',
    'hardball',
    'heavy.lifting',
    'herding cats',
    'high.level',
    '(high|mass).impact',
    'hive ?mind',
    'hybrid environments?',
    'hyperconverged',
    'holistic',
    'impactful',
    'impeccable',
    'in a nutshell',
    'incent',
    'incentivi(s|z)e',
    'increase the odds',
    '(inflat|redeem)able value',
    'influencers?',
    'innovat(e|ed|ion|ive|ing|or)s?',
    'inspir(e|ing|ation)',
    'insights?',
    'integrat(e|ed|ion)s?',
    'internet of things',
    'intellectual property',
    'intuitive',
    'iot',
    'knowledge (base|transfer)',
    'KPIs?',
    'landing pages?',
    'lead the field',
    'leading',
    'leaders?',
    'leadership',
    'learnings',
    'legacy',
    'lessons learned',
    'level playing field',
    'level set',
    'leverag(e|ing)',
    'low.hanging fruit',
    'look.(&|and).feel',
    'm2m',
    'machine learning',
    'made simple',
    'market (chang(er|ing)|leader|window)',
    'market.ready',
    'marketing collateral',
    'maximi(s|z)e',
    'meaningful( client | )interactions?',
    'measurements?',
    'methodolog(y|ies)',
    'metrics',
    'middleware',
    'milestone',
    'military-grade encryption',
    'mind ?share',
    'mind ?shower',
    'mind-boggling',
    'mindset',
    '(mission|time).critical',
    'ml',
    'moneti(s|z)e',
    'mov(e|ing) (fast|forward)',
    'multitask(ing?)',
    'multifaceted',
    'negotiated',
    'networking',
    'new economy',
    'new.breed',
    '(new|next|second).(level|gen|generation)',
    'niches?',
    'ninja',
    'no-brainer',
    'non-traditional management',
    'objectives',
    'occupy the field',
    'off.site',
    'off.the.(radar|shelf)',
    'on board',
    'on.premises?',
    'on the (back end|radar screen|same page)',
    'one to one',
    'opportunit(y|ies)',
    'outperform',
    'optimal',
    'outstanding',
    'out(side)?.of.the.(box|loop)',
    'outsourc(e|ed|ing)',
    '(total cost of )?ownership',
    'paradigms?( shift)?',
    'partner(ships?)?',
    'patents?',
    'performance indicators',
    'personaliz(e|ed|ation)',
    'perspective',
    'phases?',
    'phased approach',
    'pipeline',
    'pioneers',
    'planning horizon',
    'platforms?',
    'plug.?in',
    'pop',
    'potentials?',
    'powerful',
    'prioriti(s|z)ed?',
    'proactive',
    'problem space',
    'processes',
    'profit(ability)?',
    'promotion',
    'promotional collateral',
    'prominent',
    'proprietary',
    'proof.of.concept',
    'push the envelope',
    'push.back',
    'productivity',
    'quick wins?',
    'rais(e|ing) the bar',
    'ramp.up',
    'relationship management',
    'responsive',
    'engage(ments?)?',
    'reach out',
    'reactivation',
    'real.time',
    'real.world',
    'reconfigure',
    'redefin(e|ed|ing)',
    'red flags?',
    'reengineering',
    'reinvent(ing)? the(.square)? wheel',
    'reinvigorate',
    'relevance',
    'repurpose',
    'resilien(ce|cy|t)',
    'resource allocation',
    'restructuring',
    'retention',
    'return on investment',
    'reus(e|ability)',
    'revenue',
    'reverse.engineer',
    'revisit',
    'rich',
    'road ?map',
    'robust',
    'rock.?star',
    'roi',
    'run the numbers',
    '(s|p)aas',
    'scal(e|es|ing|ability)',
    'high availability',
    'scenarios?',
    'scope',
    'scrum( master)?',
    'seamless',
    'secret sauce',
    'search engine optimization',
    'segments?',
    'self-managed team',
    'seo',
    '(serial )?entrepreneurs?',
    'serverless',
    'shareholder value',
    'significant(ly)?',
    'single-source responsibility',
    'skill ?sets?',
    'smoke (&|and) mirrors',
    'social(.media|.gaming|.networks?)',
    'solutions?',
    'sophisticated',
    'soup to nuts',
    'sow',
    'stakeholders?',
    'start.up?',
    'statement of work',
    'state.of.the.art',
    'sticky-?ness',
    'strateg(y|ic|ize|ise)',
    'streamlin(ed|e|ing)',
    'story points?',
    'success(ful)?',
    'super(critical|star)',
    'sustainab(le|ility)',
    'synerg(y|ies|ized|i)',
    'tailwinds?',
    'talented',
    'take offline',
    'talking points',
    'target (audience|group)',
    'targeted',
    'tasked',
    'tco',
    'team.building',
    'team.player',
    'teamwork',
    'technolog(y|ies)',
    'that being said',
    'time.to.market',
    'timelines?',
    'top.down',
    'top of the game',
    'total quality',
    'touch.base',
    'touchpoints?',
    'traction',
    'transform',
    'trends?',
    'turnkey',
    'ultimate',
    'up.to.speed',
    'up-?sell',
    'upside',
    'user.friendly',
    'user funnels?',
    'user.experience',
    'utili(s|z)(e|ation)',
    'unicorn',
    'unique approach',
    'unlimited.holidays',
    'values?',
    'valueable',
    'value.add(ed)?',
    'vertical market',
    'viral',
    'virtual(ization|isation)?',
    'visibility',
    'vision',
    'walk the talk',
    'wearable',
    'web.enabled',
    'win-win',
    'wisdom of crowds',
    'with due respect',
    'with ease',
    'workflows?',
    'world.?class',
    'world a better place',
    'wow.factor'
];
<commit_msg>Update terms.js (#81)<commit_after>export default [
    '(business|client|community|culture|customer|data|goal|intelligence|market' +
        '|process|quality|results|role|sales|subject|service|user)' +
        '.(centric(ity)?|facing|oriented|driven|focused|assessment|service|process)',
    '24/7',
    'ai',
    'agile',
    'artificial intelligence',
    'at (your|their) fingertips',
    'autonomous',
    'a[-/]b testing',
    'acquisition',
    'action items?',
    'advantages?',
    'aggregate',
    'accelerate',
    'all.in.one',
    'analytics?',
    'application service providers?',
    'assets?',
    'authoritative',
    'automated',
    'augmented',
    'extended reality',
    'award.winning',
    'b2b',
    'back to the drawing board',
    'ball.?park',
    'band.aid',
    'bandwidth',
    '(benefit|gap) analysis',
    'bespoke',
    'best-in-class',
    'best.of.breed',
    'best.practice',
    'big.data',
    'big picture',
    'big thinkers?',
    'blockchain',
    'blazingly fast',
    'bottom line',
    'bottom.up',
    'boost(s|ing)?',
    'brain.?storm(ing)?',
    'brain.?dump',
    'brand(s?|ing|ed)',
    'bright',
    'burn.rates?',
    'business( cases| plans)?',
    'buzz',
    'call to action',
    'capacity',
    'capabilit(y|ies)',
    'capitali(s|z)e',
    'centers? of excellence',
    'challenges?',
    'change agents?',
    'circle the wagons',
    'cloud',
    'collaborat(e|ion|ive)s?',
    'communicat(e|ion)s?',
    'company-employee.fit',
    'compelling',
    'competitive( advantage)?',
    'connected systems?',
    'complex',
    'comprehensive',
    'connect the dots',
    'containerizat(e|ion|ing)',
    'content management',
    'contextual(ly)?',
    'contingency plans?',
    'control groups?',
    'convergence',
    'convergent',
    'conversions?',
    'core business',
    'core competenc(y|ies)',
    'core.to.edge',
    'cost-effective',
    'cost/benefit',
    'cost control',
    'craftsmanship',
    'critical path',
    'crypto.currency',
    'crypto(?!graphy).\\w+',
    'crm',
    'cross.sell',
    'crowd.?(fund(s?|ed|ing)|sourc(ed|e|ing))',
    'customer obsession',
    'cutting.edge',
    'cyber',
    'data mining',
    'de-dupe',
    'deep dive',
    'deep learning',
    'delight',
    'deliverables?',
    'demographic',
    'devops',
    'digital transformation',
    'discovery',
    'distributed ledgers?',
    'disrupt(ive)?',
    'dollar.productive',
    'downsi(s|z)e',
    'drill down',
    'drink the kool-aid',
    'drop.?in',
    'drop the ball',
    'due dilligence',
    'dynamic(s|ally)?',
    'e-?(business|commerce|tailers)',
    'easily',
    'easy',
    'ecosystems?',
    'efficien(t|cy)',
    'elaboration',
    'elephant in the room',
    'elevator pitch',
    'enabl(e|ing)',
    'emerging markets?',
    'empower(ing|ment|s)?',
    'enablement',
    'end of the day',
    'end.to.end',
    'engulf',
    'engag(e|ing)',
    'enhanced?',
    'enterprise',
    'erp',
    'estimate',
    'eta',
    'etched in stone',
    'exceed expectations',
    'exhaustive',
    'expedite',
    'experiences',
    'experts?',
    'expertise',
    'exposure',
    'facilitat(e|or)',
    'fast track',
    'fault.tolerant',
    'first.to.market',
    'flexibility',
    'foot view',
    'four pillars',
    'front lines',
    'functional',
    'futurist',
    'full benefit',
    'game changer',
    'game plan',
    'behavioral',
    'go public',
    'go.to.market',
    'goals?',
    'going forward',
    'granular',
    'ground.?breaking',
    'growth',
    'grow',
    'guidance',
    'guru',
    'hackathon',
    'hacker( mindset)?',
    'happiness manage(ment|rs?)',
    'hardball',
    'heavy.lifting',
    'herding cats',
    'high.level',
    '(high|mass).impact',
    'hive ?mind',
    'hybrid environments?',
    'hyperconverged',
    'holistic',
    'impactful',
    'impeccable',
    'in a nutshell',
    'incent',
    'incentivi(s|z)e',
    'increase the odds',
    '(inflat|redeem)able value',
    'influencers?',
    'innovat(e|ed|ion|ive|ing|or)s?',
    'inspir(e|ing|ation)',
    'insights?',
    'integrat(e|ed|ion)s?',
    'internet of things',
    'intellectual property',
    'intuitive',
    'iot',
    'knowledge (base|transfer)',
    'KPIs?',
    'landing pages?',
    'lead the field',
    'leading',
    'leaders?',
    'leadership',
    'learnings',
    'legacy',
    'lessons learned',
    'level playing field',
    'level set',
    'leverag(e|ing)',
    'low.hanging fruit',
    'look.(&|and).feel',
    'm2m',
    'machine learning',
    'made simple',
    'market (chang(er|ing)|leader|window)',
    'market.ready',
    'marketing collateral',
    'maximi(s|z)e',
    'meaningful( client | )interactions?',
    'measurements?',
    'methodolog(y|ies)',
    'metrics',
    'middleware',
    'milestone',
    'military-grade encryption',
    'mind ?share',
    'mind ?shower',
    'mind-boggling',
    'mindset',
    '(mission|time).critical',
    'ml',
    'moneti(s|z)e',
    'mov(e|ing) (fast|forward)',
    'multitask(ing?)',
    'multifaceted',
    'negotiated',
    'networking',
    'new economy',
    'new.breed',
    '(new|next|second).(level|gen|generation)',
    'niches?',
    'ninja',
    'no-brainer',
    'non-traditional management',
    'objectives',
    'occupy the field',
    'off.site',
    'off.the.(radar|shelf)',
    'on board',
    'on.premises?',
    'on the (back end|radar screen|same page)',
    'one to one',
    'opportunit(y|ies)',
    'outperform',
    'optimal',
    'outstanding',
    'out(side)?.of.the.(box|loop)',
    'outsourc(e|ed|ing)',
    '(total cost of )?ownership',
    'paradigms?( shift)?',
    'partner(ships?)?',
    'patents?',
    'performance indicators',
    'personaliz(e|ed|ation)',
    'perspective',
    'phases?',
    'phased approach',
    'pipeline',
    'pioneers',
    'planning horizon',
    'platforms?',
    'plug.?in',
    'pop',
    'potentials?',
    'powerful',
    'prioriti(s|z)ed?',
    'proactive',
    'problem space',
    'processes',
    'profit(ability)?',
    'promotion',
    'promotional collateral',
    'prominent',
    'proprietary',
    'proof.of.concept',
    'push the envelope',
    'push.back',
    'productivity',
    'pushing on open doors',
    'quick wins?',
    'rais(e|ing) the bar',
    'ramp.up',
    'relationship management',
    'responsive',
    'engage(ments?)?',
    'reach out',
    'reactivation',
    'real.time',
    'real.world',
    'reconfigure',
    'redefin(e|ed|ing)',
    'red flags?',
    'reengineering',
    'reinvent(ing)? the(.square)? wheel',
    'reinvigorate',
    'relevance',
    'repurpose',
    'resilien(ce|cy|t)',
    'resource allocation',
    'restructuring',
    'retention',
    'return on investment',
    'reus(e|ability)',
    'revenue',
    'reverse.engineer',
    'revisit',
    'rich',
    'road ?map',
    'robust',
    'rock.?star',
    'roi',
    'run the numbers',
    '(s|p)aas',
    'scal(e|es|ing|ability)',
    'high availability',
    'scenarios?',
    'scope',
    'scrum( master)?',
    'seamless',
    'secret sauce',
    'search engine optimization',
    'segments?',
    'self-managed team',
    'seo',
    '(serial )?entrepreneurs?',
    'serverless',
    'shareholder value',
    'significant(ly)?',
    'single-source responsibility',
    'skill ?sets?',
    'smoke (&|and) mirrors',
    'social(.media|.gaming|.networks?)',
    'solutions?',
    'sophisticated',
    'soup to nuts',
    'sow',
    'stakeholders?',
    'start.up?',
    'statement of work',
    'state.of.the.art',
    'sticky-?ness',
    'strateg(y|ic|ize|ise)',
    'streamlin(ed|e|ing)',
    'story points?',
    'success(ful)?',
    'super(critical|star)',
    'sustainab(le|ility)',
    'synerg(y|ies|ized|i)',
    'tailwinds?',
    'talented',
    'take offline',
    'talking points',
    'target (audience|group)',
    'targeted',
    'tasked',
    'tco',
    'team.building',
    'team.player',
    'teamwork',
    'technolog(y|ies)',
    'that being said',
    'time.to.market',
    'timelines?',
    'top.down',
    'top of the game',
    'total quality',
    'touch.base',
    'touchpoints?',
    'traction',
    'transform',
    'trends?',
    'turnkey',
    'ultimate',
    'up.to.speed',
    'up-?sell',
    'upside',
    'user.friendly',
    'user funnels?',
    'user.experience',
    'utili(s|z)(e|ation)',
    'unicorn',
    'unique approach',
    'unlimited.holidays',
    'values?',
    'valueable',
    'value.add(ed)?',
    'vertical market',
    'viral',
    'virtual(ization|isation)?',
    'visibility',
    'vision',
    'walk the talk',
    'wearable',
    'web.enabled',
    'win-win',
    'wisdom of crowds',
    'with due respect',
    'with ease',
    'workflows?',
    'world.?class',
    'world a better place',
    'wow.factor'
];
<|endoftext|>


<commit_before>export default [
    '(business|client|community|culture|customer|data|goal|intelligence|market' +
        '|process|quality|results|role|sales|subject|service|user)' +
        '.(centric(ity)?|facing|oriented|driven|focused|assessment|service|process)',
    '10x',
    '24/7',
    'ai',
    'agile',
    'ambassador',
    'artificial intelligence',
    'at (your|their) fingertips?',
    'autonomous',
    'a[-/]b testing',
    'acquisition',
    'action items?',
    'act in time',
    'advantages?',
    'agents?',
    'aggregat(e|ion)',
    'accelerate',
    'all.in.one',
    'all.new',
    'amazing',
    'analytics?',
    'application service providers?',
    'as a service',
    'assets?',
    'astonishing',
    'authoritative',
    'automated',
    'augmented',
    'extended reality',
    'award.winning',
    'b2(b|c)',
    'back to the drawing board',
    'ball.?park',
    'band.aid',
    'bandwidth',
    '(benefit|gap) analysis',
    'bespoke',
    'best.in.class',
    'best.of.breed',
    'best.practice',
    'big.data',
    'big picture',
    'big thinkers?',
    'block.?chain',
    'blazing(ly)? fast',
    'boil the ocean',
    'bottom.line',
    'bottom.up',
    'boost(s|ing)?',
    'boundless',
    'brain.?storm(ing)?',
    'brain.?dump',
    'brand(s?|ing|ed)',
    'bright',
    'building.trust',
    'bulletproof',
    'burn.rates?',
    'business( cases| plans)',
    'buzz',
    'call to action',
    'capacity',
    'capabilit(y|ies)',
    'capitali(s|z)e',
    'centers? of excellence',
    'challenges?',
    'change agents?',
    'circle the wagons',
    'client-centered',
    'client-centric',
    'client-focused',
    'cloud',
    'cloud native',
    'cloudify',
    'collaborat(e|ion|ive)s?',
    'comfort( zone)?',
    'committee',
    'communicat(e|ion)s?',
    'company-employee.fit',
    'compelling',
    'competitive( advantage)?',
    'connected systems?',
    'complex(ity)?',
    'comprehensive',
    'connect the dots',
    'container orchestration',
    'containerizat(e|ion|ing)',
    'content management',
    'contextual(ly)?',
    'contingency plans?',
    'control groups?',
    'control plane',
    'convergence',
    'convergent',
    'conversions?',
    'core business',
    'core competenc(y|ies)',
    'core.to.edge',
    'cosmic',
    'cost-effective',
    'cost/benefit',
    'cost control',
    'craftsmanship',
    'critical path',
    'crypto.currency',
    'crypto(?!graphy).\\w+',
    'crm',
    'cross.sell',
    'crowd.?(fund(s?|ed|ing)|sourc(ed|e|ing))',
    'customer obsession',
    'cutting.edge',
    'cyber',
    'dashboards?',
    'dashboarding',
    'data mining',
    'decentrali(s|z)ed',
    'de-?dupe',
    'deep dive',
    'deep learning',
    'delight',
    'deliverables?',
    'demographic',
    'demystify',
    'demystifying',
    'deployless',
    'devops',
    'digital transformation',
    'differentiation',
    'discovery',
    'distributed ledgers?',
    'disrupt(ive|tor|ion|er)?',
    'dollar.productive',
    'downsi(s|z)e',
    'drill down',
    'drink the kool-aid',
    'drop.?in',
    'drop the ball',
    'due dilligence',
    'dynamic(s|ally)?',
    'e-?(business|commerce|tailers)',
    'early.stage',
    'eas(y|ily)',
    'ecosystem(s)?',
    'efficien(t|cy)',
    'effortless(ly)?',
    'elastic',
    'elaboration',
    'elephant in the room',
    'elevator pitch(ing)?',
    'enabl(e|ing)',
    'emerging markets?',
    'empower(ing|ment|s)?',
    'enablement',
    'end of the day',
    'end.to.end',
    'engulf',
    'engag(e(d)|ing|ment)',
    'enhanced?',
    'enterprise',
    'erp',
    'estimate',
    'eta',
    'etched in stone',
    'evolution',
    'exceed expectations',
    'excellent',
    'exceptional',
    'exclusive(ly)?',
    'exhaustive',
    'expedite',
    'experiences',
    'experts?',
    'expertise',
    'exposure',
    'extraordinary',
    'facilitat(e|or)',
    'fast track',
    'fault.tolerant',
    'feeling excited',
    'first.rate',
    'first.to.market',
    'flexibility',
    'flux',
    'foot view',
    'forward-thinking',
    'four pillars',
    'frictionless',
    'front lines',
    'frustration[- ]free',
    'functional',
    'futurist',
    'full benefit',
    'future.proof',
    'game changer',
    'game plan',
    'behavioral',
    'global(ly)?',
    'go public',
    'go.to.market',
    'goals?',
    'god-speed',
    'going forward',
    'granular',
    'ground.?breaking',
    'growth',
    'grow',
    'guidance',
    'guru',
    'hackathon',
    'hacker( mindset)?',
    'happiness manage(ment|rs?)',
    'hardball',
    'heavy.lifting',
    'herding cats',
    'hidden.gem',
    'hidden.meaning',
    'high.level',
    '(high|mass).impact',
    'highly.scalable',
    'hive ?mind',
    'hybrid environments?',
    'hyper.personalization',
    'hyperconverged',
    'hyperscal(e|ed|ing)',
    'holistic',
    'ideathon',
    'impactful',
    'impeccable',
    'in( |-)a( |-)nutshell',
    'incent',
    'incentivi(s|z)e',
    'increase the odds',
    'incredibl(e|y)',
    '(inflat|redeem)able value',
    'influencers?',
    'influx',
    'innovat(e|ed|ion|ive|ing|or)s?',
    'inspir(e|ing|ation)',
    'insights?',
    'integrat(e|ed|ion)s?',
    'internet[- ]of[- ]things',
    'intellectual property',
    'intuitive',
    'iot',
    'key results?',
    'kickstart(er|ed)?s?',
    'killjoy',
    'knowledge.(base|transfer|sharing)',
    'kpis?',
    'landing pages?',
    'lead the field',
    'leading',
    'leaders?',
    'leadership',
    'learnings',
    'legacy',
    'lessons learned',
    'level (the )? playing field',
    'level set',
    'leverag(e|ing)',
    'lifecycle',
    'low.hanging fruit',
    'look.(&|and).feel',
    'm2m',
    'machine learning',
    'made simple',
    'magical',
    'market (chang(er|ing)|leader|window|simplified|fit)',
    'market.ready',
    'marketing collateral',
    'maximi(s|z)e',
    'meaningful( client | )interactions?',
    'measurements?',
    'methodolog(y|ies)',
    'metrics',
    'middleware',
    'milestone',
    'military.grade encryption',
    'mind ?share',
    'mind ?shower',
    'mind-boggling',
    'mindset',
    '(mission|time).critical',
    'ml',
    'moneti(s|z)e',
    'mov(e|ing) (fast|forward)',
    'multitask(ing?)',
    'multifaceted',
    'multi-?tenant(ed)?',
    'mvp',
    'negotiated',
    'networking',
    'new.economy',
    'new.breed',
    '(new|next|second).(level|gen|generation)',
    'nexus',
    'niches?',
    'ninja',
    'no-brainer',
    'non-traditional management',
    'objectives',
    'occupy the field',
    'off.site',
    'off.the.(radar|shelf)',
    'on board',
    'on.premises?',
    'on the (back end|radar screen|same page|house)',
    'one to one',
    'open the kimono',
    'opportunit(y|ies)',
    'outperform',
    'optimal',
    'orthogonal',
    'outcome(s)',
    'outstanding',
    'out(side)?.(of)?.the.(box|loop)',
    'outsourc(e|ed|ing)',
    '(total cost of )?ownership',
    'paradigms?( shift)?',
    'partner(ships?)?',
    'patents?',
    'people.focus(ed|sed)',
    'performance indicators',
    'personaliz(e|ed|ation)',
    'perspective',
    'phases?',
    'phased approach',
    'pipeline',
    'pioneers',
    'pivot',
    'planning horizon',
    'platforms?',
    'plethora',
    'plug.?in',
    'potentials?',
    'powerful',
    'prioriti(s|z)ed?',
    'proactive',
    'problem space',
    'processes',
    'profit(ability)?',
    'promotion',
    'promotional collateral',
    'prominent',
    'proprietary',
    'proof.of.concept',
    'purpose.built',
    'push the envelope',
    'push.back',
    'production.ready',
    'productivity',
    'pushing on open doors',
    'quick wins?',
    'rais(e|ing) the bar',
    'ramp.up',
    'ravishing',
    '(reaping )(tangible )rewards',
    'relationship management',
    'responsive',
    'engage(ments?)?',
    'reach out',
    'reactivation',
    'real.time',
    'real.world',
    'reconfigure',
    'redefin(e|ed|ing)',
    'red flags?',
    'reengineering',
    'reimagin(e|ed|ing)',
    'reinvent(ing)? the(.square)? wheel',
    'reinvigorate',
    'relevance',
    'repurpose',
    'resilien(ce|cy|t)',
    'resource allocation',
    'restructuring',
    'retention',
    'return on investment',
    'results',
    'reus(e|ability)',
    'revenue',
    'reverse.engineer',
    'revisit',
    'revolution',
    'rich',
    'road ?map',
    'robust',
    'rock.?star',
    'roi',
    'run the numbers',
    '(s|p)aas',
    'sacrific(e|es|ing)',
    'scal(e|es|ing|ability)',
    'high availability',
    'scenarios?',
    'scope',
    'scrum( master)?',
    'seamless',
    'secret sauce',
    'search engine optimization',
    'segments?',
    'self-managed team',
    'seo',
    '(serial )?entrepreneurs?',
    'serverless',
    'service mesh',
    'shareholder value',
    'significant(ly)?',
    'single-source responsibility',
    'skill ?sets?',
    'smart(er)?',
    'smoke (&|and) mirrors',
    'social(.media|.gaming|.networks?)',
    'solidality',
    'solutions?',
    'sophisticated',
    'soup to nuts',
    'sow',
    'spatial.computing',
    'stakeholders?',
    'start.up?',
    'statement of work',
    'state.of.the.art',
    'step.changes?',
    'sticky-?ness',
    'strateg(y|ic|ize|ise)',
    'streamlin(ed|e|ing)',
    'story points?',
    'success(ful)?',
    'super(critical|star|nova)',
    'sustainab(le|ility)',
    'synerg(y|ies|ized|i)',
    'systems?',
    'tailwinds?',
    'talented',
    'take offline',
    'talking points',
    'target (audience|group)',
    'targeted',
    'tasked',
    'tco',
    'team.building',
    'team.player',
    'teamwork',
    'technolog(y|ies)',
    'that being said',
    'thought.leader',
    'throughput',
    'time.to.awesome',
    'time.to.market',
    'timelines?',
    'top.down',
    'top.of.the.game',
    'total quality',
    'touch.base',
    'touchpoints?',
    'traction',
    'transform(ing|ative|ation(al))',
    'trends?',
    'true',
    'truths?',
    'turnkey',
    'ultimate',
    'up.to.speed',
    'up-?sell',
    'upside',
    'user.friendly',
    'user funnels?',
    'user.experience',
    'utili(s|z)(e|ation)',
    'uncover',
    'unicorn',
    'unique approach',
    'unlimited.holidays',
    'values?',
    'valueable',
    'value.add(ed)?',
    'venture',
    'venturing',
    'vertical market',
    'viral',
    'virtual(ization|isation)?',
    'visibility',
    'visio(n|nary)',
    'walk the talk',
    'wearable',
    'web.enabled',
    'win-win',
    'wisdom of crowds',
    'with due respect',
    'with ease',
    'wizards?',
    'workflows?',
    'workloads?',
    'workplaceless',
    'workspace',
    'world.?class',
    'world a better place',
    'wow.factor',
    'you\'ve never seen (a|an) \\w+',
    'zeitgeist',
    'zenith'
];
<commit_msg>Add cloudification (#150)<commit_after>export default [
    '(business|client|community|culture|customer|data|goal|intelligence|market' +
        '|process|quality|results|role|sales|subject|service|user)' +
        '.(centric(ity)?|facing|oriented|driven|focused|assessment|service|process)',
    '10x',
    '24/7',
    'ai',
    'agile',
    'ambassador',
    'artificial intelligence',
    'at (your|their) fingertips?',
    'autonomous',
    'a[-/]b testing',
    'acquisition',
    'action items?',
    'act in time',
    'advantages?',
    'agents?',
    'aggregat(e|ion)',
    'accelerate',
    'all.in.one',
    'all.new',
    'amazing',
    'analytics?',
    'application service providers?',
    'as a service',
    'assets?',
    'astonishing',
    'authoritative',
    'automated',
    'augmented',
    'extended reality',
    'award.winning',
    'b2(b|c)',
    'back to the drawing board',
    'ball.?park',
    'band.aid',
    'bandwidth',
    '(benefit|gap) analysis',
    'bespoke',
    'best.in.class',
    'best.of.breed',
    'best.practice',
    'big.data',
    'big picture',
    'big thinkers?',
    'block.?chain',
    'blazing(ly)? fast',
    'boil the ocean',
    'bottom.line',
    'bottom.up',
    'boost(s|ing)?',
    'boundless',
    'brain.?storm(ing)?',
    'brain.?dump',
    'brand(s?|ing|ed)',
    'bright',
    'building.trust',
    'bulletproof',
    'burn.rates?',
    'business( cases| plans)',
    'buzz',
    'call to action',
    'capacity',
    'capabilit(y|ies)',
    'capitali(s|z)e',
    'centers? of excellence',
    'challenges?',
    'change agents?',
    'circle the wagons',
    'client-centered',
    'client-centric',
    'client-focused',
    'cloud',
    'cloud native',
    'cloudif(y|ication)',
    'collaborat(e|ion|ive)s?',
    'comfort( zone)?',
    'committee',
    'communicat(e|ion)s?',
    'company-employee.fit',
    'compelling',
    'competitive( advantage)?',
    'connected systems?',
    'complex(ity)?',
    'comprehensive',
    'connect the dots',
    'container orchestration',
    'containerizat(e|ion|ing)',
    'content management',
    'contextual(ly)?',
    'contingency plans?',
    'control groups?',
    'control plane',
    'convergence',
    'convergent',
    'conversions?',
    'core business',
    'core competenc(y|ies)',
    'core.to.edge',
    'cosmic',
    'cost-effective',
    'cost/benefit',
    'cost control',
    'craftsmanship',
    'critical path',
    'crypto.currency',
    'crypto(?!graphy).\\w+',
    'crm',
    'cross.sell',
    'crowd.?(fund(s?|ed|ing)|sourc(ed|e|ing))',
    'customer obsession',
    'cutting.edge',
    'cyber',
    'dashboards?',
    'dashboarding',
    'data mining',
    'decentrali(s|z)ed',
    'de-?dupe',
    'deep dive',
    'deep learning',
    'delight',
    'deliverables?',
    'demographic',
    'demystify',
    'demystifying',
    'deployless',
    'devops',
    'digital transformation',
    'differentiation',
    'discovery',
    'distributed ledgers?',
    'disrupt(ive|tor|ion|er)?',
    'dollar.productive',
    'downsi(s|z)e',
    'drill down',
    'drink the kool-aid',
    'drop.?in',
    'drop the ball',
    'due dilligence',
    'dynamic(s|ally)?',
    'e-?(business|commerce|tailers)',
    'early.stage',
    'eas(y|ily)',
    'ecosystem(s)?',
    'efficien(t|cy)',
    'effortless(ly)?',
    'elastic',
    'elaboration',
    'elephant in the room',
    'elevator pitch(ing)?',
    'enabl(e|ing)',
    'emerging markets?',
    'empower(ing|ment|s)?',
    'enablement',
    'end of the day',
    'end.to.end',
    'engulf',
    'engag(e(d)|ing|ment)',
    'enhanced?',
    'enterprise',
    'erp',
    'estimate',
    'eta',
    'etched in stone',
    'evolution',
    'exceed expectations',
    'excellent',
    'exceptional',
    'exclusive(ly)?',
    'exhaustive',
    'expedite',
    'experiences',
    'experts?',
    'expertise',
    'exposure',
    'extraordinary',
    'facilitat(e|or)',
    'fast track',
    'fault.tolerant',
    'feeling excited',
    'first.rate',
    'first.to.market',
    'flexibility',
    'flux',
    'foot view',
    'forward-thinking',
    'four pillars',
    'frictionless',
    'front lines',
    'frustration[- ]free',
    'functional',
    'futurist',
    'full benefit',
    'future.proof',
    'game changer',
    'game plan',
    'behavioral',
    'global(ly)?',
    'go public',
    'go.to.market',
    'goals?',
    'god-speed',
    'going forward',
    'granular',
    'ground.?breaking',
    'growth',
    'grow',
    'guidance',
    'guru',
    'hackathon',
    'hacker( mindset)?',
    'happiness manage(ment|rs?)',
    'hardball',
    'heavy.lifting',
    'herding cats',
    'hidden.gem',
    'hidden.meaning',
    'high.level',
    '(high|mass).impact',
    'highly.scalable',
    'hive ?mind',
    'hybrid environments?',
    'hyper.personalization',
    'hyperconverged',
    'hyperscal(e|ed|ing)',
    'holistic',
    'ideathon',
    'impactful',
    'impeccable',
    'in( |-)a( |-)nutshell',
    'incent',
    'incentivi(s|z)e',
    'increase the odds',
    'incredibl(e|y)',
    '(inflat|redeem)able value',
    'influencers?',
    'influx',
    'innovat(e|ed|ion|ive|ing|or)s?',
    'inspir(e|ing|ation)',
    'insights?',
    'integrat(e|ed|ion)s?',
    'internet[- ]of[- ]things',
    'intellectual property',
    'intuitive',
    'iot',
    'key results?',
    'kickstart(er|ed)?s?',
    'killjoy',
    'knowledge.(base|transfer|sharing)',
    'kpis?',
    'landing pages?',
    'lead the field',
    'leading',
    'leaders?',
    'leadership',
    'learnings',
    'legacy',
    'lessons learned',
    'level (the )? playing field',
    'level set',
    'leverag(e|ing)',
    'lifecycle',
    'low.hanging fruit',
    'look.(&|and).feel',
    'm2m',
    'machine learning',
    'made simple',
    'magical',
    'market (chang(er|ing)|leader|window|simplified|fit)',
    'market.ready',
    'marketing collateral',
    'maximi(s|z)e',
    'meaningful( client | )interactions?',
    'measurements?',
    'methodolog(y|ies)',
    'metrics',
    'middleware',
    'milestone',
    'military.grade encryption',
    'mind ?share',
    'mind ?shower',
    'mind-boggling',
    'mindset',
    '(mission|time).critical',
    'ml',
    'moneti(s|z)e',
    'mov(e|ing) (fast|forward)',
    'multitask(ing?)',
    'multifaceted',
    'multi-?tenant(ed)?',
    'mvp',
    'negotiated',
    'networking',
    'new.economy',
    'new.breed',
    '(new|next|second).(level|gen|generation)',
    'nexus',
    'niches?',
    'ninja',
    'no-brainer',
    'non-traditional management',
    'objectives',
    'occupy the field',
    'off.site',
    'off.the.(radar|shelf)',
    'on board',
    'on.premises?',
    'on the (back end|radar screen|same page|house)',
    'one to one',
    'open the kimono',
    'opportunit(y|ies)',
    'outperform',
    'optimal',
    'orthogonal',
    'outcome(s)',
    'outstanding',
    'out(side)?.(of)?.the.(box|loop)',
    'outsourc(e|ed|ing)',
    '(total cost of )?ownership',
    'paradigms?( shift)?',
    'partner(ships?)?',
    'patents?',
    'people.focus(ed|sed)',
    'performance indicators',
    'personaliz(e|ed|ation)',
    'perspective',
    'phases?',
    'phased approach',
    'pipeline',
    'pioneers',
    'pivot',
    'planning horizon',
    'platforms?',
    'plethora',
    'plug.?in',
    'potentials?',
    'powerful',
    'prioriti(s|z)ed?',
    'proactive',
    'problem space',
    'processes',
    'profit(ability)?',
    'promotion',
    'promotional collateral',
    'prominent',
    'proprietary',
    'proof.of.concept',
    'purpose.built',
    'push the envelope',
    'push.back',
    'production.ready',
    'productivity',
    'pushing on open doors',
    'quick wins?',
    'rais(e|ing) the bar',
    'ramp.up',
    'ravishing',
    '(reaping )(tangible )rewards',
    'relationship management',
    'responsive',
    'engage(ments?)?',
    'reach out',
    'reactivation',
    'real.time',
    'real.world',
    'reconfigure',
    'redefin(e|ed|ing)',
    'red flags?',
    'reengineering',
    'reimagin(e|ed|ing)',
    'reinvent(ing)? the(.square)? wheel',
    'reinvigorate',
    'relevance',
    'repurpose',
    'resilien(ce|cy|t)',
    'resource allocation',
    'restructuring',
    'retention',
    'return on investment',
    'results',
    'reus(e|ability)',
    'revenue',
    'reverse.engineer',
    'revisit',
    'revolution',
    'rich',
    'road ?map',
    'robust',
    'rock.?star',
    'roi',
    'run the numbers',
    '(s|p)aas',
    'sacrific(e|es|ing)',
    'scal(e|es|ing|ability)',
    'high availability',
    'scenarios?',
    'scope',
    'scrum( master)?',
    'seamless',
    'secret sauce',
    'search engine optimization',
    'segments?',
    'self-managed team',
    'seo',
    '(serial )?entrepreneurs?',
    'serverless',
    'service mesh',
    'shareholder value',
    'significant(ly)?',
    'single-source responsibility',
    'skill ?sets?',
    'smart(er)?',
    'smoke (&|and) mirrors',
    'social(.media|.gaming|.networks?)',
    'solidality',
    'solutions?',
    'sophisticated',
    'soup to nuts',
    'sow',
    'spatial.computing',
    'stakeholders?',
    'start.up?',
    'statement of work',
    'state.of.the.art',
    'step.changes?',
    'sticky-?ness',
    'strateg(y|ic|ize|ise)',
    'streamlin(ed|e|ing)',
    'story points?',
    'success(ful)?',
    'super(critical|star|nova)',
    'sustainab(le|ility)',
    'synerg(y|ies|ized|i)',
    'systems?',
    'tailwinds?',
    'talented',
    'take offline',
    'talking points',
    'target (audience|group)',
    'targeted',
    'tasked',
    'tco',
    'team.building',
    'team.player',
    'teamwork',
    'technolog(y|ies)',
    'that being said',
    'thought.leader',
    'throughput',
    'time.to.awesome',
    'time.to.market',
    'timelines?',
    'top.down',
    'top.of.the.game',
    'total quality',
    'touch.base',
    'touchpoints?',
    'traction',
    'transform(ing|ative|ation(al))',
    'trends?',
    'true',
    'truths?',
    'turnkey',
    'ultimate',
    'up.to.speed',
    'up-?sell',
    'upside',
    'user.friendly',
    'user funnels?',
    'user.experience',
    'utili(s|z)(e|ation)',
    'uncover',
    'unicorn',
    'unique approach',
    'unlimited.holidays',
    'values?',
    'valueable',
    'value.add(ed)?',
    'venture',
    'venturing',
    'vertical market',
    'viral',
    'virtual(ization|isation)?',
    'visibility',
    'visio(n|nary)',
    'walk the talk',
    'wearable',
    'web.enabled',
    'win-win',
    'wisdom of crowds',
    'with due respect',
    'with ease',
    'wizards?',
    'workflows?',
    'workloads?',
    'workplaceless',
    'workspace',
    'world.?class',
    'world a better place',
    'wow.factor',
    'you\'ve never seen (a|an) \\w+',
    'zeitgeist',
    'zenith'
];
<|endoftext|>