Init

Author: trgwii

.gitignore

@@ -0,0 +1,2 @@
+Deno.js
+test_bundle.js

.vscode/settings.json

@@ -0,0 +1,5 @@
+{
+  "deno.enable": true,
+  "editor.formatOnSave": true,
+  "editor.defaultFormatter": "denoland.vscode-deno"
+}

Deno.ts

@@ -0,0 +1,160 @@
+///<reference no-default-lib="true" />
+///<reference lib="deno.ns" />
+///<reference lib="deno.console" />
+
+import type {} from "./qjs.d.ts";
+import * as std from "std";
+import * as os from "os";
+
+export const args: typeof Deno.args = scriptArgs.slice(1);
+export const mainModule: typeof Deno.mainModule = scriptArgs[0];
+export const noColor: typeof Deno.noColor =
+  typeof std.getenv("NO_COLOR") !== "undefined";
+
+export const exit: typeof Deno.exit = function exit(n) {
+  return std.exit(n ?? 1);
+};
+
+export const build: typeof Deno.build = {
+  target: "",
+  arch: "x86_64",
+  os: "linux",
+  vendor: "unknown",
+  env: "gnu",
+};
+build.target = `${build.arch}-${build.vendor}-${build.os}-${build.env}`;
+
+export const env: typeof Deno.env = {
+  get(key) {
+    return std.getenv(key);
+  },
+  set(key, value) {
+    return std.setenv(key, value);
+  },
+  delete(key) {
+    return std.unsetenv(key);
+  },
+  toObject() {
+    return std.getenviron();
+  },
+};
+
+export const errors: typeof Deno.errors = {
+  NotFound: class NotFound extends Error {},
+  PermissionDenied: class PermissionDenied extends Error {},
+  ConnectionRefused: class ConnectionRefused extends Error {},
+  ConnectionReset: class ConnectionReset extends Error {},
+  ConnectionAborted: class ConnectionAborted extends Error {},
+  NotConnected: class NotConnected extends Error {},
+  AddrInUse: class AddrInUse extends Error {},
+  AddrNotAvailable: class AddrNotAvailable extends Error {},
+  BrokenPipe: class BrokenPipe extends Error {},
+  AlreadyExists: class AlreadyExists extends Error {},
+  InvalidData: class InvalidData extends Error {},
+  TimedOut: class TimedOut extends Error {},
+  Interrupted: class Interrupted extends Error {},
+  WriteZero: class WriteZero extends Error {},
+  UnexpectedEof: class UnexpectedEof extends Error {},
+  BadResource: class BadResource extends Error {},
+  Http: class Http extends Error {},
+  Busy: class Busy extends Error {},
+};
+
+export const readTextFile: typeof Deno.readTextFile =
+  async function readTextFile(path) {
+    const file = std.loadFile(typeof path === "object" ? path.href : path);
+    if (file == null) {
+      throw new errors.NotFound(path + " not found");
+    }
+    return file;
+  };
+
+const files = new Map<number, { path: string; file: std.FILE }>();
+
+export enum SeekMode {
+  Start = 0,
+  Current = 1,
+  End = 2,
+}
+
+export const File: typeof Deno.File = class File
+  implements
+    Deno.Reader,
+    Deno.ReaderSync,
+    Deno.Writer,
+    Deno.WriterSync,
+    Deno.Seeker,
+    Deno.SeekerSync,
+    Deno.Closer {
+  #file: std.FILE;
+  #closed = false;
+  constructor(readonly rid: number) {
+    this.#file = files.get(rid)!.file;
+  }
+  readSync(p: Uint8Array): number | null {
+    if (this.#closed || this.#file.eof()) {
+      return null;
+    }
+    return this.#file.read(p.buffer, p.byteOffset, p.byteLength);
+  }
+  async read(p: Uint8Array): Promise<number | null> {
+    return this.readSync(p);
+  }
+  writeSync(p: Uint8Array): number {
+    const nwritten = this.#file.write(p.buffer, p.byteOffset, p.byteLength);
+    this.#file.flush();
+    return nwritten;
+  }
+  async write(p: Uint8Array): Promise<number> {
+    return this.writeSync(p);
+  }
+  seekSync(offset: number, whence: SeekMode): number {
+    this.#file.seek(
+      offset,
+      whence === SeekMode.Start
+        ? std.SEEK_SET
+        : whence === SeekMode.Current
+        ? std.SEEK_CUR
+        : std.SEEK_END,
+    );
+    return offset;
+  }
+  async seek(offset: number, whence: SeekMode): Promise<number> {
+    return this.seek(offset, whence);
+  }
+  close() {
+    this.#closed = true;
+    this.#file.close();
+    files.delete(this.rid);
+  }
+};
+
+export const open: typeof Deno.open = async function open(path, options) {
+  const file = std.open(
+    path,
+    `${options?.read ? "r" : ""}${
+      options?.write ? (options?.read ? "+" : "w") : ""
+    }`,
+  );
+  files.set(file.fileno(), { path, file });
+  if (file == null) {
+    throw new errors.NotFound(path + " not found");
+  }
+  return new File(file.fileno());
+};
+
+export const stdin: typeof Deno.stdin = {
+  rid: std.in.fileno(),
+  close() {
+    std.in.close();
+  },
+  readSync(p: Uint8Array): number | null {
+    if (std.in.eof()) {
+      return null;
+    }
+    return std.in.read(p.buffer, p.byteOffset, p.byteLength);
+  },
+  async read(p: Uint8Array): Promise<number | null> {
+    return this.readSync(p);
+  },
+};

