diff --git a/bower.json b/bower.json
index ae2bcf5033..ea5e637ce2 100644
--- a/bower.json
+++ b/bower.json
@@ -26,7 +26,8 @@
   "devDependencies": {
     "web-component-tester": "^6.0.0",
     "test-fixture": "PolymerElements/test-fixture#3.0.0-rc.1",
-    "iron-component-page": "PolymerElements/iron-component-page#^3.0.1"
+    "iron-component-page": "PolymerElements/iron-component-page#^3.0.1",
+    "perf-tester": "polymerlabs/perf-tester"
   },
   "private": true,
   "resolutions": {
diff --git a/externs/closure-types.js b/externs/closure-types.js
index e97a702165..8e7f3dd19a 100644
--- a/externs/closure-types.js
+++ b/externs/closure-types.js
@@ -1379,6 +1379,17 @@ Polymer_ArraySelectorMixin.prototype.select = function(item){};
 Polymer_ArraySelectorMixin.prototype.selectIndex = function(idx){};
 /**
 * @interface
+* @extends {Polymer_PropertyEffects}
+*/
+function Polymer_StrictBindingParser(){}
+/**
+* @param {string} text Text to parse from attribute or textContent
+* @param {Object} templateInfo Current template metadata
+* @return {Array.<!BindingPart>}
+*/
+Polymer_StrictBindingParser._parseBindings = function(text, templateInfo){};
+/**
+* @interface
 * @extends {Polymer_ElementMixin}
 */
 function Polymer_DisableUpgradeMixin(){}
diff --git a/lib/mixins/property-effects.html b/lib/mixins/property-effects.html
index 0feb7c9e41..d5c60613e2 100644
--- a/lib/mixins/property-effects.html
+++ b/lib/mixins/property-effects.html
@@ -2629,6 +2629,17 @@
        * - Inline computed method (supports negation):
        *   `[[compute(a, 'literal', b)]]`, `[[!compute(a, 'literal', b)]]`
        *
+       * The default implementation uses a regular expression for best
+       * performance. However, the regular expression uses a white-list of
+       * allowed characters in a data-binding, which causes problems for
+       * data-bindings that do use characters not in this white-list.
+       *
+       * Instead of updating the white-list with all allowed characters,
+       * there is a StrictBindingParser (see lib/mixins/strict-binding-parser)
+       * that uses a state machine instead. This state machine is able to handle
+       * all characters. However, it is slightly less performant, therefore we
+       * extracted it into a separate optional mixin.
+       *
        * @param {string} text Text to parse from attribute or textContent
        * @param {Object} templateInfo Current template metadata
        * @return {Array<!BindingPart>} Array of binding part metadata
diff --git a/lib/mixins/strict-binding-parser.html b/lib/mixins/strict-binding-parser.html
new file mode 100644
index 0000000000..03a3b3d278
--- /dev/null
+++ b/lib/mixins/strict-binding-parser.html
@@ -0,0 +1,419 @@
+<!--
+@license
+Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+Code distributed by Google as part of the polymer project is also
+subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+-->
+<link rel="import" href="../utils/boot.html">
+<link rel="import" href="../utils/path.html">
+<link rel="import" href="../utils/mixin.html">
+<link rel="import" href="../mixins/property-effects.html">
+
+<script>
+(function() {
+  'use strict';
+
+  /**
+   * The open and corresponding closing brackets for surrounding bindings.
+   * @enum {string}
+   */
+  const BINDINGS = {
+    '{': '}',
+    '[': ']'
+  };
+
+  /**
+   * All states that the parser can be in. The states represent the state-machine as a whole.
+   * @enum {number}
+   */
+  const STATE = {
+    INITIAL: 1,
+    FIRSTOPENINGBINDING: 2,
+    FIRSTCHARACTERBINDING: 3,
+    BINDING: 4,
+    FIRSTCOLON: 5,
+    COLONNOTIFYEVENT: 6,
+    COLONNOTIFYEVENTFIRSTCLOSINGBINDING: 7,
+    FIRSTCLOSINGBINDING: 8,
+    STRING: 9,
+    METHOD: 10,
+    STRINGARG: 11,
+    NUMBERARG: 12,
+    VARIABLEARG: 13,
+    METHODCLOSED: 14,
+    METHODCLOSEDBINDING: 15
+  };
+
+  function pushLiteral(text, i, parts, startChar) {
+    const literal = text.substring(startChar || 0, i);
+    if (literal) {
+      parts.push({
+        literal
+      });
+    }
+  }
+
+  function storeMethod(bindingData, templateInfo) {
+    const methodName = bindingData.signature.methodName;
+    const dynamicFns = templateInfo.dynamicFns;
+    if (dynamicFns && dynamicFns[methodName] || bindingData.signature.static) {
+      bindingData.dependencies.push(methodName);
+      bindingData.signature.dynamicFn = true;
+    }
+  }
+
+  function storeVariableBinding(parts, bindingData, prop, i) {
+    bindingData.source = prop;
+    bindingData.dependencies.push(prop);
+    bindingData.startChar = i + 1;
+    parts.push(bindingData);
+  }
+
+  function storeMethodVariable(bindingData, text, i) {
+    const name = text.substring(bindingData.startChar, i).trim();
+    if (name) {
+      if (name === 'true' || name === 'false') {
+        bindingData.signature.args.push({
+          name,
+          value: name == 'true',
+          literal: true
+        });
+      } else {
+        const arg = {
+          name
+        };
+        arg.structured = Polymer.Path.isPath(name);
+        if (arg.structured) {
+          arg.wildcard = (name.slice(-2) == '.*');
+          if (arg.wildcard) {
+            arg.name = name.slice(0, -2);
+          }
+        }
+        bindingData.signature.args.push(arg);
+        bindingData.dependencies.push(name);
+        bindingData.signature.static = false;
+      }
+    }
+  }
+
+  function storeMethodNumber(bindingData, text, i) {
+    const value = text.substring(bindingData.startChar, i).trim();
+    bindingData.signature.args.push({
+      name: value,
+      value: Number(value),
+      literal: true
+    });
+  }
+
+  /**
+   * Mixin that parses binding expressions and generates corresponding metadata.
+   * The implementation is different than in `property-effects`, as it uses a
+   * state machine instead of a regex. As such, this implementation is able to
+   * handle more cases, with the potential performance hit.
+   *
+   * @mixinFunction
+   * @appliesMixin Polymer.PropertyEffects
+   * @polymer
+   * @memberof Polymer
+   * @summary Mixin that parses binding expressions and generates corresponding metadata.
+   */
+  const StrictBindingParser = Polymer.dedupingMixin((base) => {
+
+    /**
+     * @constructor
+     * @extends {base}
+     * @implements {Polymer_PropertyEffects}
+     */
+    const elementBase = Polymer.PropertyEffects(base);
+
+    /**
+     * @polymer
+     * @mixinClass
+     * @implements {Polymer_PropertyEffects}
+     */
+    return class extends elementBase {
+
+      /**
+       * Called to parse text in a template (either attribute values or
+       * textContent) into binding metadata.
+       *
+       * Any overrides of this method should return an array of binding part
+       * metadata  representing one or more bindings found in the provided text
+       * and any "literal" text in between.  Any non-literal parts will be passed
+       * to `_evaluateBinding` when any dependencies change.  The only required
+       * fields of each "part" in the returned array are as follows:
+       *
+       * - `dependencies` - Array containing trigger metadata for each property
+       *   that should trigger the binding to update
+       * - `literal` - String containing text if the part represents a literal;
+       *   in this case no `dependencies` are needed
+       *
+       * Additional metadata for use by `_evaluateBinding` may be provided in
+       * each part object as needed.
+       *
+       * The default implementation handles the following types of bindings
+       * (one or more may be intermixed with literal strings):
+       * - Property binding: `[[prop]]`
+       * - Path binding: `[[object.prop]]`
+       * - Negated property or path bindings: `[[!prop]]` or `[[!object.prop]]`
+       * - Two-way property or path bindings (supports negation):
+       *   `{{prop}}`, `{{object.prop}}`, `{{!prop}}` or `{{!object.prop}}`
+       * - Inline computed method (supports negation):
+       *   `[[compute(a, 'literal', b)]]`, `[[!compute(a, 'literal', b)]]`
+       *
+       * @param {string} text Text to parse from attribute or textContent
+       * @param {Object} templateInfo Current template metadata
+       * @return {Array<!BindingPart>} Array of binding part metadata
+       * @protected
+       */
+      static _parseBindings(text, templateInfo) {
+        const parts = [];
+        let bindingData = {};
+        let escaped = false;
+        /** @type {string} */
+        let quote;
+        /** @type {number} */
+        let state = STATE.INITIAL;
+        let i,l;
+
+        for (i=0,l=text.length; i<l; i++) {
+          const char = text.charAt(i);
+          switch (state) {
+            case STATE.INITIAL: {
+              if ((char === '{' || char === '[')) {
+                bindingData = {
+                  mode: char,
+                  dependencies: [],
+                  startChar: bindingData.startChar
+                };
+                state = STATE.FIRSTOPENINGBINDING;
+              }
+              break;
+            }
+            case STATE.FIRSTOPENINGBINDING: {
+              if (char === bindingData.mode) {
+                pushLiteral(text, i - 1, parts, bindingData.startChar);
+                bindingData.startChar = i + 1;
+                state = STATE.FIRSTCHARACTERBINDING;
+              } else {
+                bindingData = {};
+                state = STATE.INITIAL;
+              }
+              break;
+            }
+            case STATE.FIRSTCHARACTERBINDING: {
+              if (char !== ' ' && char !== '\t' && char !== '\n') {
+                if (char === '!') {
+                  bindingData.negate = true;
+                  bindingData.startChar = i + 1;
+                }
+                state = STATE.BINDING;
+              }
+              break;
+            }
+            case STATE.BINDING: {
+              switch (char) {
+                case BINDINGS[bindingData.mode]: {
+                  state = STATE.FIRSTCLOSINGBINDING;
+                  break;
+                }
+                case '\'':
+                case '"': {
+                  quote = char;
+                  state = STATE.STRING;
+                  break;
+                }
+                case '(': {
+                  bindingData.signature = {
+                    methodName: text.substring(bindingData.startChar, i).trim(),
+                    args: [],
+                    static: true
+                  };
+                  bindingData.startChar = i + 1;
+                  state = STATE.METHOD;
+                  break;
+                }
+                case ':': {
+                  state = STATE.FIRSTCOLON;
+                }
+              }
+              break;
+            }
+            case STATE.FIRSTCOLON: {
+              if (char === ':') {
+                bindingData.customEvent = true;
+                bindingData.startCharAfterColon = i + 1;
+                state = STATE.COLONNOTIFYEVENT;
+              } else {
+                state = STATE.BINDING;
+              }
+              break;
+            }
+            case STATE.COLONNOTIFYEVENT: {
+              if (char === BINDINGS[bindingData.mode]) {
+                state = STATE.COLONNOTIFYEVENTFIRSTCLOSINGBINDING;
+              }
+              break;
+            }
+            case STATE.COLONNOTIFYEVENTFIRSTCLOSINGBINDING: {
+              if (char === BINDINGS[bindingData.mode]) {
+                bindingData.event = text.substring(bindingData.startCharAfterColon, i - 1).trim();
+                const prop = text.substring(bindingData.startChar, bindingData.startCharAfterColon - 2).trim();
+                storeVariableBinding(parts, bindingData, prop, i);
+                state = STATE.INITIAL;
+              } else {
+                state = STATE.BINDING;
+              }
+              break;
+            }
+            case STATE.FIRSTCLOSINGBINDING: {
+              if (char === BINDINGS[bindingData.mode]) {
+                const prop = text.substring(bindingData.startChar, i - 1).trim();
+                storeVariableBinding(parts, bindingData, prop, i);
+                state = STATE.INITIAL;
+              } else {
+                state = STATE.BINDING;
+              }
+              break;
+            }
+            case STATE.STRING: {
+              if (char === '\\') {
+                escaped = true;
+              } else if (char === quote && !escaped) {
+                state = STATE.BINDING;
+              } else {
+                escaped = false;
+              }
+              break;
+            }
+            case STATE.METHOD: {
+              switch (char) {
+                case ')': {
+                  storeMethodVariable(bindingData, text, i);
+                  storeMethod(bindingData, templateInfo);
+                  bindingData.startChar = i + 1;
+                  state = STATE.METHODCLOSED;
+                  break;
+                }
+                case ',': {
+                  storeMethodVariable(bindingData, text, i);
+                  bindingData.startChar = i + 1;
+                  break;
+                }
+                case '\'':
+                case '"': {
+                  quote = char;
+                  state = STATE.STRINGARG;
+                  break;
+                }
+                default: {
+                  if (char >= '0' && char <= '9' || char === '-') {
+                    state = STATE.NUMBERARG;
+                  } else if (char != ' ' && char != '\n') {
+                    state = STATE.VARIABLEARG;
+                  }
+                }
+              }
+              break;
+            }
+            case STATE.STRINGARG: {
+              if (char === '\\') {
+                escaped = true;
+              } else if (char === quote && !escaped) {
+                const value = text.substring(bindingData.startChar, i)
+                    .replace(/^\s+/, '')
+                    .substring(1)
+                    // replace comma entity with comma
+                    .replace(/&comma;/g, ',')
+                    // repair extra escape sequences; note only commas strictly need
+                    // escaping, but we allow any other char to be escaped since its
+                    // likely users will do this
+                    .replace(/\\(.)/g, '\$1');
+                bindingData.signature.args.push({
+                  value,
+                  name: value,
+                  literal: true
+                });
+                bindingData.startChar = i + 1;
+                state = STATE.METHOD;
+              } else {
+                escaped = false;
+              }
+              break;
+            }
+            case STATE.NUMBERARG: {
+              switch (char) {
+                case ',': {
+                  storeMethodNumber(bindingData, text, i);
+                  bindingData.startChar = i + 1;
+                  state = STATE.METHOD;
+                  break;
+                }
+                case ')': {
+                  storeMethodNumber(bindingData, text, i);
+                  storeMethod(bindingData, templateInfo);
+                  state = STATE.METHODCLOSED;
+                  break;
+                }
+                default: {
+                  if (char < '0' || char > '9') {
+                    state = STATE.VARIABLEARG;
+                  }
+                }
+              }
+              break;
+            }
+            case STATE.VARIABLEARG: {
+              switch (char) {
+                case ',': {
+                  storeMethodVariable(bindingData, text, i);
+                  bindingData.startChar = i + 1;
+                  state = STATE.METHOD;
+                  break;
+                }
+                case ')': {
+                  storeMethodVariable(bindingData, text, i);
+                  storeMethod(bindingData, templateInfo);
+                  state = STATE.METHODCLOSED;
+                  break;
+                }
+              }
+              break;
+            }
+            case STATE.METHODCLOSED: {
+              if (char === BINDINGS[bindingData.mode]) {
+                state = STATE.METHODCLOSEDBINDING;
+              } else if (char !== ' ' && char !== '\t' && char !== '\n') {
+                console.warn(`Expected two closing "${BINDINGS[bindingData.mode]}" for binding "${text}"`);
+              }
+              break;
+            }
+            case STATE.METHODCLOSEDBINDING: {
+              if (char === BINDINGS[bindingData.mode]) {
+                bindingData.startChar = i + 1;
+                parts.push(bindingData);
+                state = STATE.INITIAL;
+              } else if (char !== ' ' && char !== '\t' && char !== '\n') {
+                console.warn(`Expected one closing "${BINDINGS[bindingData.mode]}" for binding "${text}"`);
+              }
+              break;
+            }
+          }
+        }
+
+        if (parts.length) {
+          pushLiteral(text, i, parts, parts[parts.length - 1].startChar);
+          return parts;
+        }
+
+        return null;
+      }
+    };
+  });
+
+  Polymer.StrictBindingParser = StrictBindingParser;
+})();
+</script>
diff --git a/test/perf/binding-expressions.html b/test/perf/binding-expressions.html
new file mode 100644
index 0000000000..177a41f249
--- /dev/null
+++ b/test/perf/binding-expressions.html
@@ -0,0 +1,78 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, minimum-scale=1.0, initial-scale=1, user-scalable=yes">
+  <script src="../../bower_components/perf-tester/perf.js"></script>
+  <script src="../../bower_components/webcomponentsjs/webcomponents-lite.js"></script>
+  <link rel="import" href="../../polymer.html">
+  <link rel="import" href="../../lib/mixins/strict-binding-parser.html">
+</head>
+
+<body>
+
+<!--   <template>
+    {{compute(alaksjflkasjflkasjflkasjlfkajslkfjaslkfjaaaaaaaaaaaaaaaaaaaaaaaa)]}
+  </template>
+ -->    <!-- {{compute(tricky, 'literal\,\'zot\'', this.has.long.log.lo)]} -->
+
+  <template>
+    <span>{{foo}}</span> <span>{{foo.bar}}</span> <span>{{foo.bar.zot}}</span>
+    Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod
+    tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam,
+    quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo
+    consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse
+    cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non
+    proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
+    <span>{{compute(tricky, 'literal\,\'zot\'')}}</span>
+    Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod
+    tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam,
+    quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo
+    consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse
+    cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non
+    proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
+    <span>{{compute(tricky, 'literal\,\'zot\'', this.has.a.bogus.ending.bracket)]}</span>
+    Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod
+    tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam,
+    quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo
+    consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse
+    cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non
+    proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
+    <div class$="{{compute(a, b, c,d,e,f,g,h,i)}}">
+      Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod
+      tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam,
+      quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo
+      consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse
+      cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non
+      proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
+      <span>{{bindings.and.stuff}}</span>
+      <div id="zot"><span>[[computeFn(a, 'b', c, "d", 999)]]</span> literal <span>{{a.b}}</span> literally</div>
+      <div id="zot"><span>[[computeFn(a, 'b', c, "d", 999)]]</span> literal <span>{{a.b}}</span> literally</div>
+      <div id="zot"><span>[[computeFn(a, 'b', c, "d", 999)]]</span> literal <span>{{a.b}}</span> literally</div>
+      <div id="zot"><span>[[computeFn(a, 'b', c, "d", 999)]]</span> literal <span>{{a.b}}</span> literally</div>
+      <div id="zot"><span>[[computeFn(a, 'b', c, "d", 999)]]</span> literal <span>{{a.b}}</span> literally</div>
+      <div id="zot"><span>[[computeFn(a, 'b', c, "d", 999)]]</span> literal <span>{{a.b}}</span> literally</div>
+      <div id="zot"><span>[[computeFn(a, 'b', c, "d", 999)]]</span> literal <span>{{a.b}}</span> literally</div>
+    </div>
+  </template>
+
+  <script>
+  var COUNT = 1000;
+  var templates = [];
+  var template = document.querySelector('template');
+  for (var i=0; i<COUNT; i++) {
+    templates[i] = template.cloneNode(true);
+  }
+  console.perf();
+  for (var i=0; i<COUNT; i++) {
+    const klass = class Foo extends Polymer.StrictBindingParser(Polymer.Element) {
+      static get _template() { return templates[i]; }
+    };
+    customElements.define('foo-' + i, klass);
+    new klass();
+  }
+  console.perfEnd();
+  </script>
+
+</body>
+</html>
diff --git a/test/perf/perf-tests.html b/test/perf/perf-tests.html
new file mode 100644
index 0000000000..f8da4dbe1a
--- /dev/null
+++ b/test/perf/perf-tests.html
@@ -0,0 +1,27 @@
+<!doctype html>
+<html lang="en">
+<head>
+
+  <meta charset="utf-8">
+  <script src="../../bower_components/webcomponentsjs/webcomponents-lite.js"></script>
+  <script src="../../bower_components/perf-tester/perf-tester.js"></script>
+  <link rel="import" href="../../polymer.html">
+  <style>
+    summary {
+      font-family: sans-serif;
+      font-size: 1.5em;
+    }
+  </style>
+
+</head>
+<body>
+  <summary>Perf is go.</summary>
+  <perf-tester runs="25"></perf-tester>
+
+  <script>
+    document.querySelector('perf-tester').tests = [
+      'binding-expressions.html'
+    ];
+  </script>
+
+</body>
\ No newline at end of file
diff --git a/test/unit/property-effects-elements.html b/test/unit/property-effects-elements.html
index ecfca10c0c..f9144d74f1 100644
--- a/test/unit/property-effects-elements.html
+++ b/test/unit/property-effects-elements.html
@@ -8,6 +8,7 @@
 subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
 -->
 <link rel="import" href="../../polymer.html">
+<link rel="import" href="../../lib/mixins/strict-binding-parser.html">
 
 <dom-module id="x-basic">
   <template>
@@ -47,6 +48,7 @@
       compoundAttr2$="literal1 {{cpnd1}} literal2 {{cpnd2}}{{cpnd3.prop}} literal3 {{computeCompound(cpnd4, cpnd5, 'literalComputed')}} literal4"
       compoundAttr3$="[yes/no]: {{cpnd1}}, {{computeCompound('world', 'username ', 'Hello {0} ')}}"
       computed-from-behavior="{{computeFromBehavior(value)}}"
+      computed-dynamic-fn="{{dynamicFn('hello', 'username')}}"
       >
       Test
       <!-- Malformed bindings to be ignored -->
@@ -83,6 +85,11 @@
           content: '[[binding]]'
         }
       </style>
