@suchipi/quickjs 0.3.0 → 0.4.1

package/build/aarch64-apple-darwin/bin/file-to-bytecode.js

@@ -0,0 +1,27 @@
+#!/usr/bin/env quickjs-run
+
+// Simple script which reads in a file, converts it to bytecode, and writes out
+// the bytecode to a new file.
+
+/// <reference path="../quickjs/quickjs.d.ts" />
+/// <reference path="../quickjs-libc/quickjs-libc.d.ts" />
+/// <reference path="../quickjs-libbytecode/quickjs-libbytecode.d.ts" />
+
+import * as std from "quickjs:std";
+import * as Bytecode from "quickjs:bytecode";
+
+function main() {
+  const [_quickjsRun, _thisScript, inputFile, outputFile] = scriptArgs;
+
+  if (!(inputFile && outputFile)) {
+    throw new Error(
+      "You must pass two positional arguments to this script: the input file path (js) and the output file path (bytecode binary)."
+    );
+  }
+
+  const bytecode = Bytecode.fromFile(inputFile);
+  const out = std.open(outputFile, "wb");
+  out.write(bytecode, 0, bytecode.byteLength);
+}
+
+main();

package/build/aarch64-unknown-linux-gnu/bin/file-to-bytecode.js

@@ -0,0 +1,27 @@
+#!/usr/bin/env quickjs-run
+
+// Simple script which reads in a file, converts it to bytecode, and writes out
+// the bytecode to a new file.
+
+/// <reference path="../quickjs/quickjs.d.ts" />
+/// <reference path="../quickjs-libc/quickjs-libc.d.ts" />
+/// <reference path="../quickjs-libbytecode/quickjs-libbytecode.d.ts" />
+
+import * as std from "quickjs:std";
+import * as Bytecode from "quickjs:bytecode";
+
+function main() {
+  const [_quickjsRun, _thisScript, inputFile, outputFile] = scriptArgs;
+
+  if (!(inputFile && outputFile)) {
+    throw new Error(
+      "You must pass two positional arguments to this script: the input file path (js) and the output file path (bytecode binary)."
+    );
+  }
+
+  const bytecode = Bytecode.fromFile(inputFile);
+  const out = std.open(outputFile, "wb");
+  out.write(bytecode, 0, bytecode.byteLength);
+}
+
+main();

package/build/aarch64-unknown-linux-musl/bin/file-to-bytecode.js

@@ -0,0 +1,27 @@
+#!/usr/bin/env quickjs-run
+
+// Simple script which reads in a file, converts it to bytecode, and writes out
+// the bytecode to a new file.
+
+/// <reference path="../quickjs/quickjs.d.ts" />
+/// <reference path="../quickjs-libc/quickjs-libc.d.ts" />
+/// <reference path="../quickjs-libbytecode/quickjs-libbytecode.d.ts" />
+
+import * as std from "quickjs:std";
+import * as Bytecode from "quickjs:bytecode";
+
+function main() {
+  const [_quickjsRun, _thisScript, inputFile, outputFile] = scriptArgs;
+
+  if (!(inputFile && outputFile)) {
+    throw new Error(
+      "You must pass two positional arguments to this script: the input file path (js) and the output file path (bytecode binary)."
+    );
+  }
+
+  const bytecode = Bytecode.fromFile(inputFile);
+  const out = std.open(outputFile, "wb");
+  out.write(bytecode, 0, bytecode.byteLength);
+}
+
+main();

package/build/aarch64-unknown-linux-static/bin/file-to-bytecode.js

@@ -0,0 +1,27 @@
+#!/usr/bin/env quickjs-run
+
+// Simple script which reads in a file, converts it to bytecode, and writes out
+// the bytecode to a new file.
+
+/// <reference path="../quickjs/quickjs.d.ts" />
+/// <reference path="../quickjs-libc/quickjs-libc.d.ts" />
+/// <reference path="../quickjs-libbytecode/quickjs-libbytecode.d.ts" />
+
+import * as std from "quickjs:std";
+import * as Bytecode from "quickjs:bytecode";
+
+function main() {
+  const [_quickjsRun, _thisScript, inputFile, outputFile] = scriptArgs;
+
+  if (!(inputFile && outputFile)) {
+    throw new Error(
+      "You must pass two positional arguments to this script: the input file path (js) and the output file path (bytecode binary)."
+    );
+  }
+
+  const bytecode = Bytecode.fromFile(inputFile);
+  const out = std.open(outputFile, "wb");
+  out.write(bytecode, 0, bytecode.byteLength);
+}
+
+main();

