@boristype/runtime 0.1.0-alpha.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 BorisType
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/build/.executables.json

@@ -0,0 +1 @@
+[]

package/build/cache/index.js

@@ -0,0 +1,14 @@
+var storage = {};
+function set(key, value) {
+    storage.SetProperty(key, value);
+    return value;
+}
+function get(key) {
+    return storage.GetOptProperty(key);
+}
+function has(key) {
+    return storage.HasProperty(key);
+}
+function init() {
+    storage = SafeObject();
+}

package/build/cache.js

@@ -0,0 +1,8 @@
+"META:NAMESPACE:bt";
+var cache = {};
+function init_cache() {
+    var cacheLibrary;
+    cacheLibrary = OpenCodeLibrary("./cache/index.js");
+    cacheLibrary.init();
+    cache = cacheLibrary;
+}

package/build/destructuring.js

@@ -0,0 +1,22 @@
+"META:NAMESPACE:bt";
+function object_rest(obj, exclude) {
+    var newObj;
+    var key;
+    newObj = {};
+    for (key in obj) {
+        if (exclude.indexOf(key) >= 0) {
+            continue;
+        }
+        newObj.SetProperty(key, obj.GetProperty(key));
+    }
+    return newObj;
+}
+function array_rest(arr, start) {
+    var newArr;
+    var i;
+    newArr = [];
+    for (i = start; i < arr.length; i++) {
+        newArr.push(arr[i]);
+    }
+    return newArr;
+}

package/build/filemap.js

@@ -0,0 +1,15 @@
+"META:NAMESPACE:bt";
+var fileMap = {};
+function getFileUrl(fileKey) {
+    return fileMap.GetOptProperty(fileKey);
+}
+function loadFileMap(fileMapFileUrl) {
+    var fileMapContent;
+    var fileMapJson;
+    var fileKey;
+    fileMapContent = LoadUrlText(fileMapFileUrl);
+    fileMapJson = ParseJson(fileMapContent);
+    for (fileKey in fileMapJson) {
+        fileMap.SetProperty(fileKey, fileMapJson.GetProperty(fileKey));
+    }
+}

package/build/init.js

@@ -0,0 +1,24 @@
+var LOG_CODE = "bt-runtime";
+EnableLog(LOG_CODE, true);
+try {
+    RegisterCodeLibrary("./polyfill.js");
+    RegisterCodeLibrary("./semantic.js");
+    RegisterCodeLibrary("./destructuring.js");
+    RegisterCodeLibrary("./require.js");
+    RegisterCodeLibrary("./cache.js");
+    bt.init_polyfill();
+    bt.init_require();
+    bt.init_cache();
+    LogEvent(LOG_CODE, "INFO:     bt:runtime module registration success");
+    alert("[bt:runtime]  INFO:      bt:runtime module registration success");
+}
+catch (err) {
+    LogEvent(LOG_CODE, "ERROR:    bt:runtime module registration failed: " + err);
+    alert("[bt:runtime]  ERROR:     bt:runtime module registration failed: " + err);
+}
+function test() {
+    alert("hello world");
+    function govno() {
+    }
+    alert("test");
+}

package/build/package.json

@@ -0,0 +1,11 @@
+{
+  "name": "bt-runtime",
+  "version": "0.0.1.1001",
+  "description": "bt-runtime",
+  "enableByDefault": true,
+  "dependencies": {},
+  "type": "standard",
+  "tags": [
+    "#public"
+  ]
+}

package/build/polyfill/Array.js