build.ts

@@ -0,0 +1,7 @@
+console.log(
+  Object.entries(
+    (await Deno.emit(Deno.args[0], {
+      check: false,
+    })).files,
+  ).find(([k, v]) => k.endsWith(".js"))![1],
+);

dev.sh

@@ -0,0 +1,4 @@
+deno run --unstable --allow-read=Deno.ts,qjs.d.ts build.ts Deno.ts > Deno.js
+deno bundle test.js > test_bundle.js
+deno run -A test_bundle.js "$@"
+./qjs --unhandled-rejection test_bundle.js "$@"

qjs.d.ts

@@ -0,0 +1,118 @@
+declare var console: Console;
+declare var print: typeof console["log"];
+declare var scriptArgs: string[];
+
+declare module "std" {
+  export const SEEK_SET: number;
+  export const SEEK_CUR: number;
+  export const SEEK_END: number;
+
+  export interface FILE {
+    /** Close the file. Return 0 if OK or `-errno` in case of I/O error. */
+    close(): number;
+    /** Outputs the string with the UTF-8 encoding. */
+    puts(str: string): void;
+    /** Formatted printf. The same formats as the standard C library `printf` are supported. Integer format types (e.g. `%d`) truncate the Numbers or BigInts to 32 bits. Use the `l` modifier (e.g. `%ld`) to truncate to 64 bits. */
+    printf(fmt: string, ...args: any[]): void;
+
+    /** Flush the buffered file. */
+    flush(): void;
+    /** Seek to a give file position (whence is `std.SEEK_*`). `offset` can be a number or a bigint. Return 0 if OK or `-errno` in case of I/O error. */
+    seek(
+      offset: number | bigint,
+      whence: typeof SEEK_SET | typeof SEEK_CUR | typeof SEEK_END,
+    ): void;
+
+    /** Return the current file position. */
+    tell(): number;
+
+    /** Return the current file position as a bigint. */
+    tello(): bigint;
+
+    /** Return true if end of file. */
+    eof(): boolean;
+
+    /** Return the associated OS handle. */
+    fileno(): number;
+
+    /** Return true if there was an error. */
+    error(): boolean;
+
+    /** Clear the error indication. */
+    clearerr(): void;
+
+    /** Read `length` bytes from the file to the ArrayBuffer `buffer` at byte position `position` (wrapper to the libc `fread`). */
+    read(buffer: ArrayBuffer, position: number, length: number): number;
+
+    /** Write `length` bytes to the file from the ArrayBuffer `buffer` at byte position `position` (wrapper to the libc `fwrite`). */
+    write(buffer: ArrayBuffer, position: number, length: number): number;
+
+    /** Return the next line from the file, assuming UTF-8 encoding, excluding the trailing line feed. */
+    getline(): string;
+
+    /** Read `max_size` bytes from the file and return them as a string assuming UTF-8 encoding. If `max_size` is not present, the file is read up its end. */
+    readAsString(max_size?: number): string;
+
+    /** Return the next byte from the file. Return -1 if the end of file is reached. */
+    getByte(): number;
+
+    /** Write one byte to the file. */
+    putByte(c: number): void;
+  }
+
+  /** Exit the process. */
+  export function exit(n: number): never;
+
+  /** Load the file `filename` and return it as a string assuming UTF-8 encoding. Return `null` in case of I/O error. */
+  export function loadFile(filename: string): string | null;
+
+  /** Open a file (wrapper to the libc `fopen()`). Return the FILE object or `null` in case of I/O error. If `errorObj` is not undefined, set its `errno` property to the error code or to 0 if no error occured. */
+  export function open(
+    filename: string,
+    flags: string,
+    errorObj?: { errno?: number },
+  ): FILE;
+
+  /** Open a file from a file handle (wrapper to the libc `fdopen()`). Return the FILE object or `null` in case of I/O error. If `errorObj` is not undefined, set its `errno` property to the error code or to 0 if no error occured. */
+  export function fdopen(
+    fd: number,
+    flags: string,
+    errorObj?: { errno?: number },
+  ): FILE;
+
+  const In: FILE;
+  export { In as in };
+  export const out: FILE;
+  export const err: FILE;
+
+  /** Return the value of the environment variable `name` or `undefined` if it is not defined. */
+  export function getenv(name: string): string | undefined;
+  /** Set the value of the environment variable `name` to the string `value`. */
+  export function setenv(name: string, value: string): void;
+  /** Delete the environment variable `name`. */
+  export function unsetenv(name: string): void;
+  /** Return an object containing the environment variables as key-value pairs. */
+  export function getenviron(): Record<string, string>;
+  /** Download url using the curl command line utility. */
+  export function urlGet<Full extends boolean = false>(
+    url: string,
+    options?: {
+      /** Boolean (default = false). If true, the response is an ArrayBuffer instead of a string. When a string is returned, the data is assumed to be UTF-8 encoded. */
+      binary?: boolean;
+      /** Boolean (default = false). If true, return the an object contains the properties `response` (response content), `responseHeaders` (headers separated by CRLF), `status` (status code). `response` is `null` is case of protocol or network error. If `full` is false, only the response is returned if the status is between 200 and 299. Otherwise `null` is returned. */
+      full?: Full;
+    },
+  ): Full extends true ? {
+    /** response content */
+    response: string;
+    /** headers separated by CRLF */
+    responseHeaders: Record<string, string>;
+    /** status code */
+    status: number;
+  }
+    : string | null;
+}
+
+declare module "os" {
+  export function chdir(path: string): number;
+}

test.js

@@ -0,0 +1,20 @@
+import {
+  iterateReader,
+  writeAll,
+} from "https://deno.land/[email protected]/streams/conversion.ts";
+
+(async () => {
+  // code to conditionally import deno.qjs
+  // #region
+  /** @type {typeof globalThis.Deno} */
+  const Deno = "Deno" in globalThis
+    ? globalThis.Deno
+    : await import("./Deno.js");
+  "Deno" in globalThis || (globalThis.Deno = Deno);
+  // #endregion
+
+  const file = await Deno.open("test.txt", { write: true });
+  for await (const buf of iterateReader(Deno.stdin, { bufSize: 10 })) {
+    await writeAll(file, buf);
+  }
+})();