package/build/dts/inspect.d.ts

@@ -1,4 +1,5 @@
-/** npm: @suchipi/print@2.3.0. License: ISC */
+/** npm: @suchipi/print@2.5.0. License: ISC */
+/* (with some QuickJS-specific modifications) */
 
 /*
 Copyright (c) 2016-2022, John Gardner
@@ -110,6 +111,11 @@ declare interface InspectFunction {
    * @returns A string representation of `value`.
    */
   (value: any, key?: string | symbol, options?: InspectOptions): string;
+
+  /**
+   * A symbol which can be used to customize how an object gets printed.
+   */
+  custom: symbol;
 }
 
 /**
@@ -121,3 +127,18 @@ declare interface InspectFunction {
  * @returns A string representation of `value`.
  */
 declare var inspect: InspectFunction;
+
+declare interface InspectCustomInputs {
+  key: string | symbol;
+  type: string;
+  brackets: [string, string];
+  oneLine: boolean;
+  linesBefore: Array<string>;
+  linesAfter: Array<string>;
+  propLines: Array<string>;
+  readonly tooDeep: boolean;
+  indent: string;
+  typeSuffix: string;
+  opts: InspectOptions;
+  colours: { [Key in keyof Required<InspectColours>]: string };
+}

package/build/dts/quickjs-modulesys.d.ts