@@ -0,0 +1,550 @@
+function at(array, index) {
+    var len;
+    var normalizedIndex;
+    var positiveIndex;
+    len = ArrayCount(array);
+    normalizedIndex = Int(index);
+    if (normalizedIndex < 0) {
+        positiveIndex = len + normalizedIndex;
+        return positiveIndex >= 0 ? array[positiveIndex] : undefined;
+    }
+    return normalizedIndex < len ? array[normalizedIndex] : undefined;
+}
+function copyWithin(array, target, start, end) {
+    var len;
+    var to;
+    var from;
+    var final;
+    var normalizedTarget;
+    var normalizedStart;
+    var normalizedEnd;
+    var count;
+    var i;
+    len = ArrayCount(array);
+    to = Int(target);
+    from = Int(start);
+    final = OptInt(end) ? Int(end) : len;
+    normalizedTarget = to < 0 ? Max(len + to, 0) : Min(to, len);
+    normalizedStart = from < 0 ? Max(len + from, 0) : Min(from, len);
+    normalizedEnd = final < 0 ? Max(len + final, 0) : Min(final, len);
+    count = Min(normalizedEnd - normalizedStart, len - normalizedTarget);
+    if (count > 0) {
+        if ((normalizedStart < normalizedTarget) && (normalizedTarget < (normalizedStart + count))) {
+            for (i = count - 1; i >= 0; i--) {
+                array[normalizedTarget + i] = array[normalizedStart + i];
+            }
+        }
+        else {
+            for (i = 0; i < count; i++) {
+                array[normalizedTarget + i] = array[normalizedStart + i];
+            }
+        }
+    }
+    return array;
+}
+function entries(array) {
+    var result;
+    var i;
+    result = [];
+    for (i = 0; i < ArrayCount(array); i++) {
+        result.push([i, array[i]]);
+    }
+    return result;
+}
+function every(array, callback) {
+    var len;
+    var i;
+    var value;
+    var likeBoolResult;
+    len = ArrayCount(array);
+    for (i = 0; i < len; i++) {
+        value = array[i];
+        likeBoolResult = bt.callFunction(callback, [value, i, array]);
+        if ((((((likeBoolResult === false) || (likeBoolResult === 0)) || (likeBoolResult === -0)) || (likeBoolResult === "")) || (likeBoolResult === null)) || (likeBoolResult === undefined)) {
+            return false;
+        }
+    }
+    return true;
+}
+function fill(array, value, start, end) {
+    var len;
+    var normalizedStart;
+    var normalizedEnd;
+    var from;
+    var to;
+    var i;
+    len = ArrayCount(array);
+    normalizedStart = start === undefined ? 0 : Int(start);
+    normalizedEnd = end === undefined ? len : Int(end);
+    from = normalizedStart < 0 ? Max(len + normalizedStart, 0) : Min(normalizedStart, len);
+    to = normalizedEnd < 0 ? Max(len + normalizedEnd, 0) : Min(normalizedEnd, len);
+    for (i = from; i < to; i++) {
+        array[i] = value;
+    }
+    return array;
+}
+function filter(array, callback) {
+    var result;
+    var len;
+    var i;
+    var value;
+    var likeBoolResult;
+    result = [];
+    len = ArrayCount(array);
+    for (i = 0; i < len; i++) {
+        value = array[i];
+        likeBoolResult = bt.callFunction(callback, [value, i, array]);
+        if (!((((((likeBoolResult === false) || (likeBoolResult === 0)) || (likeBoolResult === -0)) || (likeBoolResult === "")) || (likeBoolResult === null)) || (likeBoolResult === undefined))) {
+            result.push(value);
+        }
+    }
+    return result;
+}
+function find(array, callback) {
+    var len;
+    var i;
+    var value;
+    var likeBoolResult;
+    len = ArrayCount(array);
+    for (i = 0; i < len; i++) {
+        value = array[i];
+        likeBoolResult = bt.callFunction(callback, [value, i, array]);
+        if (!((((((likeBoolResult === false) || (likeBoolResult === 0)) || (likeBoolResult === -0)) || (likeBoolResult === "")) || (likeBoolResult === null)) || (likeBoolResult === undefined))) {
+            return value;
+        }
+    }
+    return undefined;
+}
+function findIndex(array, callback) {
+    var len;
+    var i;
+    var value;
+    var likeBoolResult;
+    len = ArrayCount(array);
+    for (i = 0; i < len; i++) {
+        value = array[i];
+        likeBoolResult = bt.callFunction(callback, [value, i, array]);
+        if (!((((((likeBoolResult === false) || (likeBoolResult === 0)) || (likeBoolResult === -0)) || (likeBoolResult === "")) || (likeBoolResult === null)) || (likeBoolResult === undefined))) {
+            return i;
+        }
+    }
+    return -1;
+}
+function findLast(array, callback) {
+    var len;
+    var i;
+    var value;
+    var likeBoolResult;
+    len = ArrayCount(array);
+    for (i = len - 1; i >= 0; i--) {
+        value = array[i];
+        likeBoolResult = bt.callFunction(callback, [value, i, array]);
+        if (!((((((likeBoolResult === false) || (likeBoolResult === 0)) || (likeBoolResult === -0)) || (likeBoolResult === "")) || (likeBoolResult === null)) || (likeBoolResult === undefined))) {
+            return value;
+        }
+    }
+    return undefined;
+}
+function findLastIndex(array, callback) {
+    var len;
+    var i;
+    var value;
+    var likeBoolResult;
+    len = ArrayCount(array);
+    for (i = len - 1; i >= 0; i--) {
+        value = array[i];
+        likeBoolResult = bt.callFunction(callback, [value, i, array]);
+        if (!((((((likeBoolResult === false) || (likeBoolResult === 0)) || (likeBoolResult === -0)) || (likeBoolResult === "")) || (likeBoolResult === null)) || (likeBoolResult === undefined))) {
+            return i;
+        }
+    }
+    return -1;
+}
+function flat(array, depth) {
+    var result;
+    var i;
+    var value;
+    var flattened;
+    var __item0;
+    var item;
+    depth = depth === undefined ? 1 : Int(depth);
+    result = [];
+    for (i = 0; i < ArrayCount(array); i++) {
+        value = array[i];
+        if (IsArray(value) && (depth > 0)) {
+            flattened = flat(value, depth - 1);
+            for (__item0 in flattened) {
+                item = __item0;
+                result.push(item);
+            }
+        }
+        else {
+            result.push(value);
+        }
+    }
+    return result;
+}
+function flatMap(array, callback) {
+    var result;
+    var len;
+    var i;
+    var value;
+    var mapped;
+    var __item1;
+    var item;
+    result = [];
+    len = ArrayCount(array);
+    for (i = 0; i < len; i++) {
+        value = array[i];
+        mapped = bt.callFunction(callback, [value, i, array]);
+        if (IsArray(mapped)) {
+            for (__item1 in mapped) {
+                item = __item1;
+                result.push(item);
+            }
+        }
+        else {
+            result.push(mapped);
+        }
+    }
+    return result;
+}
+function forEach(array, callback) {
+    var len;
+    var i;
+    var value;
+    len = ArrayCount(array);
+    for (i = 0; i < len; i++) {
+        value = array[i];
+        bt.callFunction(callback, [value, i, array]);
+    }
+    return;
+}
+function includes(array, searchElement, fromIndex) {
+    var from;
+    var len;
+    var startIndex;
+    var i;
+    from = fromIndex === undefined ? 0 : Int(fromIndex);
+    len = ArrayCount(array);
+    startIndex = from >= 0 ? from : Max(len + from, 0);
+    for (i = startIndex; i < len; i++) {
+        if (array[i] === searchElement) {
+            return true;
+        }
+    }
+    return false;
+}
+function indexOf(array, searchElement, fromIndex) {
+    var from;
+    var len;
+    var startIndex;
+    var i;
+    from = fromIndex === undefined ? 0 : Int(fromIndex);
+    len = ArrayCount(array);
+    startIndex = from >= 0 ? from : Max(len + from, 0);
+    for (i = startIndex; i < len; i++) {
+        if (array[i] === searchElement) {
+            return i;
+        }
+    }
+    return -1;
+}
+function join(array, separator) {
+    var result;
+    var len;
+    var i;
+    separator = separator === undefined ? "," : separator;
+    result = "";
+    len = ArrayCount(array);
+    for (i = 0; i < len; i++) {
+        result += array[i];
+        if (i < (len - 1)) {
+            result += separator;
+        }
+    }
+    return result;
+}
+function keys(array) {
+    var result;
+    var i;
+    result = [];
+    for (i = 0; i < ArrayCount(array); i++) {
+        result.push(i);
+    }
+    return result;
+}
+function lastIndexOf(array, searchElement, fromIndex) {
+    var len;
+    var from;
+    var startIndex;
+    var i;
+    len = ArrayCount(array);
+    from = fromIndex === undefined ? len - 1 : Int(fromIndex);
+    startIndex = from >= 0 ? Min(from, len - 1) : len + from;
+    for (i = startIndex; i >= 0; i--) {
+        if (array[i] === searchElement) {
+            return i;
+        }
+    }
+    return -1;
+}
+function map(array, callback) {
+    var result;
+    var len;
+    var i;
+    var value;
+    var mapped;
+    result = [];
+    len = ArrayCount(array);
+    for (i = 0; i < len; i++) {
+        value = array[i];
+        mapped = bt.callFunction(callback, [value, i, array]);
+        result.push(mapped);
+    }
+    return result;
+}
+function pop(array) {
+    var len;
+    var value;
+    len = ArrayCount(array);
+    if (len === 0) {
+        return undefined;
+    }
+    value = array[len - 1];
+    array.splice(len - 1, 1);
+    return value;
+}
+function push(array, other) {
+    var __item2;
+    var item;
+    for (__item2 in other) {
+        item = __item2;
+        array.push(item);
+    }
+}
+function reduce(array, callback, initialValue) {
+    var len;
+    var accumulator;
+    var startIndex;
+    var i;
+    var value;
+    len = ArrayCount(array);
+    accumulator = undefined;
+    startIndex = undefined;
+    if (initialValue !== undefined) {
+        accumulator = initialValue;
+        startIndex = 0;
+    }
+    else {
+        if (len === 0) {
+            throw "Reduce of empty array with no initial value";
+        }
+        accumulator = array[0];
+        startIndex = 1;
+    }
+    for (i = startIndex; i < len; i++) {
+        value = array[i];
+        accumulator = bt.callFunction(callback, [accumulator, value, i, array]);
+    }
+    return accumulator;
+}
+function reduceRight(array, callback, initialValue) {
+    var len;
+    var accumulator;
+    var startIndex;
+    var i;
+    var value;
+    len = ArrayCount(array);
+    accumulator = undefined;
+    startIndex = undefined;
+    if (initialValue !== undefined) {
+        accumulator = initialValue;
+        startIndex = (len - 1);
+    }
+    else {
+        if (len === 0) {
+            throw "Reduce of empty array with no initial value";
+        }
+        accumulator = array[len - 1];
+        startIndex = (len - 2);
+    }
+    for (i = startIndex; i >= 0; i--) {
+        value = array[i];
+        accumulator = bt.callFunction(callback, [accumulator, value, i, array]);
+    }
+    return accumulator;
+}
+function reverse(array) {
+    var len;
+    var mid;
+    var i;
+    var oppositeIndex;
+    var temp;
+    len = ArrayCount(array);
+    mid = Int(len / 2);
+    for (i = 0; i < mid; i++) {
+        oppositeIndex = (len - i) - 1;
+        temp = array[i];
+        array[i] = array[oppositeIndex];
+        array[oppositeIndex] = temp;
+    }
+    return array;
+}
+function shift(array) {
+    var len;
+    var value;
+    len = ArrayCount(array);
+    if (len === 0) {
+        return undefined;
+    }
+    value = array[0];
+    array.splice(0, 1);
+    return value;
+}
+function slice(array, start, end) {
+    var len;
+    var normalizedStart;
+    var normalizedEnd;
+    var from;
+    var to;
+    var result;
+    var i;
+    len = ArrayCount(array);
+    normalizedStart = start === undefined ? 0 : Int(start);
+    normalizedEnd = end === undefined ? len : Int(end);
+    from = normalizedStart < 0 ? Max(len + normalizedStart, 0) : Min(normalizedStart, len);
+    to = normalizedEnd < 0 ? Max(len + normalizedEnd, 0) : Min(normalizedEnd, len);
+    result = [];
+    for (i = from; i < to; i++) {
+        result.push(array[i]);
+    }
+    return result;
+}
+function some(array, callback) {
+    var len;
+    var i;
+    var value;
+    var likeBoolResult;
+    len = ArrayCount(array);
+    for (i = 0; i < len; i++) {
+        value = array[i];
+        likeBoolResult = bt.callFunction(callback, [value, i, array]);
+        if (!((((((likeBoolResult === false) || (likeBoolResult === 0)) || (likeBoolResult === -0)) || (likeBoolResult === "")) || (likeBoolResult === null)) || (likeBoolResult === undefined))) {
+            return true;
+        }
+    }
+    return false;
+}
+function sort(array, compareFn) {
+    throw "Array.sort polyfill is not implemented yet";
+}
+function splice(array, start, deleteCount, items) {
+    var len;
+    var normalizedStart;
+    var normalizedDeleteCount;
+    var removed;
+    var i;
+    var newLength;
+    var delta;
+    deleteCount = deleteCount === undefined ? ArrayCount(array) - start : Int(deleteCount);
+    len = ArrayCount(array);
+    normalizedStart = start < 0 ? Max(len + start, 0) : Min(start, len);
+    normalizedDeleteCount = Min(deleteCount, len - normalizedStart);
+    removed = [];
+    for (i = 0; i < normalizedDeleteCount; i++) {
+        removed.push(array[normalizedStart + i]);
+    }
+    for (i = normalizedStart; i < (len - normalizedDeleteCount); i++) {
+        array[i] = array[i + normalizedDeleteCount];
+    }
+    for (i = (len - normalizedDeleteCount) - 1; i >= normalizedStart; i--) {
+        array[i + items.length] = array[i];
+    }
+    for (i = 0; i < items.length; i++) {
+        array[normalizedStart + i] = items[i];
+    }
+    newLength = (len - normalizedDeleteCount) + items.length;
+    delta = ArrayCount(array) - newLength;
+    array.splice(((len - normalizedDeleteCount) + items.length), delta);
+    return removed;
+}
+function toReversed(array) {
+    var len;
+    var result;
+    var i;
+    len = ArrayCount(array);
+    result = [];
+    for (i = 0; i < len; i++) {
+        result[i] = array[(len - i) - 1];
+    }
+    return result;
+}
+function toSorted(array, compareFn) {
+    throw "Array.toSorted polyfill is not implemented yet";
+}
+function toSpliced(array, start, deleteCount, items) {
+    var len;
+    var normalizedStart;
+    var normalizedDeleteCount;
+    var result;
+    var i;
+    var __item3;
+    var item;
+    deleteCount = deleteCount === undefined ? ArrayCount(array) - start : Int(deleteCount);
+    len = ArrayCount(array);
+    normalizedStart = start < 0 ? Max(len + start, 0) : Min(start, len);
+    normalizedDeleteCount = Min(deleteCount, len - normalizedStart);
+    result = [];
+    for (i = 0; i < normalizedStart; i++) {
+        result.push(array[i]);
+    }
+    for (__item3 in items) {
+        item = __item3;
+        result.push(item);
+    }
+    for (i = normalizedStart + normalizedDeleteCount; i < len; i++) {
+        result.push(array[i]);
+    }
+    return result;
+}
+function unshift(array, items) {
+    var len;
+    var i;
+    len = ArrayCount(array);
+    for (i = len - 1; i >= 0; i--) {
+        array[i + items.length] = array[i];
+    }
+    for (i = 0; i < items.length; i++) {
+        array[i] = items[i];
+    }
+    return len + ArrayCount(items);
+}
+function values(array) {
+    return ArraySelectAll(array);
+}
+function _with(array, index, value) {
+    var len;
+    var normalizedIndex;
+    var result;
+    var i;
+    var positiveIndex;
+    len = ArrayCount(array);
+    normalizedIndex = Int(index);
+    result = [];
+    for (i = 0; i < len; i++) {
+        result[i] = array[i];
+    }
+    if (normalizedIndex < 0) {
+        positiveIndex = len + normalizedIndex;
+        if (positiveIndex >= 0) {
+            result[positiveIndex] = value;
+        }
+    }
+    else {
+        if (normalizedIndex < len) {
+            result[normalizedIndex] = value;
+        }
+    }
+    return result;
+}

