isomorfeus-preact 10.5.1 → 10.5.2

data/node_modules/stylis/src/Utility.js

@@ -0,0 +1,109 @@
+/**
+ * @param {number}
+ * @return {number}
+ */
+export var abs = Math.abs
+
+/**
+ * @param {number}
+ * @return {string}
+ */
+export var from = String.fromCharCode
+
+/**
+ * @param {string} value
+ * @param {number} length
+ * @return {number}
+ */
+export function hash (value, length) {
+	return (((((((length << 2) ^ charat(value, 0)) << 2) ^ charat(value, 1)) << 2) ^ charat(value, 2)) << 2) ^ charat(value, 3)
+}
+
+/**
+ * @param {string} value
+ * @return {string}
+ */
+export function trim (value) {
+	return value.trim()
+}
+
+/**
+ * @param {string} value
+ * @param {RegExp} pattern
+ * @return {string?}
+ */
+export function match (value, pattern) {
+	return (value = pattern.exec(value)) ? value[0] : value
+}
+
+/**
+ * @param {string} value
+ * @param {(string|RegExp)} pattern
+ * @param {string} replacement
+ * @return {string}
+ */
+export function replace (value, pattern, replacement) {
+	return value.replace(pattern, replacement)
+}
+
+/**
+ * @param {string} value
+ * @param {string} value
+ * @return {number}
+ */
+export function indexof (value, search) {
+	return value.indexOf(search)
+}
+
+/**
+ * @param {string} value
+ * @param {number} index
+ * @return {number}
+ */
+export function charat (value, index) {
+	return value.charCodeAt(index) | 0
+}
+
+/**
+ * @param {string} value
+ * @param {number} begin
+ * @param {number} end
+ * @return {string}
+ */
+export function substr (value, begin, end) {
+	return value.slice(begin, end)
+}
+
+/**
+ * @param {string} value
+ * @return {number}
+ */
+export function strlen (value) {
+	return value.length
+}
+
+/**
+ * @param {any[]} value
+ * @return {number}
+ */
+export function sizeof (value) {
+	return value.length
+}
+
+/**
+ * @param {any} value
+ * @param {any[]} array
+ * @return {any}
+ */
+export function append (value, array) {
+	return array.push(value), value
+}
+
+/**
+ * @param {string[]} array
+ * @param {function} callback
+ * @return {string}
+ */
+export function combine (array, callback) {
+	return array.map(callback).join('')
+}

data/node_modules/wouter-preact/cjs/index.js

