deno.land / x / deno@v1.28.2 / core / 01_core.js
نووسراو ببینە
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license."use strict";
((window) => { const { Error, RangeError, ReferenceError, SyntaxError, TypeError, URIError, Map, Array, ArrayPrototypeFill, ArrayPrototypePush, ArrayPrototypeMap, ErrorCaptureStackTrace, Promise, ObjectFromEntries, MapPrototypeGet, MapPrototypeHas, MapPrototypeDelete, MapPrototypeSet, PromisePrototypeThen, PromisePrototypeFinally, StringPrototypeSlice, ObjectAssign, SymbolFor, setQueueMicrotask, } = window.__bootstrap.primordials; const { ops } = window.Deno.core;
const errorMap = {}; // Builtin v8 / JS errors registerErrorClass("Error", Error); registerErrorClass("RangeError", RangeError); registerErrorClass("ReferenceError", ReferenceError); registerErrorClass("SyntaxError", SyntaxError); registerErrorClass("TypeError", TypeError); registerErrorClass("URIError", URIError);
let nextPromiseId = 1; const promiseMap = new Map(); const RING_SIZE = 4 * 1024; const NO_PROMISE = null; // Alias to null is faster than plain nulls const promiseRing = ArrayPrototypeFill(new Array(RING_SIZE), NO_PROMISE); // TODO(bartlomieju): it future use `v8::Private` so it's not visible // to users. Currently missing bindings. const promiseIdSymbol = SymbolFor("Deno.core.internalPromiseId");
let opCallTracingEnabled = false; const opCallTraces = new Map();
function enableOpCallTracing() { opCallTracingEnabled = true; }
function isOpCallTracingEnabled() { return opCallTracingEnabled; }
function setPromise(promiseId) { const idx = promiseId % RING_SIZE; // Move old promise from ring to map const oldPromise = promiseRing[idx]; if (oldPromise !== NO_PROMISE) { const oldPromiseId = promiseId - RING_SIZE; MapPrototypeSet(promiseMap, oldPromiseId, oldPromise); } // Set new promise return promiseRing[idx] = newPromise(); }
function getPromise(promiseId) { // Check if out of ring bounds, fallback to map const outOfBounds = promiseId < nextPromiseId - RING_SIZE; if (outOfBounds) { const promise = MapPrototypeGet(promiseMap, promiseId); MapPrototypeDelete(promiseMap, promiseId); return promise; } // Otherwise take from ring const idx = promiseId % RING_SIZE; const promise = promiseRing[idx]; promiseRing[idx] = NO_PROMISE; return promise; }
function newPromise() { let resolve, reject; const promise = new Promise((resolve_, reject_) => { resolve = resolve_; reject = reject_; }); promise.resolve = resolve; promise.reject = reject; return promise; }
function hasPromise(promiseId) { // Check if out of ring bounds, fallback to map const outOfBounds = promiseId < nextPromiseId - RING_SIZE; if (outOfBounds) { return MapPrototypeHas(promiseMap, promiseId); } // Otherwise check it in ring const idx = promiseId % RING_SIZE; return promiseRing[idx] != NO_PROMISE; }
function opresolve() { for (let i = 0; i < arguments.length; i += 2) { const promiseId = arguments[i]; const res = arguments[i + 1]; const promise = getPromise(promiseId); promise.resolve(res); } }
function registerErrorClass(className, errorClass) { registerErrorBuilder(className, (msg) => new errorClass(msg)); }
function registerErrorBuilder(className, errorBuilder) { if (typeof errorMap[className] !== "undefined") { throw new TypeError(`Error class for "${className}" already registered`); } errorMap[className] = errorBuilder; }
function buildCustomError(className, message, code) { const error = errorMap[className]?.(message); // Strip buildCustomError() calls from stack trace if (typeof error == "object") { ErrorCaptureStackTrace(error, buildCustomError); if (code) { error.code = code; } } return error; }
function unwrapOpResult(res) { // .$err_class_name is a special key that should only exist on errors if (res?.$err_class_name) { const className = res.$err_class_name; const errorBuilder = errorMap[className]; const err = errorBuilder ? errorBuilder(res.message) : new Error( `Unregistered error class: "${className}"\n ${res.message}\n Classes of errors returned from ops should be registered via Deno.core.registerErrorClass().`, ); // Set .code if error was a known OS error, see error_codes.rs if (res.code) { err.code = res.code; } // Strip unwrapOpResult() and errorBuilder() calls from stack trace ErrorCaptureStackTrace(err, unwrapOpResult); throw err; } return res; }
function rollPromiseId() { return nextPromiseId++; }
// Generate async op wrappers. See core/bindings.rs function initializeAsyncOps() { function genAsyncOp(op, name, args) { return new Function( "setPromise", "getPromise", "promiseIdSymbol", "rollPromiseId", "handleOpCallTracing", "op", "unwrapOpResult", "PromisePrototypeThen", ` return function ${name}(${args}) { const id = rollPromiseId(); let promise = PromisePrototypeThen(setPromise(id), unwrapOpResult); try { op(id, ${args}); } catch (err) { // Cleanup the just-created promise getPromise(id); // Rethrow the error throw err; } handleOpCallTracing("${name}", id, promise); promise[promiseIdSymbol] = id; return promise; } `, )( setPromise, getPromise, promiseIdSymbol, rollPromiseId, handleOpCallTracing, op, unwrapOpResult, PromisePrototypeThen, ); }
// { <name>: <argc>, ... } for (const ele of Object.entries(ops.asyncOpsInfo())) { if (!ele) continue; const [name, argc] = ele; const op = ops[name]; const args = Array.from({ length: argc }, (_, i) => `arg${i}`).join(", "); ops[name] = genAsyncOp(op, name, args); } }
function handleOpCallTracing(opName, promiseId, p) { if (opCallTracingEnabled) { const stack = StringPrototypeSlice(new Error().stack, 6); MapPrototypeSet(opCallTraces, promiseId, { opName, stack }); p = PromisePrototypeFinally( p, () => MapPrototypeDelete(opCallTraces, promiseId), ); } }
function opAsync(opName, ...args) { return ops[opName](...args); }
function refOp(promiseId) { if (!hasPromise(promiseId)) { return; } ops.op_ref_op(promiseId); }
function unrefOp(promiseId) { if (!hasPromise(promiseId)) { return; } ops.op_unref_op(promiseId); }
function resources() { return ObjectFromEntries(ops.op_resources()); }
function metrics() { const [aggregate, perOps] = ops.op_metrics(); aggregate.ops = ObjectFromEntries(ArrayPrototypeMap( ops.op_op_names(), (opName, opId) => [opName, perOps[opId]], )); return aggregate; }
let reportExceptionCallback = undefined;
// Used to report errors thrown from functions passed to `queueMicrotask()`. // The callback will be passed the thrown error. For example, you can use this // to dispatch an error event to the global scope. // In other words, set the implementation for // https://html.spec.whatwg.org/multipage/webappapis.html#report-the-exception function setReportExceptionCallback(cb) { if (typeof cb != "function") { throw new TypeError("expected a function"); } reportExceptionCallback = cb; }
function queueMicrotask(cb) { if (typeof cb != "function") { throw new TypeError("expected a function"); } return ops.op_queue_microtask(() => { try { cb(); } catch (error) { if (reportExceptionCallback) { reportExceptionCallback(error); } else { throw error; } } }); }
// Some "extensions" rely on "BadResource" and "Interrupted" errors in the // JS code (eg. "deno_net") so they are provided in "Deno.core" but later // reexported on "Deno.errors" class BadResource extends Error { constructor(msg) { super(msg); this.name = "BadResource"; } } const BadResourcePrototype = BadResource.prototype;
class Interrupted extends Error { constructor(msg) { super(msg); this.name = "Interrupted"; } } const InterruptedPrototype = Interrupted.prototype;
const promiseHooks = { init: [], before: [], after: [], resolve: [], hasBeenSet: false, };
function setPromiseHooks(init, before, after, resolve) { if (init) ArrayPrototypePush(promiseHooks.init, init); if (before) ArrayPrototypePush(promiseHooks.before, before); if (after) ArrayPrototypePush(promiseHooks.after, after); if (resolve) ArrayPrototypePush(promiseHooks.resolve, resolve);
if (!promiseHooks.hasBeenSet) { promiseHooks.hasBeenSet = true;
ops.op_set_promise_hooks((promise, parentPromise) => { for (let i = 0; i < promiseHooks.init.length; ++i) { promiseHooks.init[i](promise, parentPromise); } }, (promise) => { for (let i = 0; i < promiseHooks.before.length; ++i) { promiseHooks.before[i](promise); } }, (promise) => { for (let i = 0; i < promiseHooks.after.length; ++i) { promiseHooks.after[i](promise); } }, (promise) => { for (let i = 0; i < promiseHooks.resolve.length; ++i) { promiseHooks.resolve[i](promise); } }); } }
// Extra Deno.core.* exports const core = ObjectAssign(globalThis.Deno.core, { opAsync, initializeAsyncOps, resources, metrics, registerErrorBuilder, registerErrorClass, buildCustomError, opresolve, BadResource, BadResourcePrototype, Interrupted, InterruptedPrototype, enableOpCallTracing, isOpCallTracingEnabled, opCallTraces, refOp, unrefOp, setReportExceptionCallback, setPromiseHooks, close: (rid) => ops.op_close(rid), tryClose: (rid) => ops.op_try_close(rid), read: (rid, buffer) => ops.op_read(rid, buffer), readAll: (rid) => ops.op_read_all(rid), write: (rid, buffer) => ops.op_write(rid, buffer), writeAll: (rid, buffer) => ops.op_write_all(rid, buffer), shutdown: (rid) => ops.op_shutdown(rid), print: (msg, isErr) => ops.op_print(msg, isErr), setMacrotaskCallback: (fn) => ops.op_set_macrotask_callback(fn), setNextTickCallback: (fn) => ops.op_set_next_tick_callback(fn), runMicrotasks: () => ops.op_run_microtasks(), hasTickScheduled: () => ops.op_has_tick_scheduled(), setHasTickScheduled: (bool) => ops.op_set_has_tick_scheduled(bool), evalContext: ( source, specifier, ) => ops.op_eval_context(source, specifier), createHostObject: () => ops.op_create_host_object(), encode: (text) => ops.op_encode(text), decode: (buffer) => ops.op_decode(buffer), serialize: ( value, options, errorCallback, ) => ops.op_serialize(value, options, errorCallback), deserialize: (buffer, options) => ops.op_deserialize(buffer, options), getPromiseDetails: (promise) => ops.op_get_promise_details(promise), getProxyDetails: (proxy) => ops.op_get_proxy_details(proxy), isProxy: (value) => ops.op_is_proxy(value), memoryUsage: () => ops.op_memory_usage(), setWasmStreamingCallback: (fn) => ops.op_set_wasm_streaming_callback(fn), abortWasmStreaming: ( rid, error, ) => ops.op_abort_wasm_streaming(rid, error), destructureError: (error) => ops.op_destructure_error(error), opNames: () => ops.op_op_names(), eventLoopHasMoreWork: () => ops.op_event_loop_has_more_work(), setPromiseRejectCallback: (fn) => ops.op_set_promise_reject_callback(fn), byteLength: (str) => ops.op_str_byte_length(str), });
ObjectAssign(globalThis.__bootstrap, { core }); ObjectAssign(globalThis.Deno, { core });
// Direct bindings on `globalThis` ObjectAssign(globalThis, { queueMicrotask }); setQueueMicrotask(queueMicrotask);})(globalThis);
deno
Version Info
a year ago