package/build/polyfill/Math.js

@@ -0,0 +1,37 @@
+function abs(num) {
+    if (num < 0) {
+        return -num;
+    }
+    else {
+        return num;
+    }
+}
+function ceil(num) {
+    var temp;
+    temp = undefined;
+    if (num < 0) {
+        temp = Math.round(-num);
+        return -(temp > -num ? temp - 1 : temp);
+    }
+    else {
+        temp = Math.round(num);
+        return temp < num ? temp + 1 : temp;
+    }
+}
+function floor(num) {
+    if (num < 0) {
+        return -(Math.round(-num) < -num ? Math.round(-num) + 1 : Math.round(-num));
+    }
+    return Math.round(num) > num ? Math.round(num) - 1 : Math.round(num);
+}
+function trunc(num) {
+    if (num < 0) {
+        return -(Math.round(-num) > -num ? Math.round(-num) - 1 : Math.round(-num));
+    }
+    return Math.round(num) > num ? Math.round(num) - 1 : Math.round(num);
+}
+function random() {
+    var value;
+    value = Random(0, 65535);
+    return value / 65535;
+}

package/build/polyfill/Object.js

@@ -0,0 +1,24 @@
+function assign(target, source) {
+    throw "Not implemented";
+}
+function defineProperties(obj, properties) {
+    throw "Not implemented";
+}
+function defineProperty(obj, key, descriptor) {
+    throw "Not implemented";
+}
+function entries(obj) {
+    throw "Not implemented";
+}
+function fromEntries(entries) {
+    throw "Not implemented";
+}
+function groupBy(list, keyGetter) {
+    throw "Not implemented";
+}
+function keys(obj) {
+    throw "Not implemented";
+}
+function values(obj) {
+    throw "Not implemented";
+}