@@ -0,0 +1,180 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var useLocation$1 = require('./use-location.js');
+var matcher = require('./matcher.js');
+var preact = require('preact');
+var hooks = require('preact/hooks');
+
+/*
+ * Part 1, Hooks API: useRouter, useRoute and useLocation
+ */
+
+// one of the coolest features of `createContext`:
+// when no value is provided — default object is used.
+// allows us to use the router context as a global ref to store
+// the implicitly created router (see `useRouter` below)
+const RouterCtx = preact.createContext({});
+
+const buildRouter = ({
+  hook = useLocation$1['default'],
+  base = "",
+  matcher: matcher$1 = matcher['default'](),
+} = {}) => ({ hook, base, matcher: matcher$1 });
+
+const useRouter = () => {
+  const globalRef = hooks.useContext(RouterCtx);
+
+  // either obtain the router from the outer context (provided by the
+  // `<Router /> component) or create an implicit one on demand.
+  return globalRef.v || (globalRef.v = buildRouter());
+};
+
+const useLocation = () => {
+  const router = useRouter();
+  return router.hook(router);
+};
+
+const useRoute = (pattern) => {
+  const [path] = useLocation();
+  return useRouter().matcher(pattern, path);
+};
+
+// internal hook used by Link and Redirect in order to perform navigation
+const useNavigate = (options) => {
+  const navRef = hooks.useRef();
+  const [, navigate] = useLocation();
+
+  navRef.current = () => navigate(options.to || options.href, options);
+  return navRef;
+};
+
+/*
+ * Part 2, Low Carb Router API: Router, Route, Link, Switch
+ */
+
+const Router = (props) => {
+  const ref = hooks.useRef();
+
+  // this little trick allows to avoid having unnecessary
+  // calls to potentially expensive `buildRouter` method.
+  // https://reactjs.org/docs/hooks-faq.html#how-to-create-expensive-objects-lazily
+  const value = ref.current || (ref.current = { v: buildRouter(props) });
+
+  return preact.createElement(RouterCtx.Provider, {
+    value,
+    children: props.children,
+  });
+};
+
+const Route = ({ path, match, component, children }) => {
+  const useRouteMatch = useRoute(path);
+
+  // `props.match` is present - Route is controlled by the Switch
+  const [matches, params] = match || useRouteMatch;
+
+  if (!matches) return null;
+
+  // React-Router style `component` prop
+  if (component) return preact.createElement(component, { params });
+
+  // support render prop or plain children
+  return typeof children === "function" ? children(params) : children;
+};
+
+const Link = (props) => {
+  const navRef = useNavigate(props);
+  const { base } = useRouter();
+
+  let { to, href = to, children, onClick } = props;
+
+  const handleClick = hooks.useCallback(
+    (event) => {
+      // ignores the navigation when clicked using right mouse button or
+      // by holding a special modifier key: ctrl, command, win, alt, shift
+      if (
+        event.ctrlKey ||
+        event.metaKey ||
+        event.altKey ||
+        event.shiftKey ||
+        event.button !== 0
+      )
+        return;
+
+      event.preventDefault();
+      navRef.current();
+      onClick && onClick(event);
+    },
+    // navRef is a ref so it never changes
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [onClick]
+  );
+
+  // wraps children in `a` if needed
+  const extraProps = {
+    // handle nested routers and absolute paths
+    href: href[0] === "~" ? href.slice(1) : base + href,
+    onClick: handleClick,
+    to: null,
+  };
+  const jsx = preact.isValidElement(children) ? children : preact.createElement("a", props);
+
+  return preact.cloneElement(jsx, extraProps);
+};
+
+const flattenChildren = (children) => {
+  return Array.isArray(children)
+    ? [].concat(
+        ...children.map((c) =>
+          c.type === preact.Fragment
+            ? flattenChildren(c.props.children)
+            : flattenChildren(c)
+        )
+      )
+    : [children];
+};
+
+const Switch = ({ children, location }) => {
+  const { matcher } = useRouter();
+  const [originalLocation] = useLocation();
+
+  for (const element of flattenChildren(children)) {
+    let match = 0;
+
+    if (
+      preact.isValidElement(element) &&
+      // we don't require an element to be of type Route,
+      // but we do require it to contain a truthy `path` prop.
+      // this allows to use different components that wrap Route
+      // inside of a switch, for example <AnimatedRoute />.
+      (match = element.props.path
+        ? matcher(element.props.path, location || originalLocation)
+        : [true, {}])[0]
+    )
+      return preact.cloneElement(element, { match });
+  }
+
+  return null;
+};
+
+const Redirect = (props) => {
+  const navRef = useNavigate(props);
+
+  // empty array means running the effect once, navRef is a ref so it never changes
+  hooks.useLayoutEffect(() => {
+    navRef.current();
+  }, []); // eslint-disable-line react-hooks/exhaustive-deps
+
+  return null;
+};
+
+exports.Link = Link;
+exports.Redirect = Redirect;
+exports.Route = Route;
+exports.Router = Router;
+exports.Switch = Switch;
+exports.default = useRoute;
+exports.useLocation = useLocation;
+exports.useRoute = useRoute;
+exports.useRouter = useRouter;

data/node_modules/wouter-preact/cjs/matcher.js