@@ -0,0 +1,180 @@
+/**
+ * A global which lets you configure the module loader (import/export/require).
+ * You can use these properties to add support for importing new filetypes.
+ *
+ * This global can also be used to identify whether an object is a module
+ * namespace record.
+ */
+interface ModuleGlobal {
+  /**
+   * Returns true if `target` is a module namespace object.
+   */
+  [Symbol.hasInstance](target: any): target is {
+    [key: string | number | symbol]: any;
+  };
+
+  /**
+   * A list of filetype extensions that may be omitted from an import specifier
+   * string.
+   *
+   * Defaults to `[".js"]`. You can add more strings to this array to
+   * make the engine search for additional files when resolving a
+   * require/import.
+   *
+   * See the doc comment on {@link require} for more information.
+   *
+   * NOTE: If you add a new extension to this array, you will likely also want
+   * to add to {@link Module.compilers}.
+   */
+  searchExtensions: Array<string>;
+
+  /**
+   * User-defined functions which will handle getting the JavaScript code
+   * associated with a module.
+   *
+   * The key for each property in this object should be a file extension
+   * string with a leading dot, eg `".jsx"`. The value for each property should
+   * be a function which receives (1) the filepath to a module, and (2) that
+   * file's content as a UTF-8 string, and the function should return a string
+   * containing JavaScript code that corresponds to that module. In most cases,
+   * these functions will compile the contents of the file from one format into JavaScript.
+   *
+   * The function does not have to use the second 'content' argument it
+   * receives (ie. when loading binary files).
+   *
+   * By adding to this object, you can make it possible to import non-js
+   * filetypes; compile-to-JS languages like JSX, TypeScript, and CoffeeScript
+   * can be compiled at import time, and asset files like .txt files or .png
+   * files can be converted into an appropriate data structure at import time.
+   *
+   * As an example, to make it possible to import .txt files, you might do:
+   * ```js
+   * import * as std from "std";
+   *
+   * Module.compilers[".txt"] = (filename, content) => {
+   *   return `export default ${JSON.stringify(content)}`;
+   * }
+   * ```
+   * (leveraging `JSON.stringify`'s ability to escape quotes).
+   *
+   * Then, later in your code, you can do:
+   * ```js
+   * import names from "./names.txt";
+   * ```
+   *
+   * And `names` will be a string containing the contents of names.txt.
+   *
+   * NOTE: When adding to this object, you may also wish to add to
+   * {@link Module.searchExtensions}.
+   */
+  compilers: {
+    [extensionWithDot: string]: (filename: string, content: string) => string;
+  };
+
+  /**
+   * Create a virtual built-in module whose exports consist of the own
+   * enumerable properties of `obj`.
+   */
+  define(name: string, obj: { [key: string]: any }): void;
+
+  /**
+   * Resolves a require/import request from `fromFile` into a canonicalized path.
+   *
+   * To change native module resolution behavior, replace this function with
+   * your own implementation. Note that you must handle
+   * `Module.searchExtensions` yourself in your replacement implementation.
+   */
+  resolve(name: string, fromFile: string): string;
+
+  /**
+   * Reads the contents of the given resolved module name into a string.
+   *
+   * To change native module loading behavior, replace this function with your
+   * own implementation. Note that you must handle `Module.compilers` yourself
+   * in your replacement implementation.
+   */
+  read(modulePath: string): string;
+}
+
+// global added by QJMS_AddModuleGlobal
+declare var Module: ModuleGlobal;
+
+interface RequireFunction {
+  /**
+   * Synchronously import a module.
+   *
+   * `source` will be resolved relative to the calling file.
+   *
+   * If `source` does not have a file extension, and a file without an extension
+   * cannot be found, the engine will check for files with the extensions in
+   * {@link Module.searchExtensions}, and use one of those if present. This
+   * behavior also happens when using normal `import` statements.
+   *
+   * For example, if you write:
+   *
+   * ```js
+   * import something from "./somewhere";
+   * ```
+   *
+   * but there's no file named `somewhere` in the same directory as the file
+   * where that import appears, and `Module.searchExtensions` is the default
+   * value:
+   *
+   * ```js
+   * [".js"]
+   * ```
+   *
+   * then the engine will look for `somewhere.js`. If that doesn't exist, the
+   * engine will look for `somewhere/index.js`. If *that* doesn't exist, an error
+   * will be thrown.
+   *
+   * If you add more extensions to `Module.searchExtensions`, then the engine
+   * will use those, too. It will search in the same order as the strings appear
+   * in the `Module.searchExtensions` array.
+   */
+  (source: string): any;
+
+  /**
+   * Resolves the normalized path to a modules, relative to the calling file.
+   */
+  resolve: (source: string) => string;
+}
+
+// global added by QJMS_AddRequireGlobal
+declare var require: RequireFunction;
+
+// gets set per-module by QJMS_SetModuleImportMeta
+interface ImportMeta {
+  /**
+   * A URL representing the current module.
+   *
+   * Usually starts with `file://`.
+   */
+  url: string;
+
+  /**
+   * Whether the current module is the "main" module, meaning that it is the
+   * entrypoint file that's been loaded, or, in other terms, the first
+   * user-authored module that's been loaded.
+   */
+  main: boolean;
+
+  /**
+   * Equivalent to `globalThis.require`. Provided for compatibility with tools
+   * that can leverage a CommonJS require function via `import.meta.require`.
+   */
+  require: RequireFunction;
+
+  /**
+   * Resolves a module specifier based on the current module's path.
+   *
+   * Equivalent to `globalThis.require.resolve`.
+   *
+   * Behaves similarly to [the browser import.meta.resolve](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/import.meta/resolve),
+   * but it does not ensure that the returned string is a valid URL, because it
+   * delegates directly to {@link Module.resolve} to resolve the name. If you
+   * want this to return URL strings, change `Module.resolve` and `Module.read`
+   * to work with URL strings.
+   */
+  resolve: RequireFunction["resolve"];
+}

package/build/x86_64-apple-darwin/bin/file-to-bytecode.js

