@bablr/agast-helpers 0.11.0 → 0.11.2

package/lib/builders.js

@@ -402,6 +402,8 @@ export const parseObject = (input) => {
 
     obj[key] = value;
 
+    while (chr === ' ') chr = str[++p.idx];
+
     sep = chr === ',' ? chr : null;
     if (sep) {
       chr = str[++p.idx];
@@ -429,13 +431,23 @@ export const parseArray = (input) => {
     chr = str[++p.idx];
   }
 
-  let value = parseExpression(p);
-  chr = str[p.idx];
+  let first = true;
+  while (first || chr === ',') {
+    if (!first && chr === ',') {
+      chr = str[++p.idx];
+      while (chr === ' ') {
+        chr = str[++p.idx];
+      }
+    }
+    let value = parseExpression(p);
+    chr = str[p.idx];
 
-  arr.push(value);
+    arr.push(value);
 
-  while (chr === ' ') {
-    chr = str[++p.idx];
+    while (chr === ' ') {
+      chr = str[++p.idx];
+    }
+    first = false;
   }
 
   if (chr !== ']') throw new Error();
@@ -473,12 +485,31 @@ export const parseString = (input) => {
   return result.join('');
 };
 
+export const parseDigits = (input) => {
+  let p = buildParser(input);
+  let { str } = p;
+  let chr = str[p.idx];
+  let digits = [];
+
+  while (chr >= '0' && chr <= '9') {
+    digits.push(chr);
+    chr = str[++p.idx];
+  }
+
+  return parseInt(digits.join(''), 10);
+};
+
 export const parseUnsignedInteger = (input) => {
   let p = buildParser(input);
   let { str } = p;
   let chr = str[p.idx];
   let digits = [];
 
+  if (chr === '0') {
+    chr = str[++p.idx];
+    return 0;
+  }
+
   while (chr >= '0' && chr <= '9') {
     digits.push(chr);
     chr = str[++p.idx];
@@ -487,6 +518,58 @@ export const parseUnsignedInteger = (input) => {
   return parseInt(digits.join(''), 10);
 };
 
+export const parseInteger = (input) => {
+  let p = buildParser(input);
+  let { str } = p;
+  let chr = str[p.idx];
+  let negative = false;
+
+  if (chr === '-') {
+    negative = true;
+    chr = str[++p.idx];
+  }
+
+  return parseUnsignedInteger(p) * (negative ? -1 : 1);
+};
+
+export const parseNumber = (input) => {
+  let p = buildParser(input);
+  let { str } = p;
+  let chr = str[p.idx];
+  let startIdx = p.idx;
+
+  if (chr === '-') {
+    chr = str[++p.idx];
+  }
+
+  if (chr == '0') {
+    chr = str[++p.idx];
+  } else {
+    parseDigits(p);
+    chr = str[p.idx];
+  }
+
+  if (chr === '.') {
+    chr = str[++p.idx];
+    parseDigits(p);
+    chr = str[p.idx];
+  }
+
+  if (chr === 'e' || chr === 'E') {
+    chr = str[++p.idx];
+
+    if (chr === '+' || chr === '-') {
+      chr = str[++p.idx];
+    }
+
+    parseDigits(p);
+  }
+
+  let endIdx = p.idx;
+
+  return parseFloat(str.slice(startIdx, endIdx));
+};
+
 export const parseEscape = (input) => {
   let p = buildParser(input);
   let { str } = p;
@@ -601,7 +684,7 @@ export const parseExpression = (input) => {
         p.idx += 9;
         return -Infinity;
       } else {
-        throw new Error();
+        return parseNumber(p);
       }
     case '+':
       if (str[p.idx + 1] === 'I' && match(p, '+Infinity')) {
@@ -612,7 +695,7 @@ export const parseExpression = (input) => {
       }
     default:
       if (chr >= '0' && chr <= '9') {
-        return parseUnsignedInteger(p);
+        return parseNumber(p);
       } else {
         throw new Error();
       }

package/lib/object.js

@@ -123,6 +123,48 @@ export const when = (condition, value) => {
     : emptySpreadable;
 };
 
+let arrayIncludes_ = Array.prototype.includes;
+export const arrayIncludes = (arr, key) => {
+  if (!isArray(arr)) throw new Error();
+
+  return arrayIncludes_.call(arr, key);
+};
+
+let arraySlice_ = Array.prototype.slice;
+export const arraySlice = (arr, start, end) => {
+  if (!isArray(arr)) throw new Error();
+
+  return arraySlice_.call(arr, start, end);
+};
+
+let arrayJoin_ = Array.prototype.join;
+export const arrayJoin = (arr, sep) => {
+  if (!isArray(arr)) throw new Error();
+
+  return arrayJoin_.call(arr, sep);
+};
+
+let arrayFindIndex_ = Array.prototype.findIndex;
+export const arrayFindIndex = (arr, value) => {
+  if (!isArray(arr)) throw new Error();
+
+  return arrayFindIndex_.call(arr, value);
+};
+
+let arrayMap_ = Array.prototype.map;
+export const arrayMap = (arr, fn) => {
+  if (!isArray(arr)) throw new Error();
+
+  return arrayMap_.call(arr, fn);
+};
+
+let arrayReduce_ = Array.prototype.reduce;
+export const arrayReduce = (arr, fn, initial) => {
+  if (!isArray(arr)) throw new Error();
+
+  return arrayReduce_.call(arr, fn, initial);
+};
+
 export const isObject = (obj) => obj !== null && typeof obj === 'object';
 export const isPlainObject = (val) => val && [Object.prototype, null].includes(getPrototypeOf(val));
 export const isFunction = (obj) => typeof obj === 'function';

package/lib/print.js

@@ -13,20 +13,23 @@ import {
   StreamTag,
 } from './symbols.js';
 import { parseObject } from './builders.js';
+import { arrayValues } from './iterable.js';
+import { arrayJoin, arrayMap } from './object.js';
 
 let { isInteger, isFinite } = Number;
 let { isArray } = Array;
-let { freeze } = Object;
+let { freeze, entries } = Object;
 let isString = (val) => typeof val === 'string';
 let isNumber = (val) => typeof val === 'number';
 let isObject = (val) => val && typeof val === 'object' && !isArray(val);
 
-export const printArray = (arr) => `[${arr.map((v) => printExpression(v)).join(', ')}]`;
+export const printArray = (arr) =>
+  `[${[...arrayValues(arr)].map((v) => printExpression(v)).join(', ')}]`;
 
 export const printObject = (obj) => {
-  let entries = Object.entries(obj);
-  return entries.length
-    ? `{ ${entries.map(([k, v]) => `${k}: ${printExpression(v)}`).join(', ')} }`
+  let entries_ = entries(obj);
+  return entries_.length
+    ? `{ ${entries_.map(([k, v]) => `${k}: ${printExpression(v)}`).join(', ')} }`
     : '{}';
 };
 
@@ -62,20 +65,18 @@ export const printAttributes = (attributes) => {
 };
 
 export const printIdentifierPath = (path) => {
-  return Array.prototype.map
-    .call(path, (segment) => {
-      let { name, type } = segment;
-      if (name) {
-        return printIdentifier(name);
-      }
-      if (type) {
-        if (type !== '..') throw new Error();
-        return type;
-      } else {
-        throw new Error();
-      }
-    })
-    .join('.');
+  return arrayMap(path, (segment) => {
+    let { name, type } = segment;
+    if (name) {
+      return printIdentifier(name);
+    }
+    if (type) {
+      if (type !== '..') throw new Error();
+      return type;
+    } else {
+      throw new Error();
+    }
+  }).join('.');
 };
 
 let escapeReplacer = (esc) => {
@@ -257,7 +258,7 @@ export const printStreamTag = (tag) => {
 
   let { processPath, stream } = tag.value;
 
-  return `<${Array.prototype.join.call(processPath, '.')}-${stream}>`;
+  return `<${arrayJoin(processPath, '.')}-${stream}>`;
 };
 
 export const printCloseNodeTag = (tag) => {
@@ -272,7 +273,7 @@ export const printAttributeDefinition = (tag) => {
   let { path, value } = tag.value;
 
   return `{ ${printIdentifierPath(
-    Array.prototype.map.call(path, (name) => freeze({ type: null, name })),
+    arrayMap(path, (name) => freeze({ type: null, name })),
   )}: ${printExpression(value)} }`;
 };
 

package/lib/tags.js

@@ -14,13 +14,11 @@ import {
   BindingTag,
   Document,
 } from './symbols.js';
-import { freezeRecord, isArray, isObject, isString } from './object.js';
+import { arrayReduce, arraySlice, freezeRecord, isArray, isObject, isString } from './object.js';
 import { buildReference, parseTag, parseTagType } from './builders.js';
 import { printTag } from './print.js';
 import { arrayValues } from './iterable.js';
 
-let { reduce } = Array.prototype;
-
 export { defaultNodeSize };
 
 export const referenceIsSingular = (ref) => {
@@ -189,7 +187,7 @@ const __getPropertyTagsIndex = (tags, type, name, index) => {
 export const compareNames = (a, b) => (a > b ? 1 : b > a ? -1 : 0);
 
 export const sumValues = (values, depth) => {
-  let mapStats = reduce.call(
+  let mapStats = arrayReduce(
     values,
     (acc, val) => {
       const { names, types } = acc;
@@ -298,11 +296,9 @@ const {
   findPath,
 } = module_;
 
-let { slice } = Array.prototype;
-
 const getAt = (idx, tags) => {
   if (isArray(idx) && idx.length > 1) {
-    return module_.getAt(slice.call(idx, 1), module_.getAt(slice.call(idx, 0, 1), tags));
+    return module_.getAt(arraySlice(idx, 1), module_.getAt(arraySlice(idx, 0, 1), tags));
   } else {
     return module_.getAt(idx, tags);
   }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@bablr/agast-helpers",
   "description": "Helper functions for working with agAST trees",
-  "version": "0.11.0",
+  "version": "0.11.2",
   "author": "Conrad Buck<conartist6@gmail.com>",
   "type": "module",
   "files": [