@@ -0,0 +1,72 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+// creates a matcher function
+function makeMatcher(makeRegexpFn = pathToRegexp) {
+  let cache = {};
+
+  // obtains a cached regexp version of the pattern
+  const getRegexp = (pattern) =>
+    cache[pattern] || (cache[pattern] = makeRegexpFn(pattern));
+
+  return (pattern, path) => {
+    const { regexp, keys } = getRegexp(pattern || "");
+    const out = regexp.exec(path);
+
+    if (!out) return [false, null];
+
+    // formats an object with matched params
+    const params = keys.reduce((params, key, i) => {
+      params[key.name] = out[i + 1];
+      return params;
+    }, {});
+
+    return [true, params];
+  };
+}
+
+// escapes a regexp string (borrowed from path-to-regexp sources)
+// https://github.com/pillarjs/path-to-regexp/blob/v3.0.0/index.js#L202
+const escapeRx = (str) => str.replace(/([.+*?=^!:${}()[\]|/\\])/g, "\\$1");
+
+// returns a segment representation in RegExp based on flags
+// adapted and simplified version from path-to-regexp sources
+const rxForSegment = (repeat, optional, prefix) => {
+  let capture = repeat ? "((?:[^\\/]+?)(?:\\/(?:[^\\/]+?))*)" : "([^\\/]+?)";
+  if (optional && prefix) capture = "(?:\\/" + capture + ")";
+  return capture + (optional ? "?" : "");
+};
+
+const pathToRegexp = (pattern) => {
+  const groupRx = /:([A-Za-z0-9_]+)([?+*]?)/g;
+
+  let match = null,
+    lastIndex = 0,
+    keys = [],
+    result = "";
+
+  while ((match = groupRx.exec(pattern)) !== null) {
+    const [_, segment, mod] = match;
+
+    // :foo  [1]      (  )
+    // :foo? [0 - 1]  ( o)
+    // :foo+ [1 - ∞]  (r )
+    // :foo* [0 - ∞]  (ro)
+    const repeat = mod === "+" || mod === "*";
+    const optional = mod === "?" || mod === "*";
+    const prefix = optional && pattern[match.index - 1] === "/" ? 1 : 0;
+
+    const prev = pattern.substring(lastIndex, match.index - prefix);
+
+    keys.push({ name: segment });
+    lastIndex = groupRx.lastIndex;
+
+    result += escapeRx(prev) + rxForSegment(repeat, optional, prefix);
+  }
+
+  result += escapeRx(pattern.substring(lastIndex));
+  return { keys, regexp: new RegExp("^" + result + "(?:\\/)?$", "i") };
+};
+
+exports.default = makeMatcher;

data/node_modules/wouter-preact/cjs/package.json

@@ -0,0 +1 @@
+{"type": "commonjs"}

data/node_modules/wouter-preact/cjs/react-deps.js

@@ -0,0 +1,75 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var preact = require('preact');
+var hooks = require('preact/hooks');
+
+
+
+Object.defineProperty(exports, 'Fragment', {
+  enumerable: true,
+  get: function () {
+    return preact.Fragment;
+  }
+});
+Object.defineProperty(exports, 'cloneElement', {
+  enumerable: true,
+  get: function () {
+    return preact.cloneElement;
+  }
+});
+Object.defineProperty(exports, 'createContext', {
+  enumerable: true,
+  get: function () {
+    return preact.createContext;
+  }
+});
+Object.defineProperty(exports, 'createElement', {
+  enumerable: true,
+  get: function () {
+    return preact.createElement;
+  }
+});
+Object.defineProperty(exports, 'isValidElement', {
+  enumerable: true,
+  get: function () {
+    return preact.isValidElement;
+  }
+});
+Object.defineProperty(exports, 'useCallback', {
+  enumerable: true,
+  get: function () {
+    return hooks.useCallback;
+  }
+});
+Object.defineProperty(exports, 'useContext', {
+  enumerable: true,
+  get: function () {
+    return hooks.useContext;
+  }
+});
+Object.defineProperty(exports, 'useEffect', {
+  enumerable: true,
+  get: function () {
+    return hooks.useEffect;
+  }
+});
+Object.defineProperty(exports, 'useLayoutEffect', {
+  enumerable: true,
+  get: function () {
+    return hooks.useLayoutEffect;
+  }
+});
+Object.defineProperty(exports, 'useRef', {
+  enumerable: true,
+  get: function () {
+    return hooks.useRef;
+  }
+});
+Object.defineProperty(exports, 'useState', {
+  enumerable: true,
+  get: function () {
+    return hooks.useState;
+  }
+});

data/node_modules/wouter-preact/cjs/static-location.js

@@ -0,0 +1,21 @@
+'use strict';
+
+// Generates static `useLocation` hook. The hook always
+// responds with initial path provided.
+// You can use this for server-side rendering.
+var staticLocation = (path = "/", { record = false } = {}) => {
+  let hook;
+  const navigate = (to, { replace } = {}) => {
+    if (record) {
+      if (replace) {
+        hook.history.pop();
+      }
+      hook.history.push(to);
+    }
+  };
+  hook = () => [path, navigate];
+  hook.history = [path];
+  return hook;
+};
+
+module.exports = staticLocation;