@valbuild/server 0.146.2 → 0.147.0

package/dist/ops-f37d18c6.cjs.dev.js

@@ -0,0 +1,361 @@
+'use strict';
+
+var ts = require('typescript');
+var fp = require('@valbuild/core/fp');
+var jsonValuesModule = require('./jsonValuesModule-8ae503a8.cjs.dev.js');
+var patch = require('@valbuild/core/patch');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { 'default': e }; }
+
+var ts__default = /*#__PURE__*/_interopDefault(ts);
+
+function isValidIdentifier(text) {
+  if (text.length === 0) {
+    return false;
+  }
+  if (!ts__default["default"].isIdentifierStart(text.charCodeAt(0), ts__default["default"].ScriptTarget.ES2020)) {
+    return false;
+  }
+  for (let i = 1; i < text.length; ++i) {
+    if (!ts__default["default"].isIdentifierPart(text.charCodeAt(i), ts__default["default"].ScriptTarget.ES2020)) {
+      return false;
+    }
+  }
+  return true;
+}
+function createPropertyAssignment(key, value) {
+  return ts__default["default"].factory.createPropertyAssignment(isValidIdentifier(key) ? ts__default["default"].factory.createIdentifier(key) : ts__default["default"].factory.createStringLiteral(key), toExpression(value));
+}
+
+/**
+ * Builds the expression `c.json(() => import("<importPath>"))` used to reference
+ * a lazily-loaded `*.val.json` entry of a `.jsonValues()` record.
+ */
+function createValJsonReference(importPath) {
+  // () => import("<importPath>")
+  // NOTE: an `import` identifier prints as the dynamic-import keyword call,
+  // which avoids casting the ImportKeyword token (not typed as an Expression).
+  const importCall = ts__default["default"].factory.createCallExpression(ts__default["default"].factory.createIdentifier("import"), undefined, [ts__default["default"].factory.createStringLiteral(importPath)]);
+  const thunk = ts__default["default"].factory.createArrowFunction(undefined, undefined, [], undefined, ts__default["default"].factory.createToken(ts__default["default"].SyntaxKind.EqualsGreaterThanToken), importCall);
+  // c.json(<thunk>)
+  return ts__default["default"].factory.createCallExpression(ts__default["default"].factory.createPropertyAccessExpression(ts__default["default"].factory.createIdentifier("c"), ts__default["default"].factory.createIdentifier("json")), undefined, [thunk]);
+}
+
+/**
+ * Inserts a new `.jsonValues()` entry `"<key>": c.json(() => import("<importPath>"))`
+ * into the record's object literal in a `.val.ts` module. `recordPath` is the
+ * path from the module source to the record (empty for a root record/router).
+ * Fails if the entry key already exists.
+ */
+function insertValJsonEntry(document, recordPath, key, importPath) {
+  return fp.pipe(jsonValuesModule.analyzeValModule(document), fp.result.flatMap(({
+    source
+  }) => getAtPath(source, recordPath)), fp.result.flatMap(recordNode => {
+    if (!ts__default["default"].isObjectLiteralExpression(recordNode)) {
+      return fp.result.err(new patch.PatchError("Cannot add jsonValues entry: record source is not an object literal"));
+    }
+    return fp.pipe(jsonValuesModule.findObjectPropertyAssignment(recordNode, key), fp.result.flatMap(assignment => {
+      if (assignment) {
+        return fp.result.err(new patch.PatchError(`Cannot add jsonValues entry '${key}': it already exists`));
+      }
+      const property = ts__default["default"].factory.createPropertyAssignment(isValidIdentifier(key) ? ts__default["default"].factory.createIdentifier(key) : ts__default["default"].factory.createStringLiteral(key), createValJsonReference(importPath));
+      return fp.result.ok(insertAt(document, recordNode.properties, recordNode.properties.length, property));
+    }));
+  }));
+}
+
+/**
+ * Removes the `.jsonValues()` entry `"<key>"` from the record's object literal
+ * in a `.val.ts` module. `recordPath` is the path from the module source to the
+ * record (empty for a root record/router). Fails if the entry key is missing.
+ */
+function removeValJsonEntry(document, recordPath, key) {
+  return fp.pipe(jsonValuesModule.analyzeValModule(document), fp.result.flatMap(({
+    source
+  }) => getAtPath(source, recordPath)), fp.result.flatMap(recordNode => {
+    if (!ts__default["default"].isObjectLiteralExpression(recordNode)) {
+      return fp.result.err(new patch.PatchError("Cannot remove jsonValues entry: record source is not an object literal"));
+    }
+    return fp.pipe(jsonValuesModule.findObjectPropertyAssignment(recordNode, key), fp.result.flatMap(assignment => {
+      if (!assignment) {
+        return fp.result.err(new patch.PatchError(`Cannot remove jsonValues entry '${key}': it does not exist`));
+      }
+      const [doc] = removeAt(document, recordNode.properties, recordNode.properties.indexOf(assignment));
+      return fp.result.ok(doc);
+    }));
+  }));
+}
+function toExpression(value) {
+  if (typeof value === "string") {
+    // TODO: Use configuration/heuristics to determine use of single quote or double quote
+    return ts__default["default"].factory.createStringLiteral(value);
+  } else if (typeof value === "number") {
+    // TODO: do we want to do something like this for very large numbers?
+    // if (value > Number.MAX_SAFE_INTEGER) {
+    //   return ts.factory.createBigIntLiteral(`${value}n`);
+    // }
+    // if (value < Number.MIN_SAFE_INTEGER) {
+    //   return ts.factory.createPrefixUnaryExpression(
+    //     ts.SyntaxKind.MinusToken,
+    //     ts.factory.createBigIntLiteral(`${value}n`),
+    //   );
+    // }
+    if (value < 0) {
+      return ts__default["default"].factory.createPrefixUnaryExpression(ts__default["default"].SyntaxKind.MinusToken, ts__default["default"].factory.createNumericLiteral(Math.abs(value)));
+    }
+    return ts__default["default"].factory.createNumericLiteral(value);
+  } else if (typeof value === "boolean") {
+    return value ? ts__default["default"].factory.createTrue() : ts__default["default"].factory.createFalse();
+  } else if (value === null) {
+    return ts__default["default"].factory.createNull();
+  } else if (Array.isArray(value)) {
+    return ts__default["default"].factory.createArrayLiteralExpression(value.map(toExpression));
+  } else if (typeof value === "object") {
+    return ts__default["default"].factory.createObjectLiteralExpression(Object.entries(value)
+    // `patch_id` is injected server-side onto a media source whose bytes are
+    // not committed yet. It describes the draft, not the content, and a
+    // whole-object write built from the client's optimistic view would
+    // otherwise print it into the user's file.
+    .filter(([key]) => key !== "patch_id").map(([key, value]) => createPropertyAssignment(key, value)));
+  } else {
+    return ts__default["default"].factory.createStringLiteral(value);
+  }
+}
+
+// TODO: Choose newline based on project settings/heuristics/system default?
+const newLine = ts__default["default"].NewLineKind.LineFeed;
+// TODO: Handle indentation of printed code
+const printer = ts__default["default"].createPrinter({
+  newLine: newLine
+  // neverAsciiEscape: true,
+});
+function replaceNodeValue(document, node, value) {
+  const replacementText = printer.printNode(ts__default["default"].EmitHint.Unspecified, toExpression(value), document);
+  const span = ts__default["default"].createTextSpanFromBounds(node.getStart(document, false), node.end);
+  const newText = `${document.text.substring(0, span.start)}${replacementText}${document.text.substring(ts__default["default"].textSpanEnd(span))}`;
+  return [document.update(newText, ts__default["default"].createTextChangeRange(span, replacementText.length)), node];
+}
+function isIndentation(s) {
+  for (let i = 0; i < s.length; ++i) {
+    const c = s.charAt(i);
+    if (c !== " " && c !== "\t") {
+      return false;
+    }
+  }
+  return true;
+}
+function newLineStr(kind) {
+  if (kind === ts__default["default"].NewLineKind.CarriageReturnLineFeed) {
+    return "\r\n";
+  } else {
+    return "\n";
+  }
+}
+function getSeparator(document, neighbor) {
+  const startPos = neighbor.getStart(document, true);
+  const basis = document.getLineAndCharacterOfPosition(startPos);
+  const lineStartPos = document.getPositionOfLineAndCharacter(basis.line, 0);
+  const maybeIndentation = document.getText().substring(lineStartPos, startPos);
+  if (isIndentation(maybeIndentation)) {
+    return `,${newLineStr(newLine)}${maybeIndentation}`;
+  } else {
+    return `, `;
+  }
+}
+function insertAt(document, nodes, index, node) {
+  let span;
+  let replacementText;
+  if (nodes.length === 0) {
+    // Replace entire range of nodes
+    replacementText = printer.printNode(ts__default["default"].EmitHint.Unspecified, node, document);
+    span = ts__default["default"].createTextSpanFromBounds(nodes.pos, nodes.end);
+  } else if (index === nodes.length) {
+    // Insert after last node
+    const neighbor = nodes[nodes.length - 1];
+    replacementText = `${getSeparator(document, neighbor)}${printer.printNode(ts__default["default"].EmitHint.Unspecified, node, document)}`;
+    span = ts__default["default"].createTextSpan(neighbor.end, 0);
+  } else {
+    // Insert before node
+    const neighbor = nodes[index];
+    replacementText = `${printer.printNode(ts__default["default"].EmitHint.Unspecified, node, document)}${getSeparator(document, neighbor)}`;
+    span = ts__default["default"].createTextSpan(neighbor.getStart(document, true), 0);
+  }
+  const newText = `${document.text.substring(0, span.start)}${replacementText}${document.text.substring(ts__default["default"].textSpanEnd(span))}`;
+  return document.update(newText, ts__default["default"].createTextChangeRange(span, replacementText.length));
+}
+function removeAt(document, nodes, index) {
+  const node = nodes[index];
+  let span;
+  if (nodes.length === 1) {
+    span = ts__default["default"].createTextSpanFromBounds(nodes.pos, nodes.end);
+  } else if (index === nodes.length - 1) {
+    // Remove until previous node
+    const neighbor = nodes[index - 1];
+    span = ts__default["default"].createTextSpanFromBounds(neighbor.end, node.end);
+  } else {
+    // Remove before next node
+    const neighbor = nodes[index + 1];
+    span = ts__default["default"].createTextSpanFromBounds(node.getStart(document, true), neighbor.getStart(document, true));
+  }
+  const newText = `${document.text.substring(0, span.start)}${document.text.substring(ts__default["default"].textSpanEnd(span))}`;
+  return [document.update(newText, ts__default["default"].createTextChangeRange(span, 0)), node];
+}
+function parseAndValidateArrayInsertIndex(key, nodes) {
+  if (key === "-") {
+    // For insertion, all nodes up until the insertion index must be valid
+    // initializers
+    const err = jsonValuesModule.validateInitializers(nodes);
+    if (err) {
+      return fp.result.err(err);
+    }
+    return fp.result.ok(nodes.length);
+  }
+  return fp.pipe(patch.parseAndValidateArrayIndex(key), fp.result.flatMap(index => {
+    // For insertion, all nodes up until the insertion index must be valid
+    // initializers
+    const err = jsonValuesModule.validateInitializers(nodes.slice(0, index));
+    if (err) {
+      return fp.result.err(err);
+    }
+    if (index > nodes.length) {
+      return fp.result.err(new patch.PatchError("Array index out of bounds"));
+    } else {
+      return fp.result.ok(index);
+    }
+  }));
+}
+function parseAndValidateArrayInboundsIndex(key, nodes) {
+  return fp.pipe(patch.parseAndValidateArrayIndex(key), fp.result.flatMap(index => {
+    // For in-bounds operations, all nodes up until and including the index
+    // must be valid initializers
+    const err = jsonValuesModule.validateInitializers(nodes.slice(0, index + 1));
+    if (err) {
+      return fp.result.err(err);
+    }
+    if (index >= nodes.length) {
+      return fp.result.err(new patch.PatchError("Array index out of bounds"));
+    } else {
+      return fp.result.ok(index);
+    }
+  }));
+}
+function replaceInNode(document, node, key, value) {
+  if (ts__default["default"].isArrayLiteralExpression(node)) {
+    return fp.pipe(parseAndValidateArrayInboundsIndex(key, node.elements), fp.result.map(index => replaceNodeValue(document, node.elements[index], value)));
+  } else if (ts__default["default"].isObjectLiteralExpression(node)) {
+    return fp.pipe(jsonValuesModule.findObjectPropertyAssignment(node, key), fp.result.flatMap(assignment => {
+      if (!assignment) {
+        return fp.result.err(new patch.PatchError("Cannot replace object element which does not exist"));
+      }
+      return fp.result.ok(assignment);
+    }), fp.result.map(assignment => replaceNodeValue(document, assignment.initializer, value)));
+  } else {
+    return fp.result.err(jsonValuesModule.shallowValidateExpression(node) ?? new patch.PatchError("Cannot replace in non-object/array"));
+  }
+}
+function replaceAtPath(document, rootNode, path, value) {
+  if (patch.isNotRoot(path)) {
+    return fp.pipe(getPointerFromPath(rootNode, path), fp.result.flatMap(([node, key]) => replaceInNode(document, node, key, value)));
+  } else {
+    return fp.result.ok(replaceNodeValue(document, rootNode, value));
+  }
+}
+function getFromNode(node, key) {
+  if (ts__default["default"].isArrayLiteralExpression(node)) {
+    return fp.pipe(parseAndValidateArrayInboundsIndex(key, node.elements), fp.result.map(index => node.elements[index]));
+  } else if (ts__default["default"].isObjectLiteralExpression(node)) {
+    return fp.pipe(jsonValuesModule.findObjectPropertyAssignment(node, key), fp.result.map(assignment => assignment === null || assignment === void 0 ? void 0 : assignment.initializer));
+  } else {
+    return fp.result.err(jsonValuesModule.shallowValidateExpression(node) ?? new patch.PatchError("Cannot access non-object/array"));
+  }
+}
+function getPointerFromPath(node, path) {
+  let targetNode = node;
+  let key = path[0];
+  for (let i = 0; i < path.length - 1; ++i, key = path[i]) {
+    const childNode = getFromNode(targetNode, key);
+    if (fp.result.isErr(childNode)) {
+      return childNode;
+    }
+    if (childNode.value === undefined) {
+      return fp.result.err(new patch.PatchError(`Path refers to non-existing object/array: ${path.join("/")}`));
+    }
+    targetNode = childNode.value;
+  }
+  return fp.result.ok([targetNode, key]);
+}
+function getAtPath(rootNode, path) {
+  return fp.pipe(path, fp.result.flatMapReduce((node, key) => fp.pipe(getFromNode(node, key), fp.result.filterOrElse(childNode => childNode !== undefined, () => new patch.PatchError("Path refers to non-existing object/array"))), rootNode));
+}
+function removeFromNode(document, node, key) {
+  if (ts__default["default"].isArrayLiteralExpression(node)) {
+    return fp.pipe(parseAndValidateArrayInboundsIndex(key, node.elements), fp.result.map(index => removeAt(document, node.elements, index)));
+  } else if (ts__default["default"].isObjectLiteralExpression(node)) {
+    return fp.pipe(jsonValuesModule.findObjectPropertyAssignment(node, key), fp.result.flatMap(assignment => {
+      if (!assignment) {
+        return fp.result.err(new patch.PatchError("Cannot remove object element which does not exist"));
+      }
+      return fp.result.ok(assignment);
+    }), fp.result.map(assignment => [removeAt(document, node.properties, node.properties.indexOf(assignment))[0], assignment.initializer]));
+  } else {
+    return fp.result.err(jsonValuesModule.shallowValidateExpression(node) ?? new patch.PatchError("Cannot remove from non-object/array"));
+  }
+}
+function removeAtPath(document, rootNode, path) {
+  return fp.pipe(getPointerFromPath(rootNode, path), fp.result.flatMap(([node, key]) => removeFromNode(document, node, key)));
+}
+function addToNode(document, node, key, value) {
+  if (ts__default["default"].isArrayLiteralExpression(node)) {
+    return fp.pipe(parseAndValidateArrayInsertIndex(key, node.elements), fp.result.map(index => [insertAt(document, node.elements, index, toExpression(value))]));
+  } else if (ts__default["default"].isObjectLiteralExpression(node)) {
+    return fp.pipe(jsonValuesModule.findObjectPropertyAssignment(node, key), fp.result.map(assignment => {
+      if (!assignment) {
+        return [insertAt(document, node.properties, node.properties.length, createPropertyAssignment(key, value))];
+      } else {
+        return replaceNodeValue(document, assignment.initializer, value);
+      }
+    }));
+  } else {
+    return fp.result.err(jsonValuesModule.shallowValidateExpression(node) ?? new patch.PatchError("Cannot add to non-object/array"));
+  }
+}
+function addAtPath(document, rootNode, path, value) {
+  if (patch.isNotRoot(path)) {
+    return fp.pipe(getPointerFromPath(rootNode, path), fp.result.flatMap(([node, key]) => addToNode(document, node, key, value)));
+  } else {
+    return fp.result.ok(replaceNodeValue(document, rootNode, value));
+  }
+}
+function pickDocument([document]) {
+  return document;
+}
+class TSOps {
+  constructor(findRoot) {
+    this.findRoot = findRoot;
+  }
+  get(document, path) {
+    return fp.pipe(document, this.findRoot, fp.result.flatMap(rootNode => getAtPath(rootNode, path)), fp.result.flatMap(jsonValuesModule.evaluateExpression));
+  }
+  add(document, path, value) {
+    return fp.pipe(document, this.findRoot, fp.result.flatMap(rootNode => addAtPath(document, rootNode, path, value)), fp.result.map(pickDocument));
+  }
+  remove(document, path) {
+    return fp.pipe(document, this.findRoot, fp.result.flatMap(rootNode => removeAtPath(document, rootNode, path)), fp.result.map(pickDocument));
+  }
+  replace(document, path, value) {
+    return fp.pipe(document, this.findRoot, fp.result.flatMap(rootNode => replaceAtPath(document, rootNode, path, value)), fp.result.map(pickDocument));
+  }
+  move(document, from, path) {
+    return fp.pipe(document, this.findRoot, fp.result.flatMap(rootNode => removeAtPath(document, rootNode, from)), fp.result.flatMap(([document, removedNode]) => fp.pipe(jsonValuesModule.evaluateExpression(removedNode), fp.result.map(removedValue => [document, removedValue]))), fp.result.flatMap(([document, removedValue]) => fp.pipe(document, this.findRoot, fp.result.flatMap(root => addAtPath(document, root, path, removedValue)))), fp.result.map(pickDocument));
+  }
+  copy(document, from, path) {
+    return fp.pipe(document, this.findRoot, fp.result.flatMap(rootNode => fp.pipe(getAtPath(rootNode, from), fp.result.flatMap(jsonValuesModule.evaluateExpression), fp.result.flatMap(value => addAtPath(document, rootNode, path, value)))), fp.result.map(pickDocument));
+  }
+  test(document, path, value) {
+    return fp.pipe(document, this.findRoot, fp.result.flatMap(rootNode => getAtPath(rootNode, path)), fp.result.flatMap(jsonValuesModule.evaluateExpression), fp.result.map(documentValue => patch.deepEqual(value, documentValue)));
+  }
+}
+
+exports.TSOps = TSOps;
+exports.insertValJsonEntry = insertValJsonEntry;
+exports.removeValJsonEntry = removeValJsonEntry;

