main:{

  header:{

    {'Tasker'}

    newCol:{'New Column'}

  }

  columns:{

    scroll:{

      NoteCols:{}

    }

  }

}

NoteCol:{

  title:{['editable', 'focus']

    close:{

      {'×'}

    }

  }

  newNote:{['editable', 'placeholder="New Note..."']}

  hr:{}

  noteContainer:{

    Notes:{}

  }

}

Note:{['focus']

  close:{

    {'×'}

  }

  checkbox:{}

  content:{['edtiable']}

}

console.log('no errors :D');

// Minimum length of Soundex keys.

var minLength = 4

// Soundex values belonging to characters.

// This map also includes vowels (with a value of 0) to easily distinguish

// between an unknown value or a vowel.

var map = {}

map.a = map.e = map.i = map.o = map.u = map.y = 0

map.b = map.f = map.p = map.v = 1

map.c = map.g = map.j = map.k = map.q = map.s = map.x = map.z = 2

map.d = map.t = 3

map.l = 4

map.m = map.n = 5

map.r = 6

/**

 * Get the soundex key from a given value.

 *

 * @param {string} value

 * @param {number} [maxLength=4]

 * @returns {string}

 */

function soundex(value, maxLength) {

  var lowercase = String(value).toLowerCase()

  /** @type {Array.<string|number>} */

  var results = []

  var index = -1

  /** @type {string} */

  var character

  /** @type {number} */

  var previous

  /** @type {number} */

  var phonetics

  while (++index < lowercase.length) {

    character = lowercase.charAt(index)

    phonetics = map[character]

    if (index === 0) {

      // Initial letter

      results.push(character.toUpperCase())

    } else if (phonetics && phonetics !== previous) {

      // Phonetics value

      results.push(phonetics)

    } else if (phonetics === 0) {

      // Vowel

      phonetics = null

    } else {

      // Unknown character (including H and W)

      phonetics = previous

    }

    previous = phonetics

  }

  return pad(results.join('')).slice(0, maxLength || minLength)

}

/**

 * Pad a given value with zero characters. The function only pads four characters.

 *

 * @param {string} value

 * @returns {string}

 */

function pad(value) {

  var length = minLength - value.length

  var index = -1

  while (++index < length) {

    value += '0'

  }

  return value

}

console.log(

  soundex('Joe'),

  soundex('Smith'),

  soundex('Ed'), 

  soundex('Vilowat')

)

// hack to shove some html on the page since snippet.zone

// quick editor does not yet support HTML :P

document.body.innerHTML += `

  <p>This is some text to search...</p>

  <p>Here are some random words "Robot, Cat, Swan, Shadow"...</p>

  <button>Say Hello Robot</button>

`;

///////////

// find elements with the word `search`

let els = document.evaluate(

  "//p[contains(., 'search')]",

  document,

  null,

  XPathResult.ANY_TYPE,

  null

);

let el;

while (el = els.iterateNext()) {

  console.log('match "search"', el);

}

els = document.evaluate(

  "//body/*[contains(., 'Robot')]",

  document,

  null,

  XPathResult.ANY_TYPE,

  null

);

while (el = els.iterateNext()) {

  console.log('match "Robot"', el);

}

class Person {

  constructor(name, email) {

    this.name = name;

  }

  toString() {

    return `name: ${this.name}`;

  }

}

class Teacher extends Person {

  constructor(name, subject) {

    super(name);

    this.subject = subject;

  }

  toString() {

    return super.toString() + ` subject: ${this.subject}`;

  }

}

const teacher = new Teacher('testname', 'testSubject');

console.log(teacher.toString());

const { assign } = Object

const { min, max, floor, round, abs } = Math

// `hslToRgb` and `rgbToHsl` functions from the amazing Raphael library

// by Dmitry Baranovskiy

// https://github.com/DmitryBaranovskiy/raphael/blob/master/raphael.js

export function hslToRgb({ h, s, l, a }) {

  let H = h

  let S = s

  let L = l

  s /= 100

  l /= 100

  let r, g, b, x, c

  h = (h % 360) / 60

  c = 2 * s * (l < .5 ? l : 1 - l)

  x = c * (1 - abs(h % 2 - 1))

  r = g = b = l - c / 2;

  h = floor(h)

  r += [c, x, 0, 0, x, c][h]

  g += [x, c, c, x, 0, 0][h]

  b += [0, 0, x, c, c, x][h]

  r *= 255; g *= 255; b *= 255

  r = round(r)

  g = round(g)

  b = round(b)

  return { r, g, b, h: H, s: S, l: L, a }

}

export function rgbToHsl({ r, g, b, a }) {

  let R = r

  let G = g

  let B = b

  r /= 255

  g /= 255

  b /= 255

  let h, s, l, w, m, c;

  w = max(r, g, b);

  m = min(r, g, b);

  c = w - m;

  h = (c == 0 ? null :

        w == r ? (g - b) / c :

        w == g ? (b - r) / c + 2 :

                 (r - g) / c + 4)

  h = ((h + 360) % 6) * 60 / 360;

  l = (w + m) / 2;

  s = (c == 0 ? 0 : l < .5 ?

    c / (2 * l) :

    c / (2 - 2 * l));

  h *= 360

  s *= 100

  l *= 100

  h = round(h)

  s = round(s)

  l = round(l);

  return { h, s, l, r: R, g: G, b: B, a }

}

const fromDec = dec => ({

  r: dec >> 16,

  g: dec >> 8 & 255,

  b: dec & 255

})

const fromHex = hex =>

  fromDec(Number('0x' + hex.slice(1)))

const components = def =>

  def.match(/[0-9\.]+/g).map(parseFloat)

const fromRgb = rgb => {

  const [r, g, b, a] = components(rgb)

  return { r, g, b, a: a ?? 1 }

}

const fromHsl = hsl => {

  const [h, s, l, a] = components(hsl)

  return { h, s, l, a: a ?? 1 }

}

const utils = {

  hex: (def, o) => assign(o, rgbToHsl(

    fromHex(def)), { a: o.a ?? 1 }

  ),

  rgb: (def, o) => assign(o, rgbToHsl(fromRgb(def))),

  hsl: (def, o) => assign(o, hslToRgb(fromHsl(def))),

  prop: (def, o) => {

    const name = Object.keys(def)[0]

    o[name] = def[name]

    if (name.match(/[rgb]/)) assign(o, rgbToHsl(o))

    if (name.match(/[hsl]/)) assign(o, hslToRgb(o))

    return o

  }

}

const types = { '#': 'hex', r: 'rgb', h: 'hsl', '[': 'prop' }

const type = str => types[str[0]]

const hx = c => {

  const chan = (+c).toString(16)

  if (chan.length === 0) return '00'

  if (chan.length === 1) return '0' + chan

  return chan

};

export function shade(def) {

  const o = {

    set(def) {

      const method = utils[type(String(def))]

      if (method != null) method(def, o)

    },

    hsl: _ => `hsla(${o.h}, ${o.s}%, ${o.l}%, ${o.a})`,

    rgb: _ => `rgba(${o.r}, ${o.g}, ${o.b}, ${o.a})`,

    hex: _ => `#${hx(o.r)}${hx(o.g)}${hx(o.b)}`

  }

  o.set(def)

  return o;

}