package/build/polyfill/String.js

@@ -0,0 +1,3 @@
+function endsWith(str, searchString) {
+    return str.slice(-searchString.length) === searchString;
+}

package/build/polyfill.js

@@ -0,0 +1,18 @@
+"META:NAMESPACE:bt";
+var polyfill;
+function init_polyfill() {
+    var ArrayPolyfill;
+    var ObjectPolyfill;
+    var StringPolyfill;
+    var MathPolyfill;
+    ArrayPolyfill = OpenCodeLibrary("./polyfill/Array.js");
+    ObjectPolyfill = OpenCodeLibrary("./polyfill/Object.js");
+    StringPolyfill = OpenCodeLibrary("./polyfill/String.js");
+    MathPolyfill = OpenCodeLibrary("./polyfill/Math.js");
+    polyfill = {
+        Array: ArrayPolyfill,
+        Math: MathPolyfill,
+        Object: ObjectPolyfill,
+        String: StringPolyfill
+    };
+}

package/build/prelude.js

@@ -0,0 +1 @@
+

package/build/require.js

@@ -0,0 +1,220 @@
+"META:NAMESPACE:bt";
+var moduleLock = {};
+var urlCache = {};
+var moduleCache = {};
+function require(moduleName, dirname) {
+    var moduleUrl;
+    var cachedModule;
+    var module;
+    moduleUrl = findModuleSafe(moduleName, dirname);
+    cachedModule = GetOptObjectProperty(moduleCache, moduleUrl);
+    if (cachedModule !== undefined) {
+        return cachedModule.exports;
+    }
+    module = loadModuleSafe(moduleUrl);
+    return module.exports;
+}
+function findModuleSafe(moduleName, dirname) {
+    var moduleKey;
+    var moduleUrl;
+    moduleKey = dirname + moduleName;
+    moduleUrl = GetOptObjectProperty(urlCache, moduleKey);
+    if (moduleUrl !== undefined) {
+        return moduleUrl;
+    }
+    moduleUrl = findModule(moduleName, dirname);
+    if (moduleUrl === undefined) {
+        throw "Module not found";
+    }
+    SetObjectProperty(urlCache, moduleKey, moduleUrl);
+    return moduleUrl;
+}
+function findModule(module, dirname) {
+    var relativeFileUrl;
+    var relativeFilePath;
+    var indexFileUrl;
+    var indexFilePath;
+    var relativeJsFileUrl;
+    var relativeJsFilePath;
+    var currentDir;
+    var currentDirNodeModules;
+    var currentDirNodeModulesPath;
+    var moduleDirUrl;
+    var moduleDirPath;
+    var indexModuleFileUrl;
+    var indexModuleFilePath;
+    var modulePackageFileUrl;
+    var modulePackageData;
+    var modulePackageJson;
+    var moduleMainFile;
+    var mainFileUrl;
+    var mainFilePath;
+    var err;
+    var moduleDirJsUrl;
+    var moduleDirJsPath;
+    if (!StrBegins(dirname, "x-local://")) {
+        return undefined;
+    }
+    relativeFileUrl = UrlAppendPath(dirname, module);
+    relativeFilePath = UrlToFilePath(relativeFileUrl);
+    if (FileExists(relativeFilePath)) {
+        if (IsDirectory(relativeFilePath)) {
+            indexFileUrl = UrlAppendPath(relativeFileUrl, "index.js");
+            indexFilePath = UrlToFilePath(indexFileUrl);
+            if (FileExists(indexFilePath) && !IsDirectory(indexFilePath)) {
+                return indexFileUrl;
+            }
+            else {
+                throw "Module not found";
+            }
+        }
+        else {
+            return relativeFileUrl;
+        }
+    }
+    relativeJsFileUrl = relativeFileUrl + ".js";
+    relativeJsFilePath = UrlToFilePath(relativeJsFileUrl);
+    if (FileExists(relativeJsFilePath) && !IsDirectory(relativeJsFilePath)) {
+        return relativeJsFileUrl;
+    }
+    currentDir = dirname;
+    try {
+        while (currentDir !== "x-local://") {
+            currentDirNodeModules = UrlAppendPath(currentDir, "node_modules");
+            currentDirNodeModulesPath = UrlToFilePath(currentDirNodeModules);
+            if (FileExists(currentDirNodeModulesPath) && IsDirectory(currentDirNodeModulesPath)) {
+                moduleDirUrl = UrlAppendPath(currentDirNodeModules, module);
+                moduleDirPath = UrlToFilePath(moduleDirUrl);
+                if (FileExists(moduleDirPath)) {
+                    if (IsDirectory(moduleDirPath)) {
+                        indexModuleFileUrl = UrlAppendPath(moduleDirUrl, "index.js");
+                        indexModuleFilePath = UrlToFilePath(indexModuleFileUrl);
+                        if (FileExists(indexModuleFilePath) && !IsDirectory(indexModuleFilePath)) {
+                            return indexModuleFileUrl;
+                        }
+                        modulePackageFileUrl = UrlAppendPath(moduleDirUrl, "package.json");
+                        try {
+                            modulePackageData = LoadUrlData(modulePackageFileUrl);
+                            modulePackageJson = ParseJson(modulePackageData);
+                            moduleMainFile = modulePackageJson.GetOptProperty("main");
+                            mainFileUrl = UrlAppendPath(moduleDirUrl, moduleMainFile);
+                            mainFilePath = UrlToFilePath(mainFileUrl);
+                            if (((moduleMainFile !== undefined) && FileExists(mainFilePath)) && !IsDirectory(mainFilePath)) {
+                                return mainFileUrl;
+                            }
+                        }
+                        catch (err) {
+                            break;
+                        }
+                    }
+                    else {
+                        return moduleDirUrl;
+                    }
+                }
+                else {
+                    moduleDirJsUrl = moduleDirUrl + ".js";
+                    moduleDirJsPath = UrlToFilePath(moduleDirJsUrl);
+                    if (FileExists(moduleDirJsPath) && !IsDirectory(moduleDirJsPath)) {
+                        return moduleDirJsUrl;
+                    }
+                }
+            }
+            currentDir = UrlParent(currentDir);
+        }
+    }
+    catch (err) {
+    }
+    return undefined;
+}
+function loadModuleSafe(moduleUrl) {
+    var cachedModule;
+    var module;
+    var err;
+    requireLock(moduleUrl);
+    try {
+        cachedModule = GetOptObjectProperty(moduleCache, moduleUrl);
+        if (cachedModule !== undefined) {
+            return cachedModule.exports;
+        }
+        module = loadModule(moduleUrl);
+        return module;
+    }
+    catch (err) {
+        requireUnlock(moduleUrl);
+        throw err;
+    }
+    finally {
+        requireUnlock(moduleUrl);
+    }
+}
+function loadModule(moduleUrl) {
+    var moduleLib;
+    var moduleContext;
+    moduleLib = OpenCodeLibrary(moduleUrl);
+    moduleContext = {
+        exports: {}
+    };
+    SetObjectProperty(moduleCache, moduleUrl, moduleContext);
+    moduleLib.__init(moduleLib, moduleContext);
+    return moduleContext;
+}
+function requireLock(key) {
+    var tid;
+    var marker;
+    var current;
+    var i;
+    tid = obtainUniqueThreadId();
+    marker = {
+        owner: tid
+    };
+    moduleLock.AddProperty(key, marker);
+    while (true) {
+        current = moduleLock.GetOptProperty(key);
+        if (current === marker) {
+            return;
+        }
+        for (i = 0; i < 100; i++) {
+        }
+        Sleep(20);
+    }
+}
+function requireUnlock(key) {
+    var tid;
+    var current;
+    tid = obtainUniqueThreadId();
+    current = moduleLock.GetProperty(key);
+    if (current === undefined) {
+        throw "not locked";
+    }
+    if (current.owner !== tid) {
+        throw "not owner";
+    }
+    moduleLock.DeleteOptProperty(key);
+}
+function obtainUniqueThreadId() {
+    var tid;
+    var aux;
+    tid = undefined;
+    function generateId() {
+        return Random(100000, 999999) + "";
+    }
+    if (LdsIsServer) {
+        tid = (tid = ActiveThread.UniqueThreadId);
+    }
+    else {
+        aux = CurThreadAuxData;
+        if (aux.HasProperty("UniqueThreadId")) {
+            tid = aux.UniqueThreadId;
+        }
+        else {
+            tid = generateId();
+            aux.UniqueThreadId = tid;
+        }
+    }
+    return tid;
+}
+function init_require() {
+    moduleLock = SafeObject();
+    urlCache = SafeObject();
+    moduleCache = SafeObject();
+}

