@vc-shell/framework 1.1.45 → 1.1.47

package/dist/vendor-nth-check-Bx8TxtJt.js

@@ -1,157 +0,0 @@
-import { a as boolbase } from './vendor-boolbase-Cp9L0GAZ.js';
-
-// Following http://www.w3.org/TR/css3-selectors/#nth-child-pseudo
-// Whitespace as per https://www.w3.org/TR/selectors-3/#lex is " \t\r\n\f"
-const whitespace = new Set([9, 10, 12, 13, 32]);
-const ZERO = "0".charCodeAt(0);
-const NINE = "9".charCodeAt(0);
-/**
- * Parses an expression.
- *
- * @throws An `Error` if parsing fails.
- * @returns An array containing the integer step size and the integer offset of the nth rule.
- * @example nthCheck.parse("2n+3"); // returns [2, 3]
- */
-function parse(formula) {
-    formula = formula.trim().toLowerCase();
-    if (formula === "even") {
-        return [2, 0];
-    }
-    else if (formula === "odd") {
-        return [2, 1];
-    }
-    // Parse [ ['-'|'+']? INTEGER? {N} [ S* ['-'|'+'] S* INTEGER ]?
-    let idx = 0;
-    let a = 0;
-    let sign = readSign();
-    let number = readNumber();
-    if (idx < formula.length && formula.charAt(idx) === "n") {
-        idx++;
-        a = sign * (number !== null && number !== void 0 ? number : 1);
-        skipWhitespace();
-        if (idx < formula.length) {
-            sign = readSign();
-            skipWhitespace();
-            number = readNumber();
-        }
-        else {
-            sign = number = 0;
-        }
-    }
-    // Throw if there is anything else
-    if (number === null || idx < formula.length) {
-        throw new Error(`n-th rule couldn't be parsed ('${formula}')`);
-    }
-    return [a, sign * number];
-    function readSign() {
-        if (formula.charAt(idx) === "-") {
-            idx++;
-            return -1;
-        }
-        if (formula.charAt(idx) === "+") {
-            idx++;
-        }
-        return 1;
-    }
-    function readNumber() {
-        const start = idx;
-        let value = 0;
-        while (idx < formula.length &&
-            formula.charCodeAt(idx) >= ZERO &&
-            formula.charCodeAt(idx) <= NINE) {
-            value = value * 10 + (formula.charCodeAt(idx) - ZERO);
-            idx++;
-        }
-        // Return `null` if we didn't read anything.
-        return idx === start ? null : value;
-    }
-    function skipWhitespace() {
-        while (idx < formula.length &&
-            whitespace.has(formula.charCodeAt(idx))) {
-            idx++;
-        }
-    }
-}
-
-/**
- * Returns a function that checks if an elements index matches the given rule
- * highly optimized to return the fastest solution.
- *
- * @param parsed A tuple [a, b], as returned by `parse`.
- * @returns A highly optimized function that returns whether an index matches the nth-check.
- * @example
- *
- * ```js
- * const check = nthCheck.compile([2, 3]);
- *
- * check(0); // `false`
- * check(1); // `false`
- * check(2); // `true`
- * check(3); // `false`
- * check(4); // `true`
- * check(5); // `false`
- * check(6); // `true`
- * ```
- */
-function compile(parsed) {
-    const a = parsed[0];
-    // Subtract 1 from `b`, to convert from one- to zero-indexed.
-    const b = parsed[1] - 1;
-    /*
-     * When `b <= 0`, `a * n` won't be lead to any matches for `a < 0`.
-     * Besides, the specification states that no elements are
-     * matched when `a` and `b` are 0.
-     *
-     * `b < 0` here as we subtracted 1 from `b` above.
-     */
-    if (b < 0 && a <= 0)
-        return boolbase.falseFunc;
-    // When `a` is in the range -1..1, it matches any element (so only `b` is checked).
-    if (a === -1)
-        return (index) => index <= b;
-    if (a === 0)
-        return (index) => index === b;
-    // When `b <= 0` and `a === 1`, they match any element.
-    if (a === 1)
-        return b < 0 ? boolbase.trueFunc : (index) => index >= b;
-    /*
-     * Otherwise, modulo can be used to check if there is a match.
-     *
-     * Modulo doesn't care about the sign, so let's use `a`s absolute value.
-     */
-    const absA = Math.abs(a);
-    // Get `b mod a`, + a if this is negative.
-    const bMod = ((b % absA) + absA) % absA;
-    return a > 1
-        ? (index) => index >= b && index % absA === bMod
-        : (index) => index <= b && index % absA === bMod;
-}
-
-/**
- * Parses and compiles a formula to a highly optimized function.
- * Combination of {@link parse} and {@link compile}.
- *
- * If the formula doesn't match any elements,
- * it returns [`boolbase`](https://github.com/fb55/boolbase)'s `falseFunc`.
- * Otherwise, a function accepting an _index_ is returned, which returns
- * whether or not the passed _index_ matches the formula.
- *
- * Note: The nth-rule starts counting at `1`, the returned function at `0`.
- *
- * @param formula The formula to compile.
- * @example
- * const check = nthCheck("2n+3");
- *
- * check(0); // `false`
- * check(1); // `false`
- * check(2); // `true`
- * check(3); // `false`
- * check(4); // `true`
- * check(5); // `false`
- * check(6); // `true`
- */
-function nthCheck(formula) {
-    return compile(parse(formula));
-}
-
-export { nthCheck as n };

