local deep query selector copy

SQUASHED: AUTO-COMMIT-src-client-reactive-new-rewriting-implementation.md,fixed-unstable-import-for-lively-smaug,Merge-branch-gh-pages-of-https-github.com-LivelyKernel-lively4-core-into-gh-pages,

Author: onsetsu

src/client/lively.js

@@ -1473,7 +1473,7 @@ export default class Lively {
       var pattern = patternOrPosition;
     }
 
-    if (!url || !url.match(/^[a-z]+:\/\//)) url = lively4url;
+    if (!url || !url.match(/^[a-z]+:/)) url = lively4url;
     var livelyContainer;
     var containerPromise;
     let existingFound = false;

src/client/reactive/new-rewriting-implementation.md

@@ -56,6 +56,12 @@ function foo() {
 
 thus, while analysing an expression, dependencies are still gathered, but outside the analysis, we only need to check one global boolean (which requires not only less redundant computation but also is more JIT friendly because we do not have centralized functions that are hard to optimize).
 
+### advantages
+
+- low impact on standard js expectations
+  - no 'cannot read [prop] of obj' anymore
+  - low perf impact
+
 ### caveats
 
 1. arrow functionExpressions may need to be rewritten to have a block as body
@@ -82,8 +88,10 @@ idea: instead of a central data structutr, keep refereces to aexprs for locals i
 
 idea: local variables only need to be tracked, if
 - they leave their initial scope of declaration (= there is at least one read (#TODO: not sure if a read requires tracking) or write access to that variable in a different first-class functions' scope, i.e. it can be passed around)
+  - having `eval` in a subscope allows to read/write any local variable, thus, those also need to be rewritten
 - they are not constant (there is a write operations somewhere for them)
 
+
 # Benchmarks
 
 - need to compare performance to all other strategies

src/components/tools/lively-plugin-explorer-playground.workspace

@@ -4,7 +4,7 @@
     "/test.js",
     "/karma.conf.js"
   ],
-  "plugin": "src/client/reactive/babel-plugin-active-expression-rewriting/index.js",
+  "plugin": "src/client/reactive/babel-plugin-polymorphic-identifiers/babel-plugin-polymorphic-identifiers.js",
   "options": {
     "autoUpdateAST": true,
     "autoUpdateTransformation": true,
@@ -15,11 +15,10 @@
   },
   "pluginSelection": [
     {
-      "url": "src/client/reactive/babel-plugin-active-expression-rewriting/index.js"
+      "url": "src/client/reactive/babel-plugin-polymorphic-identifiers/babel-plugin-polymorphic-identifiers.js"
     }
   ],
   "openPlugins": [
-    "src/client/reactive/babel-plugin-active-expression-rewriting/index.js",
-    "demos/tom/playground.js"
+    "src/client/reactive/babel-plugin-polymorphic-identifiers/babel-plugin-polymorphic-identifiers.js"
   ]
 }

src/components/tools/lively-smaug.js

@@ -1,7 +1,7 @@
 "enable aexpr";
 
 import Morph from 'src/components/widgets/lively-morph.js';
-import { querySelectorAllDeep } from 'https://raw.githubusercontent.com/Georgegriff/query-selector-shadow-dom/master/src/querySelectorDeep.js';
+import { querySelectorAllDeep } from 'src/external/querySelectorDeep/querySelectorDeep.js';
 import d3 from "src/external/d3.v5.js";
 import {copyTextToClipboard} from 'utils';
 

src/components/widgets/lively-code-tip.js

@@ -30,7 +30,7 @@ export default class CodeTip extends Morph {
       "Make your code simpler to understand with the extract method feature 'Alt+M'.",
       "You can find many useful shortcuts under 'Right-click' --> 'Documentation'.",
       "'that' can be used to reference the last component you used the 'halo-menu' (Alt+Click) on.",
-      "'Ctrl+Shift+F' opens the global text search (which is case sensitive!).",
+      "'Ctrl+Shift+F' opens the global text search (which allows for regular expressions and is case sensitive!).",
       "This could be your tip! Add new tips in lively-code-tip.js",
       "Use 'Alt+P' to switch between markdown code and its visualization in the codemirror.",
       "When editing a js file, press 'F7' to open the associated HTML file (if it exists) and vice versa.",

src/external/querySelectorDeep/normalize.js

@@ -0,0 +1,166 @@
+/* istanbul ignore file */
+
+
+// normalize-selector-rev-02.js
+/*
+  author: kyle simpson (@getify)
+  original source: https://gist.github.com/getify/9679380
+
+  modified for tests by david kaye (@dfkaye)
+  21 march 2014
+
+  rev-02 incorporate kyle's changes 3/2/42014
+*/
+
+export function normalizeSelector(sel) {
+  // save unmatched text, if any
+  function saveUnmatched() {
+    if (unmatched) {
+      // whitespace needed after combinator?
+      if (tokens.length > 0 && /^[~+>]$/.test(tokens[tokens.length - 1])) {
+        tokens.push(" ");
+      }
+
+      // save unmatched text
+      tokens.push(unmatched);
+    }
+  }
+
+  var tokens = [],
+    match,
+    unmatched,
+    regex,
+    state = [0],
+    next_match_idx = 0,
+    prev_match_idx,
+    not_escaped_pattern = /(?:[^\\]|(?:^|[^\\])(?:\\\\)+)$/,
+    whitespace_pattern = /^\s+$/,
+    state_patterns = [
+      /\s+|\/\*|["'>~+[(]/g, // general
+      /\s+|\/\*|["'[\]()]/g, // [..] set
+      /\s+|\/\*|["'[\]()]/g, // (..) set
+      null, // string literal (placeholder)
+      /\*\//g, // comment
+    ];
+  sel = sel.trim();
+
+  // eslint-disable-next-line no-constant-condition
+  while (true) {
+    unmatched = "";
+
+    regex = state_patterns[state[state.length - 1]];
+
+    regex.lastIndex = next_match_idx;
+    match = regex.exec(sel);
+
+    // matched text to process?
+    if (match) {
+      prev_match_idx = next_match_idx;
+      next_match_idx = regex.lastIndex;
+
+      // collect the previous string chunk not matched before this token
+      if (prev_match_idx < next_match_idx - match[0].length) {
+        unmatched = sel.substring(
+          prev_match_idx,
+          next_match_idx - match[0].length
+        );
+      }
+
+      // general, [ ] pair, ( ) pair?
+      if (state[state.length - 1] < 3) {
+        saveUnmatched();
+
+        // starting a [ ] pair?
+        if (match[0] === "[") {
+          state.push(1);
+        }
+        // starting a ( ) pair?
+        else if (match[0] === "(") {
+          state.push(2);
+        }
+        // starting a string literal?
+        else if (/^["']$/.test(match[0])) {
+          state.push(3);
+          state_patterns[3] = new RegExp(match[0], "g");
+        }
+        // starting a comment?
+        else if (match[0] === "/*") {
+          state.push(4);
+        }
+        // ending a [ ] or ( ) pair?
+        else if (/^[\])]$/.test(match[0]) && state.length > 0) {
+          state.pop();
+        }
+        // handling whitespace or a combinator?
+        else if (/^(?:\s+|[~+>])$/.test(match[0])) {
+          // need to insert whitespace before?
+          if (
+            tokens.length > 0 &&
+            !whitespace_pattern.test(tokens[tokens.length - 1]) &&
+            state[state.length - 1] === 0
+          ) {
+            // add normalized whitespace
+            tokens.push(" ");
+          }
+
+          // case-insensitive attribute selector CSS L4
+          if (
+            state[state.length - 1] === 1 &&
+            tokens.length === 5 &&
+            tokens[2].charAt(tokens[2].length - 1) === "="
+          ) {
+            tokens[4] = " " + tokens[4];
+          }
+
+          // whitespace token we can skip?
+          if (whitespace_pattern.test(match[0])) {
+            continue;
+          }
+        }
+
+        // save matched text
+        tokens.push(match[0]);
+      }
+      // otherwise, string literal or comment
+      else {
+        // save unmatched text
+        tokens[tokens.length - 1] += unmatched;
+
+        // unescaped terminator to string literal or comment?
+        if (not_escaped_pattern.test(tokens[tokens.length - 1])) {
+          // comment terminator?
+          if (state[state.length - 1] === 4) {
+            // ok to drop comment?
+            if (
+              tokens.length < 2 ||
+              whitespace_pattern.test(tokens[tokens.length - 2])
+            ) {
+              tokens.pop();
+            }
+            // otherwise, turn comment into whitespace
+            else {
+              tokens[tokens.length - 1] = " ";
+            }
+
+            // handled already
+            match[0] = "";
+          }
+
+          state.pop();
+        }
+
+        // append matched text to existing token
+        tokens[tokens.length - 1] += match[0];
+      }
+    }
+    // otherwise, end of processing (no more matches)
+    else {
+      unmatched = sel.substr(next_match_idx);
+      saveUnmatched();
+
+      break;
+    }
+  }
+
+  return tokens.join("").trim();
+}