package/dist/publishKit-580f558a.cjs.prod.js

@@ -0,0 +1,41 @@
+'use strict';
+
+var ts = require('typescript');
+var fp = require('@valbuild/core/fp');
+var ops = require('./ops-b15239ac.cjs.prod.js');
+var jsonValuesModule = require('./jsonValuesModule-d1bb8d8f.cjs.prod.js');
+require('@valbuild/core/patch');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { 'default': e }; }
+
+var ts__default = /*#__PURE__*/_interopDefault(ts);
+
+/**
+ * Everything `ValOps.prepare` needs from the TypeScript compiler, in one module
+ * so that it is loaded when a publish asks for it rather than with the server.
+ *
+ * The compiler is most of the server's weight in a browser: the demo's in-tab
+ * server was a 3.6 MB chunk, nearly all of it this, and the demo never
+ * publishes. `prepare` imports this module dynamically, which a bundler turns
+ * into a chunk of its own; `noNodeFromBrowser.test.ts` fails if TypeScript
+ * becomes statically reachable from `@valbuild/server/browser` again.
+ */
+
+const tsOps = new ops.TSOps(document => {
+  return fp.pipe(jsonValuesModule.analyzeValModule(document), fp.result.map(({
+    source
+  }) => source));
+});
+
+/** A `.val.ts` file's text, parsed. */
+function parseValFile(text) {
+  return ts__default["default"].createSourceFile("<val>", text, ts__default["default"].ScriptTarget.ES2015);
+}
+
+exports.insertValJsonEntry = ops.insertValJsonEntry;
+exports.removeValJsonEntry = ops.removeValJsonEntry;
+exports.analyzeJsonValuesEntries = jsonValuesModule.analyzeJsonValuesEntries;
+exports.analyzeValModule = jsonValuesModule.analyzeValModule;
+exports.jsonValuesRecordKeys = jsonValuesModule.jsonValuesRecordKeys;
+exports.parseValFile = parseValFile;
+exports.tsOps = tsOps;