package/dist/vendor-orderedmap-dGG6uMFJ.js

@@ -1,137 +0,0 @@
-// ::- Persistent data structure representing an ordered mapping from
-// strings to values, with some convenient update methods.
-function OrderedMap(content) {
-  this.content = content;
-}
-
-OrderedMap.prototype = {
-  constructor: OrderedMap,
-
-  find: function(key) {
-    for (var i = 0; i < this.content.length; i += 2)
-      if (this.content[i] === key) return i
-    return -1
-  },
-
-  // :: (string) → ?any
-  // Retrieve the value stored under `key`, or return undefined when
-  // no such key exists.
-  get: function(key) {
-    var found = this.find(key);
-    return found == -1 ? undefined : this.content[found + 1]
-  },
-
-  // :: (string, any, ?string) → OrderedMap
-  // Create a new map by replacing the value of `key` with a new
-  // value, or adding a binding to the end of the map. If `newKey` is
-  // given, the key of the binding will be replaced with that key.
-  update: function(key, value, newKey) {
-    var self = newKey && newKey != key ? this.remove(newKey) : this;
-    var found = self.find(key), content = self.content.slice();
-    if (found == -1) {
-      content.push(newKey || key, value);
-    } else {
-      content[found + 1] = value;
-      if (newKey) content[found] = newKey;
-    }
-    return new OrderedMap(content)
-  },
-
-  // :: (string) → OrderedMap
-  // Return a map with the given key removed, if it existed.
-  remove: function(key) {
-    var found = this.find(key);
-    if (found == -1) return this
-    var content = this.content.slice();
-    content.splice(found, 2);
-    return new OrderedMap(content)
-  },
-
-  // :: (string, any) → OrderedMap
-  // Add a new key to the start of the map.
-  addToStart: function(key, value) {
-    return new OrderedMap([key, value].concat(this.remove(key).content))
-  },
-
-  // :: (string, any) → OrderedMap
-  // Add a new key to the end of the map.
-  addToEnd: function(key, value) {
-    var content = this.remove(key).content.slice();
-    content.push(key, value);
-    return new OrderedMap(content)
-  },
-
-  // :: (string, string, any) → OrderedMap
-  // Add a key after the given key. If `place` is not found, the new
-  // key is added to the end.
-  addBefore: function(place, key, value) {
-    var without = this.remove(key), content = without.content.slice();
-    var found = without.find(place);
-    content.splice(found == -1 ? content.length : found, 0, key, value);
-    return new OrderedMap(content)
-  },
-
-  // :: ((key: string, value: any))
-  // Call the given function for each key/value pair in the map, in
-  // order.
-  forEach: function(f) {
-    for (var i = 0; i < this.content.length; i += 2)
-      f(this.content[i], this.content[i + 1]);
-  },
-
-  // :: (union<Object, OrderedMap>) → OrderedMap
-  // Create a new map by prepending the keys in this map that don't
-  // appear in `map` before the keys in `map`.
-  prepend: function(map) {
-    map = OrderedMap.from(map);
-    if (!map.size) return this
-    return new OrderedMap(map.content.concat(this.subtract(map).content))
-  },
-
-  // :: (union<Object, OrderedMap>) → OrderedMap
-  // Create a new map by appending the keys in this map that don't
-  // appear in `map` after the keys in `map`.
-  append: function(map) {
-    map = OrderedMap.from(map);
-    if (!map.size) return this
-    return new OrderedMap(this.subtract(map).content.concat(map.content))
-  },
-
-  // :: (union<Object, OrderedMap>) → OrderedMap
-  // Create a map containing all the keys in this map that don't
-  // appear in `map`.
-  subtract: function(map) {
-    var result = this;
-    map = OrderedMap.from(map);
-    for (var i = 0; i < map.content.length; i += 2)
-      result = result.remove(map.content[i]);
-    return result
-  },
-
-  // :: () → Object
-  // Turn ordered map into a plain object.
-  toObject: function() {
-    var result = {};
-    this.forEach(function(key, value) { result[key] = value; });
-    return result
-  },
-
-  // :: number
-  // The amount of keys in this map.
-  get size() {
-    return this.content.length >> 1
-  }
-};
-
-// :: (?union<Object, OrderedMap>) → OrderedMap
-// Return a map with the given content. If null, create an empty
-// map. If given an ordered map, return that map itself. If given an
-// object, create a map from the object's properties.
-OrderedMap.from = function(value) {
-  if (value instanceof OrderedMap) return value
-  var content = [];
-  if (value) for (var prop in value) content.push(prop, value[prop]);
-  return new OrderedMap(content)
-};
-
-export { OrderedMap as O };