+      <span id="boundWithSlash">[[objectWithSlash.binding/with/slash]]</span>
+      <span id="jsonContent">[["Jan", 31],["Feb", 28],["Mar", 31]]</span>
+      <span id="nonEnglishUnicode">{{objectWithNonEnglishUnicode.商品名}}</span>
+      <span id="booleanTrue">foo(field, true): {{computeWithBoolean(otherValue, true)}}</span>
+      <span id="booleanFalse">foo(field, false): {{computeWithBoolean(otherValue, false)}}</span>
   </template>
   <script>
     let ComputingBehavior = {
@@ -177,6 +184,9 @@
         },
         title: {
           observer: 'titleChanged'
+        },
+        dynamicFn: {
+          type: Function
         }
       },
       observers: [
@@ -198,6 +208,7 @@
           notifierWithoutComputingChanged: 0
         };
         this.titleChanged = sinon.spy();
+        this._dynamicFnCalled = false;
       },
       ready: function() {
         this.isReady = true;
@@ -317,11 +328,22 @@
       computeWildcard: function(a, bInfo) {
         return a + (bInfo && bInfo.base ? bInfo.base.value  : 0);
       },
+      computeWithBoolean: function(value, bool) {
+        return bool ? value : value * 2;
+      },
       fireCustomNotifyingEvent: function() {
         this.customNotifyingValue = 'changed!';
         this.dispatchEvent(new CustomEvent('custom-notifying-value-changed'),
           {value: this.customNotifyingValue});
+      },
+      dynamicFn: function() {}
+    });
+
+    HTMLImports.whenReady(() => {
+      class XBasicWithStrictBindingParser extends Polymer.StrictBindingParser(customElements.get('x-basic')) {
+        static get is() { return 'x-basic-strict-binding-parser'; }
       }
+      customElements.define(XBasicWithStrictBindingParser.is, XBasicWithStrictBindingParser);
     });
   </script>
 </dom-module>