@@ -0,0 +1,27 @@
+#!/usr/bin/env quickjs-run
+
+// Simple script which reads in a file, converts it to bytecode, and writes out
+// the bytecode to a new file.
+
+/// <reference path="../quickjs/quickjs.d.ts" />
+/// <reference path="../quickjs-libc/quickjs-libc.d.ts" />
+/// <reference path="../quickjs-libbytecode/quickjs-libbytecode.d.ts" />
+
+import * as std from "quickjs:std";
+import * as Bytecode from "quickjs:bytecode";
+
+function main() {
+  const [_quickjsRun, _thisScript, inputFile, outputFile] = scriptArgs;
+
+  if (!(inputFile && outputFile)) {
+    throw new Error(
+      "You must pass two positional arguments to this script: the input file path (js) and the output file path (bytecode binary)."
+    );
+  }
+
+  const bytecode = Bytecode.fromFile(inputFile);
+  const out = std.open(outputFile, "wb");
+  out.write(bytecode, 0, bytecode.byteLength);
+}
+
+main();

package/build/x86_64-pc-windows-static/bin/file-to-bytecode.js

@@ -0,0 +1,27 @@
+#!/usr/bin/env quickjs-run
+
+// Simple script which reads in a file, converts it to bytecode, and writes out
+// the bytecode to a new file.
+
+/// <reference path="../quickjs/quickjs.d.ts" />
+/// <reference path="../quickjs-libc/quickjs-libc.d.ts" />
+/// <reference path="../quickjs-libbytecode/quickjs-libbytecode.d.ts" />
+
+import * as std from "quickjs:std";
+import * as Bytecode from "quickjs:bytecode";
+
+function main() {
+  const [_quickjsRun, _thisScript, inputFile, outputFile] = scriptArgs;
+
+  if (!(inputFile && outputFile)) {
+    throw new Error(
+      "You must pass two positional arguments to this script: the input file path (js) and the output file path (bytecode binary)."
+    );
+  }
+
+  const bytecode = Bytecode.fromFile(inputFile);
+  const out = std.open(outputFile, "wb");
+  out.write(bytecode, 0, bytecode.byteLength);
+}
+
+main();

package/build/x86_64-unknown-linux-gnu/bin/file-to-bytecode.js

@@ -0,0 +1,27 @@
+#!/usr/bin/env quickjs-run
+
+// Simple script which reads in a file, converts it to bytecode, and writes out
+// the bytecode to a new file.
+
+/// <reference path="../quickjs/quickjs.d.ts" />
+/// <reference path="../quickjs-libc/quickjs-libc.d.ts" />
+/// <reference path="../quickjs-libbytecode/quickjs-libbytecode.d.ts" />
+
+import * as std from "quickjs:std";
+import * as Bytecode from "quickjs:bytecode";
+
+function main() {
+  const [_quickjsRun, _thisScript, inputFile, outputFile] = scriptArgs;
+
+  if (!(inputFile && outputFile)) {
+    throw new Error(
+      "You must pass two positional arguments to this script: the input file path (js) and the output file path (bytecode binary)."
+    );
+  }
+
+  const bytecode = Bytecode.fromFile(inputFile);
+  const out = std.open(outputFile, "wb");
+  out.write(bytecode, 0, bytecode.byteLength);
+}
+
+main();

package/build/x86_64-unknown-linux-musl/bin/file-to-bytecode.js

@@ -0,0 +1,27 @@
+#!/usr/bin/env quickjs-run
+
+// Simple script which reads in a file, converts it to bytecode, and writes out
+// the bytecode to a new file.
+
+/// <reference path="../quickjs/quickjs.d.ts" />
+/// <reference path="../quickjs-libc/quickjs-libc.d.ts" />
+/// <reference path="../quickjs-libbytecode/quickjs-libbytecode.d.ts" />
+
+import * as std from "quickjs:std";
+import * as Bytecode from "quickjs:bytecode";
+
+function main() {
+  const [_quickjsRun, _thisScript, inputFile, outputFile] = scriptArgs;
+
+  if (!(inputFile && outputFile)) {
+    throw new Error(
+      "You must pass two positional arguments to this script: the input file path (js) and the output file path (bytecode binary)."
+    );
+  }
+
+  const bytecode = Bytecode.fromFile(inputFile);
+  const out = std.open(outputFile, "wb");
+  out.write(bytecode, 0, bytecode.byteLength);
+}
+
+main();

package/build/x86_64-unknown-linux-static/bin/file-to-bytecode.js

