topchetoeu/j2s
1
0
Fork 0
Code Issues 6 Pull Requests Actions Packages Projects Releases 74 Wiki Activity

restructuring of stdlibs

Browse Source
This commit is contained in:
TopchetoEU 2025-01-24 22:37:52 +02:00
parent f16d088646
commit 3c4d05abd4
Signed by: topchetoeu
GPG Key ID: 6531B8583E5F6ED4
18 changed files with 293 additions and 187 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
lib/package.json
View File

@ -17,6 +17,7 @@
"typescript": "^5.7.2"
},
"devDependencies": {
"@babel/plugin-proposal-class-properties": "^7.18.6",
"@babel/plugin-transform-class-properties": "^7.25.9",
"@babel/plugin-transform-runtime": "^7.25.9",
"@babel/plugin-transform-typescript": "^7.25.9",

5
lib/rollup.config.js
View File

@ -34,7 +34,6 @@ const construct = (input, output) => defineConfig({
optimizeConstEnums: true,
allowDeclareFields: true,
}],
["@babel/plugin-transform-class-properties"],
["@babel/plugin-transform-runtime", {
moduleName: shouldPolyfill() ? "!polyfills:" : undefined,
version: "^7.24.0",
@ -48,6 +47,7 @@ const construct = (input, output) => defineConfig({
assumptions: {
ignoreToPrimitiveHint: true,
noClassCalls: true,
privateFieldsAsProperties: true,
},
env: {
@ -77,7 +77,8 @@ const construct = (input, output) => defineConfig({
"@babel/plugin-transform-optional-chaining",
"@babel/plugin-transform-logical-assignment-operators",
"@babel/plugin-transform-numeric-separator",
"@babel/plugin-transform-class-properties",
"@babel/plugin-transform-private-methods",
"@babel/plugin-proposal-class-properties",
"@babel/plugin-transform-class-static-block",
"@babel/plugin-transform-regenerator",

13
lib/src/lib/async.d.ts vendored
View File

@ -22,3 +22,16 @@ declare interface PromiseConstructor {
resolve<T>(val: T): Promise<Awaited<T>>;
reject<T>(err: unknown): Promise<T>;
}
declare interface AsyncIterator<T, Return = unknown, Next = unknown> {
next(): Promise<IterationData<T, Return>>;
next(val: Next): Promise<IterationData<T, Return>>;
error?(err: unknown): Promise<IterationData<T, Return>>;
return?(val: Return): Promise<IterationData<T, Return>>;
}
declare interface AsyncIterableIterator<T, Return = unknown, Next = unknown> extends AsyncIterator<T, Return, Next> {
[Symbol.iterator](): this;
}
declare interface AsyncIterable<T> {
[Symbol.iterator](): AsyncIterator<T>;
}

6
lib/src/lib/iterator.d.ts vendored
View File

@ -1,12 +1,12 @@
declare interface NormalIterationData<T> {
value: T;
done: true;
done: false;
}
declare interface DoneIterationData<T> {
value: T;
done?: false;
done?: true;
}
declare type IterationData<T, Return> = NormalIterationData<T> | DoneIterationData<Return>;
declare type IterationData<T, Return = void> = NormalIterationData<T> | DoneIterationData<Return>;
declare interface Iterator<T, Return = unknown, Next = unknown> {
next(): IterationData<T, Return>;

3
lib/src/polyfills/classPrivateFieldLooseBase.js Normal file
View File

@ -0,0 +1,3 @@
export default function _classPrivateFieldLooseBase(obj) {
return obj;
}

13
lib/src/polyfills/classPrivateFieldLooseKey.js Normal file
View File

@ -0,0 +1,13 @@
import { print, self, symbol } from "../stdlib/primordials.ts";
import { Object } from "../stdlib/values/object.ts";
self.Object = {
defineProperty: function (obj, key, desc) {
if (obj == null) return obj;
Object.defineProperty(obj, key, desc);
}
};
export default function _classPrivateFieldLooseKey(key) {
return symbol.makeSymbol(key);
}

5
lib/src/polyfills/createClass.js
View File

@ -1,4 +1,4 @@
import { object } from "../stdlib/primordials.ts";
import { func, object, print } from "../stdlib/primordials.ts";
function _defineProperties(target, arr) {
if (!arr) return;
@ -31,5 +31,8 @@ export default function _createClass(clazz, instance, nonInstance) {
_defineProperties(clazz.prototype, instance);
_defineProperties(clazz, nonInstance);
func.setCallable(clazz, false);
func.setConstructable(clazz, true);
return clazz;
}

23
lib/src/stdlib/arrays/ArrayBuffer.ts
View File

@ -1,25 +1,28 @@
import { buffer, type InternalBuffer, map, symbol } from "../primordials.ts";
export const abs = new map(true);
export const abKey: unique symbol = symbol.getSymbol("ArrayBuffer.impl") as any;
export class ArrayBuffer {
public [abKey]!: InternalBuffer;
#internal!: InternalBuffer;
public get byteLength() {
return this[abKey].length;
return this.#internal.length;
}
public get byteOffset() {
return 0;
}
public constructor(val: unknown) {
if (buffer.isBuff(val)) this[abKey] = val;
else this[abKey] = buffer.buff(Number(val));
if (buffer.isBuff(val)) this.#internal = val;
else this.#internal = buffer.buff(Number(val));
}
public static unwrap(instance: ArrayBuffer) {
return instance.#internal;
}
}
export function getAB(buff: InternalBuffer): ArrayBuffer {
function wrapAB(buff: InternalBuffer): ArrayBuffer {
let res = abs.get(buff);
if (res == null) {
res = new ArrayBuffer(buff);
@ -28,3 +31,11 @@ export function getAB(buff: InternalBuffer): ArrayBuffer {
return res;
}
const unwrapAB = ArrayBuffer.unwrap;
delete (ArrayBuffer as any).unwrap;
export { wrapAB, unwrapAB };

4
lib/src/stdlib/arrays/Int32Array.ts
View File

@ -1,5 +1,5 @@
import { buffer } from "../primordials.ts";
import { abstractIgnore, TypedArray, typedArrayFuncs } from "./TypedArray.ts";
import { token, TypedArray, typedArrayFuncs } from "./TypedArray.ts";
const factory = buffer.int32;
const funcs = typedArrayFuncs(4, factory);
@ -19,7 +19,7 @@ export class Int32Array extends TypedArray {
}
public constructor(obj: any, start?: number, end?: number) {
super(abstractIgnore);
super(token);
return funcs.construct(obj, start, end) as any;
}
}

12
lib/src/stdlib/arrays/TypedArray.ts
View File

@ -1,9 +1,9 @@
import { buffer, func, type InternalBuffer, object, string, symbol } from "../primordials.ts";
import { symbols, wrapI } from "../utils.ts";
import { Error, TypeError } from "../values/errors.ts";
import { abKey, ArrayBuffer, getAB } from "./ArrayBuffer.ts";
import { ArrayBuffer, unwrapAB, wrapAB } from "./ArrayBuffer.ts";
export const abstractIgnore = symbol.getSymbol("TypedArray.abstractIgnore");
export const token = symbol.getSymbol("TypedArray.abstractIgnore");
export function typedArrayFuncs(perEl: number, constructor: (buff: InternalBuffer, start: number, end: number) => number[]) {
return {
@ -56,7 +56,7 @@ export function typedArrayFuncs(perEl: number, constructor: (buff: InternalBuffe
return constructor(buffer.buff(self * perEl), 0, self);
}
if (self instanceof ArrayBuffer) {
const internal = self[abKey];
const internal = unwrapAB(self);
if (start === undefined) start = 0;
if (end === undefined) end = (internal.length / perEl) | 0;
return constructor(internal, start, end);
@ -90,7 +90,7 @@ export function typedArrayFuncs(perEl: number, constructor: (buff: InternalBuffe
export class TypedArray {
public get buffer() {
return getAB(buffer.backer(this as any));
return wrapAB(buffer.backer(this as any));
}
public get byteOffset(): number {
throw new Error("abstract");
@ -212,8 +212,8 @@ export class TypedArray {
return this;
}
public constructor(token?: typeof abstractIgnore) {
if (token !== abstractIgnore) {
public constructor(_token?: typeof token) {
if (_token !== token) {
throw new TypeError("TypedArray constructor can't be called");
}
}

4
lib/src/stdlib/arrays/Uint8Array.ts
View File

@ -1,5 +1,5 @@
import { buffer } from "../primordials.ts";
import { abstractIgnore, TypedArray, typedArrayFuncs } from "./TypedArray.ts";
import { token, TypedArray, typedArrayFuncs } from "./TypedArray.ts";
const factory = buffer.uint8;
const funcs = typedArrayFuncs(1, factory);
@ -26,7 +26,7 @@ export class Uint8Array extends TypedArray {
}
public constructor(obj: any, start?: number, end?: number) {
super(abstractIgnore);
super(token);
return funcs.construct(obj, start, end) as any;
}
}

8
lib/src/stdlib/classes/date.ts
View File

@ -1,13 +1,11 @@
import { now, symbol } from "../primordials.ts";
const timeKey: unique symbol = symbol.makeSymbol("") as any;
import { now, number, symbol } from "../primordials.ts";
export const Date = (() => {
class Date {
[timeKey]!: number;
#time: number;
public constructor() {
this.#time = number.NaN;
}
public static now() {

51
lib/src/stdlib/classes/map.ts
View File

@ -1,51 +1,49 @@
import { Array } from "../values/array.ts";
import { func, map, symbol } from "../primordials.ts";
import { func, map } from "../primordials.ts";
import { symbols } from "../utils.ts";
const mapKey: unique symbol = symbol.makeSymbol("Map.impl") as any;
export class Map<K, V> {
private [mapKey]: InstanceType<typeof map>;
#map: InstanceType<typeof map>;
public get size() {
return this[mapKey].size();
return this.#map.size();
}
public get(key: K): V {
return this[mapKey].get(key);
return this.#map.get(key);
}
public has(key: K): boolean {
return this[mapKey].has(key);
return this.#map.has(key);
}
public set(key: K, val: V) {
this[mapKey].set(key, val);
this.#map.set(key, val);
return this;
}
public delete(key: K): boolean {
if (!this[mapKey].has(key)) return false;
if (!this.#map.has(key)) return false;
else {
this[mapKey].delete(key);
this.#map.delete(key);
return true;
}
}
public clear() {
this[mapKey].clear();
this.#map.clear();
}
public keys(): K[] {
return this[mapKey].keys();
return this.#map.keys();
}
public values(): V[] {
const res = this[mapKey].keys();
const res = this.#map.keys();
for (let i = 0; i < res.length; i++) {
res[i] = this[mapKey].get(res[i]);
res[i] = this.#map.get(res[i]);
}
return res;
}
public entries(): [K, V][] {
const res = this[mapKey].keys();
const res = this.#map.keys();
for (let i = 0; i < res.length; i++) {
res[i] = [res[i], this[mapKey].get(res[i])];
res[i] = [res[i], this.#map.get(res[i])];
}
return res;
}
@ -62,7 +60,7 @@ export class Map<K, V> {
}
public constructor(iterable?: Iterable<[K, V]>) {
const _map = this[mapKey] = new map();
const _map = this.#map = new map();
if (iterable != null) {
if (Array.isArray(iterable)) {
@ -81,31 +79,31 @@ export class Map<K, V> {
}
}
export class WeakMap<K, V> {
private [mapKey]: InstanceType<typeof map>;
#map: InstanceType<typeof map>;
public get(key: K): V {
return this[mapKey].get(key);
return this.#map.get(key);
}
public has(key: K): boolean {
return this[mapKey].has(key);
return this.#map.has(key);
}
public set(key: K, val: V) {
this[mapKey].set(key, val);
this.#map.set(key, val);
return this;
}
public delete(key: K): boolean {
if (!this[mapKey].has(key)) return false;
if (!this.#map.has(key)) return false;
else {
this[mapKey].delete(key);
this.#map.delete(key);
return true;
}
}
public clear() {
this[mapKey].clear();
this.#map.clear();
}
public constructor(iterable?: Iterable<[K, V]>) {
const _map = this[mapKey] = new map(true);
const _map = this.#map = new map(true);
if (iterable != null) {
if (Array.isArray(iterable)) {
@ -123,6 +121,3 @@ export class WeakMap<K, V> {
}
}
}
func.setCallable(Map, false);
func.setCallable(WeakMap, false);

117
lib/src/stdlib/classes/promise.ts
View File

@ -1,4 +1,4 @@
import { func, next, object, symbol } from "../primordials.ts";
import { next } from "../primordials.ts";
enum PromiseState {
Pending = "pend",
@ -6,109 +6,106 @@ enum PromiseState {
Rejected = "rej",
}
const pState: unique symbol = symbol.makeSymbol("Promise.state") as any;
const pValue: unique symbol = symbol.makeSymbol("Promise.value") as any;
const pFulHandles: unique symbol = symbol.makeSymbol("Promise.fulfillHandles") as any;
const pRejHandles: unique symbol = symbol.makeSymbol("Promise.rejectHandles") as any;
export class Promise<T> {
static #InternalPromise = function <T>(this: Promise<T>) {
this.#state = PromiseState.Pending;
this.#fulHandles = [];
this.#rejHandles = [];
} as any as new <T>() => Promise<T>;
function makePromise<T>(): Promise<T> {
return object.setPrototype({
[pState]: PromiseState.Pending,
[pFulHandles]: [],
[pRejHandles]: [],
}, Promise.prototype) as Promise<T>;
static {
this.#InternalPromise.prototype = this.prototype;
}
function fulfill(self: Promise<any>, val: any) {
if (self[pState] !== PromiseState.Pending) return;
if (self === val) throw new Error("A promise may not be fulfilled with itself");
#state: PromiseState;
#value?: T | unknown;
#fulHandles?: ((val: T) => void)[] = [];
#rejHandles?: ((val: T) => void)[] = [];
#fulfill(val: any) {
if (this.#state !== PromiseState.Pending) return;
if (this === val) throw new Error("A promise may not be fulfilled with itself");
if (val != null && typeof val.then === "function") {
val.then(
(val: any) => fulfill(self, val),
(err: any) => reject(self, err),
(val: any) => this.#fulfill(val),
(err: any) => this.#reject(err),
);
}
else {
self[pValue] = val;
self[pState] = PromiseState.Fulfilled;
this.#value = val;
this.#state = PromiseState.Fulfilled;
const handles = self[pFulHandles]!;
const handles = this.#fulHandles!;
for (let i = 0; i < handles.length; i++) {
handles[i](val);
}
self[pFulHandles] = undefined;
self[pRejHandles] = undefined;
this.#fulHandles = undefined;
this.#rejHandles = undefined;
}
}
function reject(self: Promise<any>, val: any) {
if (self[pState] !== PromiseState.Pending) return;
if (self === val) throw new Error("A promise may not be rejected with itself");
#reject(val: any) {
if (this.#state !== PromiseState.Pending) return;
if (this === val) throw new Error("A promise may not be rejected with itself");
if (val != null && typeof val.then === "function") {
val.then(
(val: any) => reject(self, val),
(err: any) => reject(self, err),
(val: any) => this.#reject(val),
(err: any) => this.#reject(err),
);
}
else {
self[pValue] = val;
self[pState] = PromiseState.Rejected;
this.#value = val;
this.#state = PromiseState.Rejected;
const handles = self[pRejHandles]!;
const handles = this.#rejHandles!;
for (let i = 0; i < handles.length; i++) {
handles[i](val);
}
self[pFulHandles] = undefined;
self[pRejHandles] = undefined;
this.#fulHandles = undefined;
this.#rejHandles = undefined;
}
}
function handle<T>(self: Promise<T>, ful?: (val: T) => void, rej?: (err: any) => void) {
if (self[pState] === PromiseState.Pending) {
#handle(ful?: (val: T) => void, rej?: (err: any) => void) {
if (this.#state === PromiseState.Pending) {
if (ful != null) {
self[pFulHandles]![self[pFulHandles]!.length] = ful;
this.#fulHandles![this.#fulHandles!.length] = ful;
}
if (rej != null) {
self[pRejHandles]![self[pRejHandles]!.length] = rej;
this.#rejHandles![this.#rejHandles!.length] = rej;
}
}
else if (self[pState] === PromiseState.Fulfilled) {
if (ful != null) ful(self[pValue] as T);
else if (this.#state === PromiseState.Fulfilled) {
if (ful != null) ful(this.#value as T);
}
else if (self[pState] === PromiseState.Rejected) {
if (rej != null) rej(self[pValue]);
else if (this.#state === PromiseState.Rejected) {
if (rej != null) rej(this.#value);
}
}
export class Promise<T> {
public [pState]: PromiseState;
public [pValue]?: T | unknown;
public [pFulHandles]?: ((val: T) => void)[] = [];
public [pRejHandles]?: ((val: T) => void)[] = [];
public then<Res>(ful?: (val: T) => Res, rej?: (err: any) => Res) {
if (typeof ful !== "function") ful = undefined;
if (typeof rej !== "function") rej = undefined;
const promise = makePromise<Res>();
const promise = new Promise.#InternalPromise<Res>();
handle(this,
this.#handle(
val => next(() => {
if (ful == null) fulfill(promise, val);
if (ful == null) promise.#fulfill(val);
else {
try { fulfill(promise, ful(val)); }
catch (e) { reject(promise, e); }
try { promise.#fulfill(ful(val)); }
catch (e) { promise.#reject(e); }
}
}),
err => next(() => {
if (rej == null) reject(promise, err);
if (rej == null) promise.#reject(err);
else {
try { fulfill(promise, rej(err)); }
catch (e) { reject(promise, e); }
try { promise.#fulfill(rej(err)); }
catch (e) { promise.#reject(e); }
}
}),
);
@ -134,21 +131,19 @@ export class Promise<T> {
}
public constructor(fn: (fulfil: (val: T) => void, reject: (err: unknown) => void) => void) {
this[pState] = PromiseState.Pending;
this.#state = PromiseState.Pending;
fn(val => fulfill(this, val), err => reject(this, err));
fn(val => this.#fulfill(val), err => this.#reject(err));
}
public static resolve(val: any) {
const res = makePromise();
fulfill(res, val);
const res = new this.#InternalPromise();
res.#fulfill(val);
return res;
}
public static reject(val: any) {
const res = makePromise();
reject(res, val);
const res = new this.#InternalPromise();
res.#reject(val);
return res;
}
}
func.setCallable(Promise, false);

43
lib/src/stdlib/classes/set.ts
View File

@ -1,42 +1,40 @@
import { Array } from "../values/array.ts";
import { func, map, symbol } from "../primordials.ts";
import { func, map } from "../primordials.ts";
import { symbols } from "../utils.ts";
const mapKey: unique symbol = symbol.makeSymbol("Set.impl") as any;
export class Set<T> {
private [mapKey]: InstanceType<typeof map>;
#map: InstanceType<typeof map>;
public get size() {
return this[mapKey].size();
return this.#map.size();
}
public has(key: T): boolean {
return this[mapKey].has(key);
return this.#map.has(key);
}
public add(val: T) {
this[mapKey].set(val, true);
this.#map.set(val, true);
return this;
}
public delete(val: T): boolean {
if (!this[mapKey].has(val)) return false;
if (!this.#map.has(val)) return false;
else {
this[mapKey].delete(val);
this.#map.delete(val);
return true;
}
}
public clear() {
this[mapKey].clear();
this.#map.clear();
}
public keys(): T[] {
return this[mapKey].keys();
return this.#map.keys();
}
public values(): T[] {
return this[mapKey].keys();
return this.#map.keys();
}
public entries(): [T, T][] {
const res = this[mapKey].keys();
const res = this.#map.keys();
for (let i = 0; i < res.length; i++) {
res[i] = [res[i], res[i]];
@ -57,7 +55,7 @@ export class Set<T> {
}
public constructor(iterable?: Iterable<T>) {
const _map = this[mapKey] = new map();
const _map = this.#map = new map();
if (iterable != null) {
if (Array.isArray(iterable)) {
@ -77,28 +75,28 @@ export class Set<T> {
}
export class WeakSet<T> {
private [mapKey]: InstanceType<typeof map>;
#map: InstanceType<typeof map>;
public has(key: T): boolean {
return this[mapKey].has(key);
return this.#map.has(key);
}
public add(val: T) {
this[mapKey].set(val, true);
this.#map.set(val, true);
return this;
}
public delete(val: T): boolean {
if (!this[mapKey].has(val)) return false;
if (!this.#map.has(val)) return false;
else {
this[mapKey].delete(val);
this.#map.delete(val);
return true;
}
}
public clear() {
this[mapKey].clear();
this.#map.clear();
}
public constructor(iterable?: Iterable<T>) {
const _map = this[mapKey] = new map(true);
const _map = this.#map = new map(true);
if (iterable != null) {
if (Array.isArray(iterable)) {
@ -116,6 +114,3 @@ export class WeakSet<T> {
}
}
}
func.setCallable(Set, false);
func.setCallable(WeakSet, false);

14
lib/src/stdlib/primordials.ts
View File

@ -4,6 +4,14 @@ export interface InternalBuffer {
length: number;
[buffSymbol]: "buffer";
}
export interface InternalSocket {
read(onRes: (data: Uint8Array) => void, onErr: (err: unknown) => void, onDone: () => void): void;
write(data: Uint8Array, onRes: () => void, onErr: (err: unknown) => void): void;
}
export interface InternalServer {
bind(address: string, onRes: () => void, onErr: (err: unknown) => void): void;
next(onRes: (socket: InternalSocket) => void, onErr: (err: unknown) => void, onDone: () => void): void;
}
export interface SymbolPrimordials {
makeSymbol(name: string): symbol;
@ -82,6 +90,9 @@ export interface JSONPrimordials {
parse(data: string): any;
stringify(data: any): string;
}
export interface NetPrimordials {
server(): InternalServer;
}
export interface Primordials {
symbol: SymbolPrimordials;
@ -91,6 +102,7 @@ export interface Primordials {
function: FunctionPrimordials;
json: JSONPrimordials;
buffer: BufferPrimordials;
net: NetPrimordials;
map: new (weak?: boolean) => {
get(key: any): any;
has(key: any): boolean;
@ -127,6 +139,7 @@ export const {
buffer,
function: func,
json,
net: socket,
map,
regex,
setGlobalPrototypes,
@ -139,3 +152,4 @@ export const {
} = primordials;
export type regex = InstanceType<typeof regex>;
export const self = (globalThis as any);

63
lib/src/stdlib/sockets.ts Normal file
View File

@ -0,0 +1,63 @@
import { Promise as Promise } from "./classes/promise";
import { func, InternalServer, InternalSocket, symbol } from "./primordials";
import { Error } from "./values/errors";
const socketToken = symbol.makeSymbol("ServerSocket.token");
export class ServerSocket {
#internal: InternalSocket;
public read() {
return new Promise((ful, rej) => {
this.#internal.read(ful, rej, ful as any);
});
}
public write(data: Uint8Array) {
return new Promise<void>((ful, rej) => {
this.#internal.write(data, ful, rej);
});
}
public next() {
return new Promise((ful, rej) => {
this.#internal.read(
data => ful({ value: data, done: false }),
rej,
() => ful({ value: undefined, done: true })
);
});
}
public [Symbol.iterator](): this {
return this;
}
public constructor(token: typeof socketToken, socket: InternalSocket) {
if (token !== socketToken) throw new Error("Invalid token for creation");
this.#internal = socket;
}
}
export class Server {
#internal: InternalServer;
public bind(address: string) {
return new Promise<void>((res, rej) => this.#internal.bind(address, res, rej));
}
public next() {
return new Promise((ful, rej) => {
this.#internal.next(
data => ful({ value: new ServerSocket(socketToken, data), done: false }),
rej,
() => ful({ value: undefined, done: true })
);
});
}
public [Symbol.iterator](): this {
return this;
}
public constructor(server: InternalServer) {
this.#internal = server;
}
}

17
lib/src/stdlib/values/regex.ts
View File

@ -1,14 +1,12 @@
import { func, regex, symbol } from "../primordials.ts";
import { func, regex } from "../primordials.ts";
import { String } from "./string.ts";
import { type ReplaceRange } from "../utils.ts";
import { applyReplaces } from "../utils.ts";
import { applySplits } from "../utils.ts";
import { symbols } from "../utils.ts";
const regexKey: unique symbol = symbol.makeSymbol("RegExp.impl") as any;
export class RegExp {
private [regexKey]!: InstanceType<typeof regex>;
#regex!: InstanceType<typeof regex>;
public readonly source!: string;
public readonly flags!: string;
@ -70,14 +68,14 @@ export class RegExp {
this.unicodeSets = unicodeSets;
this.sticky = sticky;
this[regexKey] = new regex(source, multiline, ignoreCase, dotall, unicode, unicodeSets);
this.#regex = new regex(source, multiline, ignoreCase, dotall, unicode, unicodeSets);
}
public exec(target: string) {
const useLast = this.global || this.sticky;
const start = useLast ? this.lastIndex : 0;
const match = this[regexKey].exec(target, start, this.indices);
const match = this.#regex.exec(target, start, this.indices);
if (match != null && !(this.sticky && match.matches.index !== start)) {
if (useLast) this.lastIndex = match.end;
return match.matches;
@ -92,7 +90,7 @@ export class RegExp {
public [symbols.split](target: string, limit?: number) {
return applySplits(target, limit, offset => {
const val = this[regexKey].exec(target, offset, false);
const val = this.#regex.exec(target, offset, false);
if (val == null) return undefined;
return { start: val.matches.index!, end: val.end };
@ -100,7 +98,7 @@ export class RegExp {
}
public [symbols.replace](target: string, replacer: any) {
const matches: ReplaceRange[] = [];
const regex = this[regexKey];
const regex = this.#regex;
if (this.global) {
let offset = 0;
@ -136,3 +134,6 @@ export class RegExp {
return applyReplaces(target, matches, replacer, regex.groupCount() + 1);
}
}
func.setCallable(RegExp, true);
func.setConstructable(RegExp, true);