package/build/semantic.js

@@ -0,0 +1,185 @@
+"META:NAMESPACE:bt";
+function getProperty(object, propertyName) {
+    var dataType;
+    var objectTypeOfObject;
+    var returnValue;
+    var objectTypeOfReturnValue;
+    var newDesc;
+    var knownObjectMethods;
+    dataType = DataType(object);
+    if (dataType === "undefined") {
+        throw "TypeError: Cannot read properties of undefined (reading '" + propertyName + "')";
+    }
+    if (dataType === "null") {
+        throw "TypeError: Cannot read properties of null (reading '" + propertyName + "')";
+    }
+    if (dataType === "object") {
+        objectTypeOfObject = ObjectType(object);
+        if ((objectTypeOfObject === "JsArray") && (DataType(propertyName) === "integer")) {
+            if ((propertyName < 0) || (propertyName >= ArrayCount(object))) {
+                return undefined;
+            }
+            else {
+                return object[propertyName];
+            }
+        }
+        returnValue = GetOptObjectProperty(object, propertyName);
+        objectTypeOfReturnValue = ObjectType(returnValue);
+        if (objectTypeOfReturnValue === "JsFuncObject") {
+            return returnValue;
+        }
+        if (((objectTypeOfReturnValue === "JsObject") && returnValue.HasProperty("@descriptor")) && (returnValue.GetProperty("@descriptor") === "function")) {
+            if (returnValue.HasProperty("obj") && (returnValue.GetProperty("obj") !== undefined)) {
+                return returnValue;
+            }
+            newDesc = {
+                "@descriptor": "function"
+            };
+            newDesc.SetProperty("obj", object);
+            newDesc.SetProperty("env", returnValue.env);
+            if (returnValue.HasProperty("callable")) {
+                newDesc.SetProperty("callable", returnValue.callable);
+            }
+            if (returnValue.HasProperty("lib")) {
+                newDesc.SetProperty("lib", returnValue.lib);
+            }
+            if (returnValue.HasProperty("ref")) {
+                newDesc.SetProperty("ref", returnValue.ref);
+            }
+            return newDesc;
+        }
+        if (returnValue === undefined) {
+            if (objectTypeOfObject === "JsObject") {
+                knownObjectMethods = ["HasProperty", "AddProperty", "GetOptProperty", "GetProperty", "SetProperty"];
+                if (ArrayOptFind(knownObjectMethods, "This === propertyName") !== undefined) {
+                    return {
+                        "@descriptor": "function",
+                        obj: object,
+                        env: undefined,
+                        ref: propertyName
+                    };
+                }
+            }
+            if (objectTypeOfObject === "JsArray") {
+                knownObjectMethods = ["push"];
+                if (ArrayOptFind(knownObjectMethods, "This === propertyName") !== undefined) {
+                    return {
+                        "@descriptor": "function",
+                        obj: object,
+                        env: undefined,
+                        ref: propertyName
+                    };
+                }
+            }
+            if (objectTypeOfObject === "DxTrans") {
+                knownObjectMethods = ["AddRespHeader", "CheckLdsAuth", "Execute", "GetSessionByID", "HandleNotFound", "PermanentRedirect", "Redirect", "SetRespStatus", "SetWrongAuth", "UpgradeToWebSocket"];
+                if (ArrayOptFind(knownObjectMethods, "This === propertyName") !== undefined) {
+                    return {
+                        "@descriptor": "function",
+                        obj: object,
+                        env: undefined,
+                        ref: propertyName
+                    };
+                }
+            }
+            if ((objectTypeOfObject === "BmObject") || (objectTypeOfObject === "JsCodeLibrary")) {
+                return {
+                    "@descriptor": "function",
+                    obj: object,
+                    env: undefined,
+                    ref: propertyName
+                };
+            }
+        }
+        return returnValue;
+    }
+    if (dataType === "string") {
+        if (propertyName === "length") {
+            return StrCharCount(object);
+        }
+        knownObjectMethods = ["Allocate", "charAt", "charCodeAt", "fromCharCode", "indexOf", "lastIndexOf", "slice", "split", "substr", "toLowerCase", "ToWinLineBreaks"];
+        if (ArrayOptFind(knownObjectMethods, "This === propertyName") !== undefined) {
+            return {
+                "@descriptor": "function",
+                obj: object,
+                env: undefined,
+                ref: propertyName
+            };
+        }
+    }
+    throw "TypeError: Cannot read properties of " + dataType + " (reading '" + propertyName + "')";
+}
+function setProperty(object, propertyName, value) {
+    var dataTypeOfObject;
+    dataTypeOfObject = DataType(object);
+    if (dataTypeOfObject === "undefined") {
+        throw "TypeError: Cannot set properties of undefined (setting '" + propertyName + "')";
+    }
+    if (dataTypeOfObject === "null") {
+        throw "TypeError: Cannot set properties of null (setting '" + propertyName + "')";
+    }
+    if (dataTypeOfObject === "object") {
+        SetObjectProperty(object, propertyName, value);
+        return;
+    }
+    throw "TypeError: Cannot set properties of " + dataTypeOfObject + " (setting '" + propertyName + "')";
+}
+function isFunction(object) {
+    var objectType;
+    objectType = ObjectType(object);
+    return (objectType === "JsFuncObject") || (((objectType === "JsObject") && object.HasProperty("@descriptor")) && (object.GetProperty("@descriptor") === "function"));
+}
+function callFunction(func, args) {
+    var funcObjectType;
+    var argsEval1;
+    var env2;
+    var obj2;
+    var callable2;
+    var env3;
+    var obj3;
+    var lib3;
+    var ref3;
+    var env4;
+    var obj4;
+    var ref4;
+    var argsEval4;
+    funcObjectType = ObjectType(func);
+    if (funcObjectType === "JsFuncObject") {
+        argsEval1 = collectArgsToEval("args", args.length);
+        return eval("func(" + argsEval1 + ")");
+    }
+    else if (((funcObjectType === "JsObject") && func.HasProperty("@descriptor")) && (func.GetProperty("@descriptor") === "function")) {
+        if (func.HasProperty("callable")) {
+            env2 = func.env;
+            obj2 = func.obj;
+            callable2 = func.callable;
+            return eval("callable2(env2, obj2, args)");
+        }
+        else if (func.HasProperty("lib")) {
+            env3 = func.env;
+            obj3 = func.obj;
+            lib3 = func.lib;
+            ref3 = func.ref;
+            return eval("lib3." + ref3 + "(env3, obj3, args)");
+        }
+        else {
+            env4 = func.env;
+            obj4 = func.obj;
+            ref4 = func.ref;
+            argsEval4 = collectArgsToEval("args", args.length);
+            return eval("obj4." + ref4 + "(" + argsEval4 + ")");
+        }
+    }
+    else {
+        throw "TypeError: callable is not a function";
+    }
+}
+function collectArgsToEval(name, count) {
+    var args;
+    var i;
+    args = [];
+    for (i = 0; i < count; i++) {
+        args.push(((name + "[") + i) + "]");
+    }
+    return ArrayMerge(args, "This", ", ");
+}