package/dist/publishKit-5865095c.cjs.dev.js

@@ -0,0 +1,41 @@
+'use strict';
+
+var ts = require('typescript');
+var fp = require('@valbuild/core/fp');
+var ops = require('./ops-f37d18c6.cjs.dev.js');
+var jsonValuesModule = require('./jsonValuesModule-8ae503a8.cjs.dev.js');
+require('@valbuild/core/patch');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { 'default': e }; }
+
+var ts__default = /*#__PURE__*/_interopDefault(ts);
+
+/**
+ * Everything `ValOps.prepare` needs from the TypeScript compiler, in one module
+ * so that it is loaded when a publish asks for it rather than with the server.
+ *
+ * The compiler is most of the server's weight in a browser: the demo's in-tab
+ * server was a 3.6 MB chunk, nearly all of it this, and the demo never
+ * publishes. `prepare` imports this module dynamically, which a bundler turns
+ * into a chunk of its own; `noNodeFromBrowser.test.ts` fails if TypeScript
+ * becomes statically reachable from `@valbuild/server/browser` again.
+ */
+
+const tsOps = new ops.TSOps(document => {
+  return fp.pipe(jsonValuesModule.analyzeValModule(document), fp.result.map(({
+    source
+  }) => source));
+});
+
+/** A `.val.ts` file's text, parsed. */
+function parseValFile(text) {
+  return ts__default["default"].createSourceFile("<val>", text, ts__default["default"].ScriptTarget.ES2015);
+}
+
+exports.insertValJsonEntry = ops.insertValJsonEntry;
+exports.removeValJsonEntry = ops.removeValJsonEntry;
+exports.analyzeJsonValuesEntries = jsonValuesModule.analyzeJsonValuesEntries;
+exports.analyzeValModule = jsonValuesModule.analyzeValModule;
+exports.jsonValuesRecordKeys = jsonValuesModule.jsonValuesRecordKeys;
+exports.parseValFile = parseValFile;
+exports.tsOps = tsOps;