@@ -0,0 +1,27 @@
+#!/usr/bin/env quickjs-run
+
+// Simple script which reads in a file, converts it to bytecode, and writes out
+// the bytecode to a new file.
+
+/// <reference path="../quickjs/quickjs.d.ts" />
+/// <reference path="../quickjs-libc/quickjs-libc.d.ts" />
+/// <reference path="../quickjs-libbytecode/quickjs-libbytecode.d.ts" />
+
+import * as std from "quickjs:std";
+import * as Bytecode from "quickjs:bytecode";
+
+function main() {
+  const [_quickjsRun, _thisScript, inputFile, outputFile] = scriptArgs;
+
+  if (!(inputFile && outputFile)) {
+    throw new Error(
+      "You must pass two positional arguments to this script: the input file path (js) and the output file path (bytecode binary)."
+    );
+  }
+
+  const bytecode = Bytecode.fromFile(inputFile);
+  const out = std.open(outputFile, "wb");
+  out.write(bytecode, 0, bytecode.byteLength);
+}
+
+main();

package/npm/cli/qjs.js

@@ -1,4 +1,4 @@
 #!/usr/bin/env node
-const runBinary = require("./run-binary");
+const runBinary = require("../run-binary");
 
 runBinary("qjs");

package/npm/cli/qjsc.js

@@ -1,4 +1,4 @@
 #!/usr/bin/env node
-const runBinary = require("./run-binary");
+const runBinary = require("../run-binary");
 
 runBinary("qjsc");

package/npm/cli/quickjs-run.js

@@ -1,4 +1,4 @@
 #!/usr/bin/env node
-const runBinary = require("./run-binary");
+const runBinary = require("../run-binary");
 
 runBinary("quickjs-run");

package/npm/index.js

@@ -1,54 +1,28 @@
+const fs = require("fs");
 const path = require("path");
 
-exports.buildArtifactsLocation = function buildArtifactsLocation() {
+function buildArtifactsLocation() {
   return path.resolve(__dirname, "..", "build");
-};
+}
+exports.buildArtifactsLocation = buildArtifactsLocation;
 