diff --git a/test/unit/property-effects.html b/test/unit/property-effects.html
index efe4bf6b34..d4ed2e4442 100644
--- a/test/unit/property-effects.html
+++ b/test/unit/property-effects.html
@@ -409,6 +409,13 @@
     }
   });
 
+  test('only calls dynamic functions once', function() {
+    el.dynamicFn = function() {
+      assert.isFalse(this._dynamicFnCalled);
+      this._dynamicFnCalled = true;
+    };
+  });
+
   suite('observer inheritance', function() {
     setup(function() {
       el = document.createElement('sub-observer-element');
@@ -436,6 +443,48 @@
       assert.equal(el.$.svg.getAttribute('viewBox'), el.value);
     });
   });
+
+  suite('can work with strict binding parser', function() {
+    setup(function() {
+      document.body.removeChild(el);
+      el = document.createElement('x-basic-strict-binding-parser');
+      document.body.appendChild(el);
+    });
+
+    test('binding with slash', function() {
+      el.objectWithSlash = {
+        'binding/with/slash': 'yes'
+      };
+      assert.equal(el.$.boundWithSlash.textContent, 'yes');
+    });
+
+    test('json should not be a binding', function() {
+      assert.equal(el.$.jsonContent.textContent, '[["Jan", 31],["Feb", 28],["Mar", 31]]');
+    });
+
+    test('binding with non-English unicode', function() {
+      el.objectWithNonEnglishUnicode = {
+        商品名: 'yes'
+      };
+      assert.equal(el.$.nonEnglishUnicode.textContent, 'yes');
+    });
+
+    test('binding with booleans', function() {
+      el.otherValue = 10;
+      assert.equal(el.$.booleanTrue.textContent, 'foo(field, true): 10');
+      assert.equal(el.$.booleanFalse.textContent, 'foo(field, false): 20');
+    });
+
+    suite('equivalent behavior as regex', function() {
+      // Loop over the suite "single-element binding effects" (parent of the parent of this suite)
+      // And make sure that the tests there also pass on the binding-parser
+      //
+      // t.title is the name of the test and t.fn contains the test body
+      this.parent.parent.tests.forEach(t => {
+        test(t.title, t.fn);
+      });
+    });
+  });
 });
 
 suite('computed bindings with dynamic functions', function() {
diff --git a/types/lib/mixins/property-effects.d.ts b/types/lib/mixins/property-effects.d.ts
index 572674abe3..52aec3a068 100644
--- a/types/lib/mixins/property-effects.d.ts
+++ b/types/lib/mixins/property-effects.d.ts
@@ -257,6 +257,17 @@ declare namespace Polymer {
      * - Inline computed method (supports negation):
      *   `[[compute(a, 'literal', b)]]`, `[[!compute(a, 'literal', b)]]`
      *
+     * The default implementation uses a regular expression for best
+     * performance. However, the regular expression uses a white-list of
+     * allowed characters in a data-binding, which causes problems for
+     * data-bindings that do use characters not in this white-list.
+     *
+     * Instead of updating the white-list with all allowed characters,
+     * there is a StrictBindingParser (see lib/mixins/strict-binding-parser)
+     * that uses a state machine instead. This state machine is able to handle
+     * all characters. However, it is slightly less performant, therefore we
+     * extracted it into a separate optional mixin.
+     *
      * @param text Text to parse from attribute or textContent
      * @param templateInfo Current template metadata
      * @returns Array of binding part metadata
diff --git a/types/lib/mixins/strict-binding-parser.d.ts b/types/lib/mixins/strict-binding-parser.d.ts
new file mode 100644
index 0000000000..b4d9406b95
--- /dev/null
+++ b/types/lib/mixins/strict-binding-parser.d.ts
@@ -0,0 +1,67 @@
+/**
+ * DO NOT EDIT
+ *
+ * This file was automatically generated by
+ *   https://github.com/Polymer/gen-typescript-declarations
+ *
+ * To modify these typings, edit the source file(s):
+ *   lib/mixins/strict-binding-parser.html
+ */
+
+/// <reference path="../utils/boot.d.ts" />
+/// <reference path="../utils/path.d.ts" />
+/// <reference path="../utils/mixin.d.ts" />
+/// <reference path="property-effects.d.ts" />
+
+declare namespace Polymer {
+
+
+  /**
+   * Mixin that parses binding expressions and generates corresponding metadata.
+   * The implementation is different than in `property-effects`, as it uses a
+   * state machine instead of a regex. As such, this implementation is able to
+   * handle more cases, with the potential performance hit.
+   */
+  function StrictBindingParser<T extends new (...args: any[]) => {}>(base: T): T & StrictBindingParserConstructor & Polymer.PropertyEffectsConstructor & Polymer.TemplateStampConstructor & Polymer.PropertyAccessorsConstructor & Polymer.PropertiesChangedConstructor;
+
+  interface StrictBindingParserConstructor {
+    new(...args: any[]): StrictBindingParser;
+
+    /**
+     * Called to parse text in a template (either attribute values or
+     * textContent) into binding metadata.
+     *
+     * Any overrides of this method should return an array of binding part
+     * metadata  representing one or more bindings found in the provided text
+     * and any "literal" text in between.  Any non-literal parts will be passed
+     * to `_evaluateBinding` when any dependencies change.  The only required
+     * fields of each "part" in the returned array are as follows:
+     *
+     * - `dependencies` - Array containing trigger metadata for each property
+     *   that should trigger the binding to update
+     * - `literal` - String containing text if the part represents a literal;
+     *   in this case no `dependencies` are needed
+     *
+     * Additional metadata for use by `_evaluateBinding` may be provided in
+     * each part object as needed.
+     *
+     * The default implementation handles the following types of bindings
+     * (one or more may be intermixed with literal strings):
+     * - Property binding: `[[prop]]`
+     * - Path binding: `[[object.prop]]`
+     * - Negated property or path bindings: `[[!prop]]` or `[[!object.prop]]`
+     * - Two-way property or path bindings (supports negation):
+     *   `{{prop}}`, `{{object.prop}}`, `{{!prop}}` or `{{!object.prop}}`
+     * - Inline computed method (supports negation):
+     *   `[[compute(a, 'literal', b)]]`, `[[!compute(a, 'literal', b)]]`
+     *
+     * @param text Text to parse from attribute or textContent
+     * @param templateInfo Current template metadata
+     * @returns Array of binding part metadata
+     */
+    _parseBindings(text: string, templateInfo: object|null): BindingPart[]|null;
+  }
+
+  interface StrictBindingParser {
+  }
+}