package/dist/publishKit-bc8df53d.esm.js

@@ -0,0 +1,31 @@
+import ts from 'typescript';
+import { pipe, result } from '@valbuild/core/fp';
+import { T as TSOps } from './ops-0d05feaf.esm.js';
+export { i as insertValJsonEntry, r as removeValJsonEntry } from './ops-0d05feaf.esm.js';
+import { a as analyzeValModule } from './jsonValuesModule-427d68c8.esm.js';
+export { c as analyzeJsonValuesEntries, a as analyzeValModule, j as jsonValuesRecordKeys } from './jsonValuesModule-427d68c8.esm.js';
+import '@valbuild/core/patch';
+
+/**
+ * Everything `ValOps.prepare` needs from the TypeScript compiler, in one module
+ * so that it is loaded when a publish asks for it rather than with the server.
+ *
+ * The compiler is most of the server's weight in a browser: the demo's in-tab
+ * server was a 3.6 MB chunk, nearly all of it this, and the demo never
+ * publishes. `prepare` imports this module dynamically, which a bundler turns
+ * into a chunk of its own; `noNodeFromBrowser.test.ts` fails if TypeScript
+ * becomes statically reachable from `@valbuild/server/browser` again.
+ */
+
+const tsOps = new TSOps(document => {
+  return pipe(analyzeValModule(document), result.map(({
+    source
+  }) => source));
+});
+
+/** A `.val.ts` file's text, parsed. */
+function parseValFile(text) {
+  return ts.createSourceFile("<val>", text, ts.ScriptTarget.ES2015);
+}
+
+export { parseValFile, tsOps };