-exports.identifyCurrentPlatform = function identifyCurrentPlatform() {
-  const platform = process.platform;
-  switch (platform) {
-    case "darwin":
-    case "linux":
-    case "win32": {
-      break;
-    }
-    default: {
-      throw new Error(`Unsupported platform: ${platform}`);
-    }
-  }
+const platforms = require("./platforms.json");
+exports.platforms = platforms;
 
-  /** @type {string} */
-  let arch = process.arch;
-  switch (arch) {
-    case "arm64": {
-      arch = "aarch64";
-      break;
-    }
-    case "x64": {
-      arch = "x86_64";
-      break;
-    }
-    default: {
-      throw new Error(`Unsupported processor architecture: ${arch}`);
-    }
-  }
+function identifyCurrentPlatform() {
+  const matchingPlatform = platforms.find((platform) => {
+    return (
+      platform.os === process.platform &&
+      platform.architectures.includes(process.arch)
+    );
+  });
 
-  switch (platform) {
-    case "darwin": {
-      return `${arch}-apple-darwin`;
-    }
-    case "win32": {
-      if (arch !== "x86_64") {
-        throw new Error(`Architecture is not supported on Windows: ${arch}`);
-      }
-      return `${arch}-pc-windows-static`;
-    }
-    case "linux": {
-      return `${arch}-unknown-linux-static`;
-    }
-    default: {
-      // should be unreachable
-      throw new Error(`Unsupported platform: ${platform}`);
-    }
+  if (matchingPlatform) {
+    return matchingPlatform;
+  } else {
+    throw new Error(
+      `Unsupported platform: ${process.platform}/${process.arch}`
+    );
   }
-};
+}
+exports.identifyCurrentPlatform = identifyCurrentPlatform;

package/npm/platforms.json

@@ -0,0 +1,65 @@
+[
+  {
+    "name": "aarch64-apple-darwin",
+    "architectures": ["aarch64", "arm64"],
+    "os": "darwin",
+    "abi": "",
+    "programSuffix": ""
+  },
+  {
+    "name": "aarch64-unknown-linux-gnu",
+    "architectures": ["aarch64", "arm64"],
+    "os": "linux",
+    "abi": "gnu",
+    "programSuffix": ""
+  },
+  {
+    "name": "aarch64-unknown-linux-musl",
+    "architectures": ["aarch64", "arm64"],
+    "os": "linux",
+    "abi": "musl",
+    "programSuffix": ""
+  },
+  {
+    "name": "aarch64-unknown-linux-static",
+    "architectures": ["aarch64", "arm64"],
+    "os": "linux",
+    "abi": "static",
+    "programSuffix": ""
+  },
+  {
+    "name": "x86_64-apple-darwin",
+    "architectures": ["x86_64", "amd64", "x64"],
+    "os": "darwin",
+    "abi": "",
+    "programSuffix": ""
+  },
+  {
+    "name": "x86_64-pc-windows-static",
+    "architectures": ["x86_64", "amd64", "x64"],
+    "os": "windows",
+    "abi": "",
+    "programSuffix": ".exe"
+  },
+  {
+    "name": "x86_64-unknown-linux-gnu",
+    "architectures": ["x86_64", "amd64", "x64"],
+    "os": "linux",
+    "abi": "gnu",
+    "programSuffix": ""
+  },
+  {
+    "name": "x86_64-unknown-linux-musl",
+    "architectures": ["x86_64", "amd64", "x64"],
+    "os": "linux",
+    "abi": "musl",
+    "programSuffix": ""
+  },
+  {
+    "name": "x86_64-unknown-linux-static",
+    "architectures": ["x86_64", "amd64", "x64"],
+    "os": "linux",
+    "abi": "static",
+    "programSuffix": ""
+  }
+]

package/npm/{cli/run-binary.js → run-binary.js}

@@ -1,15 +1,18 @@
 #!/usr/bin/env node
 const path = require("path");
 const child_process = require("child_process");
-const { identifyCurrentPlatform } = require("..");
+const { identifyCurrentPlatform, buildArtifactsLocation } = require(".");
 
 module.exports = function runBinary(name) {
+  const buildDir = buildArtifactsLocation();
   const platform = identifyCurrentPlatform();
 
-  let bin = path.resolve(__dirname, "..", "..", "build", platform, "bin", name);
-  if (process.platform === "win32") {
-    bin += ".exe";
-  }
+  const bin = path.resolve(
+    buildDir,
+    platform.name,
+    "bin",
+    name + platform.programSuffix
+  );
 
   const argv = process.argv.slice(2);
 

package/package.json

@@ -1,17 +1,18 @@
 {
   "name": "@suchipi/quickjs",
   "description": "Suchipi's QuickJS Fork",
-  "version": "0.3.0",
+  "version": "0.4.1",
   "main": "./npm/index.js",
   "bin": {
-    "qjs": "./npm/cli/qjs.js",
-    "qjsc": "./npm/cli/qjsc.js",
-    "quickjs-run": "./npm/cli/quickjs-run.js"
+    "qjs": "npm/cli/qjs.js",
+    "qjsc": "npm/cli/qjsc.js",
+    "quickjs-run": "npm/cli/quickjs-run.js"
   },
   "devDependencies": {
     "@babel/core": "^7.20.5",
     "@babel/preset-env": "^7.20.2",
     "@babel/preset-typescript": "^7.18.6",
+    "@suchipi/print": "^2.5.0",
     "@suchipi/shinobi": "^0.2.0",
     "@types/jest": "^29.2.4",
     "@types/node": "^18.11.9",
@@ -28,7 +29,10 @@
   },
   "prettier": {},
   "license": "MIT",
-  "repository": "suchipi/quickjs",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/suchipi/quickjs.git"
+  },
   "publishConfig": {
     "access": "public"
   }

package/tsconfig.json

@@ -23,6 +23,7 @@
     "moduleResolution": "node",
     "strictNullChecks": true,
     "esModuleInterop": true,
-    "types": ["jest"]
+    "types": ["jest"],
+    "resolveJsonModule": true
   }
 }