package/build/spxml/bt-runtime.js

@@ -0,0 +1,24 @@
+function init() {
+    var LOG_CODE;
+    var err;
+    LOG_CODE = "bt-runtime";
+    EnableLog(LOG_CODE, true);
+    try {
+        alert("Component bt-runtime initializing...");
+        RegisterCodeLibrary("../polyfill.js");
+        RegisterCodeLibrary("../semantic.js");
+        RegisterCodeLibrary("../destructuring.js");
+        RegisterCodeLibrary("../require.js");
+        RegisterCodeLibrary("../cache.js");
+        bt.init_polyfill();
+        bt.init_require();
+        bt.init_cache();
+        alert("Component bt-runtime initialized");
+        LogEvent(LOG_CODE, "INFO:     bt-runtime component registration success");
+    }
+    catch (err) {
+        alert("ERROR: Component initializing: bt-runtime:\r\n" + err);
+        LogEvent(LOG_CODE, "ERROR:    bt-runtime component registration failed: " + err);
+        throw err;
+    }
+}

package/build/spxml/bt-runtime.xml

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="utf-8"?>
+<SPXML-INLINE-FORM CODE-LIB="1">
+
+<bt-runtime>
+</bt-runtime>
+
+</SPXML-INLINE-FORM>

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@boristype/runtime",
+  "version": "0.1.0-alpha.0",
+  "description": "BorisScript runtime polyfills for the BorisType compiler",
+  "files": [
+    "build",
+    "README.md"
+  ],
+  "author": "punkhomov",
+  "license": "MIT",
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/BorisType/BorisType.git"
+  },
+  "bugs": {
+    "url": "https://github.com/BorisType/BorisType/issues"
+  },
+  "homepage": "https://github.com/BorisType/BorisType#readme",
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@boristype/types": "^1.0.0-alpha.3",
+    "@boristype/bt-cli": "^0.1.0-alpha.0",
+    "@boristype/ws-version": "^0.1.0-alpha.0"
+  },
+  "ws:package": "system",
+  "ws:name": "bt-runtime",
+  "ws:root": "./wt/bt/runtime",
+  "ws:apiext": {
+    "name": "bt:runtime",
+    "libs": [
+      "./init.xml"
+    ]
+  },
+  "scripts": {
+    "build": "npx btc build --include-non-ts-files --compile-mode bare && node scripts/gen-package-file.js"
+  }
+}