@cuxt/sandboxjs 0.1.1 → 0.1.3

package/dist/esm/utils/index.js

@@ -0,0 +1,7 @@
+import "./unraw.js";
+import "./errors.js";
+import "./CodeString.js";
+import "./types.js";
+import "./Prop.js";
+import "./Scope.js";
+import "./ExecContext.js";

package/dist/esm/utils/types.d.ts

@@ -0,0 +1,221 @@
+import { IEvalContext } from '../eval';
+import { Change } from '../executor';
+import { IExecutionTree } from '../parser';
+import { default as SandboxExec } from '../SandboxExec';
+import { Scope } from './Scope';
+export declare const AsyncFunction: Function;
+export declare const GeneratorFunction: Function;
+export declare const AsyncGeneratorFunction: Function;
+export interface IOptionParams {
+    audit?: boolean;
+    forbidFunctionCalls?: boolean;
+    forbidFunctionCreation?: boolean;
+    prototypeWhitelist?: Map<Function, Set<string>>;
+    globals?: IGlobals;
+    symbolWhitelist?: ISymbolWhitelist;
+    executionQuota?: bigint;
+    nonBlocking?: boolean;
+    haltOnSandboxError?: boolean;
+    maxParserRecursionDepth?: number;
+    /**
+     * Additional function replacements to merge with the built-in tick-checking replacements.
+     * Maps a native function to a factory that receives the IContext and returns the replacement.
+     * When sandboxed code accesses a property that returns a mapped function, the factory is
+     * called once per context and the result is cached and returned instead.
+     */
+    functionReplacements?: Map<Function, (ctx: IContext) => Function>;
+}
+export interface IOptions {
+    audit: boolean;
+    forbidFunctionCalls: boolean;
+    forbidFunctionCreation: boolean;
+    prototypeWhitelist: Map<Function, Set<PropertyKey>>;
+    globals: IGlobals;
+    symbolWhitelist: ISymbolWhitelist;
+    executionQuota?: bigint;
+    haltOnSandboxError?: boolean;
+    maxParserRecursionDepth: number;
+    nonBlocking: boolean;
+    functionReplacements: Map<Function, (ctx: IExecContext, builtInReplacement?: Function) => Function>;
+}
+export interface IContext {
+    sandbox: SandboxExec;
+    globalScope: Scope;
+    sandboxGlobal: ISandboxGlobal;
+    globalsWhitelist: Set<any>;
+    prototypeWhitelist: Map<any, Set<PropertyKey>>;
+    sandboxedFunctions: WeakSet<Function>;
+    sandboxSymbols: SandboxSymbolContext;
+    options: IOptions;
+    auditReport?: IAuditReport;
+    ticks: Ticks;
+}
+export interface IAuditReport {
+    globalsAccess: Set<unknown>;
+    prototypeAccess: {
+        [name: string]: Set<PropertyKey>;
+    };
+}
+export interface Ticks {
+    ticks: bigint;
+    tickLimit?: bigint;
+    nextYield?: bigint;
+}
+export type SubscriptionSubject = object;
+export type HaltContext = {
+    type: 'error';
+    error: Error;
+    ticks: Ticks;
+    scope: Scope;
+    context: IExecContext;
+} | {
+    type: 'manual';
+    error?: never;
+    ticks?: never;
+    scope?: never;
+    context?: never;
+} | {
+    type: 'yield';
+    error?: never;
+    ticks?: never;
+    scope?: never;
+    context?: never;
+};
+export interface IExecContext extends IExecutionTree {
+    ctx: IContext;
+    getSubscriptions: Set<(obj: SubscriptionSubject, name: string) => void>;
+    setSubscriptions: WeakMap<SubscriptionSubject, Map<string, Set<(modification: Change) => void>>>;
+    changeSubscriptions: WeakMap<SubscriptionSubject, Set<(modification: Change) => void>>;
+    setSubscriptionsGlobal: WeakMap<SubscriptionSubject, Map<string, Set<(modification: Change) => void>>>;
+    changeSubscriptionsGlobal: WeakMap<SubscriptionSubject, Set<(modification: Change) => void>>;
+    registerSandboxFunction: (fn: (...args: any[]) => any) => void;
+    evals: Map<Function, Function>;
+    allowJit: boolean;
+    evalContext?: IEvalContext;
+}
+export interface ISandboxGlobal {
+    [key: string]: unknown;
+}
+export interface ISymbolWhitelist {
+    [key: string]: symbol;
+}
+export interface SandboxSymbolContext {
+    ctor?: Function;
+    registry: Map<string, symbol>;
+    reverseRegistry: Map<symbol, string>;
+    whitelist: ISymbolWhitelist;
+}
+export type IGlobals = ISandboxGlobal;
+export interface IScope {
+    [key: string]: any;
+}
+export declare const NON_BLOCKING_THRESHOLD = 50000n;
+export declare const reservedWords: Set<string>;
+export declare const enum VarType {
+    let = "let",
+    const = "const",
+    var = "var",
+    internal = "internal"
+}
+export declare const enum LispType {
+    None = 0,
+    Prop = 1,
+    StringIndex = 2,
+    Let = 3,
+    Const = 4,
+    Call = 5,
+    KeyVal = 6,
+    Number = 7,
+    Return = 8,
+    Assign = 9,
+    InlineFunction = 10,
+    ArrowFunction = 11,
+    CreateArray = 12,
+    If = 13,
+    IfCase = 14,
+    InlineIf = 15,
+    InlineIfCase = 16,
+    SpreadObject = 17,
+    SpreadArray = 18,
+    ArrayProp = 19,
+    PropOptional = 20,
+    CallOptional = 21,
+    CreateObject = 22,
+    Group = 23,
+    Not = 24,
+    IncrementBefore = 25,
+    IncrementAfter = 26,
+    DecrementBefore = 27,
+    DecrementAfter = 28,
+    And = 29,
+    Or = 30,
+    StrictNotEqual = 31,
+    StrictEqual = 32,
+    Plus = 33,
+    Var = 34,
+    GlobalSymbol = 35,
+    Literal = 36,
+    Function = 37,
+    Loop = 38,
+    Try = 39,
+    Switch = 40,
+    SwitchCase = 41,
+    InternalBlock = 42,
+    Expression = 43,
+    Await = 44,
+    New = 45,
+    Throw = 46,
+    Minus = 47,
+    Divide = 48,
+    Power = 49,
+    Multiply = 50,
+    Modulus = 51,
+    Equal = 52,
+    NotEqual = 53,
+    SmallerEqualThan = 54,
+    LargerEqualThan = 55,
+    SmallerThan = 56,
+    LargerThan = 57,
+    Negative = 58,
+    Positive = 59,
+    Typeof = 60,
+    Delete = 61,
+    Instanceof = 62,
+    In = 63,
+    Inverse = 64,
+    SubractEquals = 65,
+    AddEquals = 66,
+    DivideEquals = 67,
+    PowerEquals = 68,
+    MultiplyEquals = 69,
+    ModulusEquals = 70,
+    BitNegateEquals = 71,
+    BitAndEquals = 72,
+    BitOrEquals = 73,
+    UnsignedShiftRightEquals = 74,
+    ShiftRightEquals = 75,
+    ShiftLeftEquals = 76,
+    BitAnd = 77,
+    BitOr = 78,
+    BitNegate = 79,
+    BitShiftLeft = 80,
+    BitShiftRight = 81,
+    BitUnsignedShiftRight = 82,
+    BigInt = 83,
+    LiteralIndex = 84,
+    RegexIndex = 85,
+    LoopAction = 86,
+    Void = 87,
+    True = 88,
+    NullishCoalescing = 89,
+    AndEquals = 90,
+    OrEquals = 91,
+    NullishCoalescingEquals = 92,
+    Block = 93,
+    Labeled = 94,
+    Internal = 95,
+    Yield = 96,
+    YieldDelegate = 97,
+    Hole = 98,
+    LispEnumSize = 99
+}

package/dist/esm/utils/types.js

@@ -0,0 +1,160 @@
+//#region src/utils/types.ts
+var AsyncFunction = Object.getPrototypeOf(async function() {}).constructor;
+var GeneratorFunction = Object.getPrototypeOf(function* () {}).constructor;
+var AsyncGeneratorFunction = Object.getPrototypeOf(async function* () {}).constructor;
+var NON_BLOCKING_THRESHOLD = 50000n;
+var reservedWords = new Set([
+	"await",
+	"break",
+	"case",
+	"catch",
+	"class",
+	"const",
+	"continue",
+	"debugger",
+	"default",
+	"delete",
+	"do",
+	"else",
+	"enum",
+	"export",
+	"extends",
+	"false",
+	"finally",
+	"for",
+	"function",
+	"if",
+	"implements",
+	"import",
+	"in",
+	"instanceof",
+	"let",
+	"new",
+	"null",
+	"return",
+	"super",
+	"switch",
+	"this",
+	"throw",
+	"true",
+	"try",
+	"typeof",
+	"var",
+	"void",
+	"while",
+	"with"
+]);
+var VarType = /* @__PURE__ */ function(VarType) {
+	VarType["let"] = "let";
+	VarType["const"] = "const";
+	VarType["var"] = "var";
+	VarType["internal"] = "internal";
+	return VarType;
+}({});
+var LispType = /* @__PURE__ */ function(LispType) {
+	LispType[LispType["None"] = 0] = "None";
+	LispType[LispType["Prop"] = 1] = "Prop";
+	LispType[LispType["StringIndex"] = 2] = "StringIndex";
+	LispType[LispType["Let"] = 3] = "Let";
+	LispType[LispType["Const"] = 4] = "Const";
+	LispType[LispType["Call"] = 5] = "Call";
+	LispType[LispType["KeyVal"] = 6] = "KeyVal";
+	LispType[LispType["Number"] = 7] = "Number";
+	LispType[LispType["Return"] = 8] = "Return";
+	LispType[LispType["Assign"] = 9] = "Assign";
+	LispType[LispType["InlineFunction"] = 10] = "InlineFunction";
+	LispType[LispType["ArrowFunction"] = 11] = "ArrowFunction";
+	LispType[LispType["CreateArray"] = 12] = "CreateArray";
+	LispType[LispType["If"] = 13] = "If";
+	LispType[LispType["IfCase"] = 14] = "IfCase";
+	LispType[LispType["InlineIf"] = 15] = "InlineIf";
+	LispType[LispType["InlineIfCase"] = 16] = "InlineIfCase";
+	LispType[LispType["SpreadObject"] = 17] = "SpreadObject";
+	LispType[LispType["SpreadArray"] = 18] = "SpreadArray";
+	LispType[LispType["ArrayProp"] = 19] = "ArrayProp";
+	LispType[LispType["PropOptional"] = 20] = "PropOptional";
+	LispType[LispType["CallOptional"] = 21] = "CallOptional";
+	LispType[LispType["CreateObject"] = 22] = "CreateObject";
+	LispType[LispType["Group"] = 23] = "Group";
+	LispType[LispType["Not"] = 24] = "Not";
+	LispType[LispType["IncrementBefore"] = 25] = "IncrementBefore";
+	LispType[LispType["IncrementAfter"] = 26] = "IncrementAfter";
+	LispType[LispType["DecrementBefore"] = 27] = "DecrementBefore";
+	LispType[LispType["DecrementAfter"] = 28] = "DecrementAfter";
+	LispType[LispType["And"] = 29] = "And";
+	LispType[LispType["Or"] = 30] = "Or";
+	LispType[LispType["StrictNotEqual"] = 31] = "StrictNotEqual";
+	LispType[LispType["StrictEqual"] = 32] = "StrictEqual";
+	LispType[LispType["Plus"] = 33] = "Plus";
+	LispType[LispType["Var"] = 34] = "Var";
+	LispType[LispType["GlobalSymbol"] = 35] = "GlobalSymbol";
+	LispType[LispType["Literal"] = 36] = "Literal";
+	LispType[LispType["Function"] = 37] = "Function";
+	LispType[LispType["Loop"] = 38] = "Loop";
+	LispType[LispType["Try"] = 39] = "Try";
+	LispType[LispType["Switch"] = 40] = "Switch";
+	LispType[LispType["SwitchCase"] = 41] = "SwitchCase";
+	LispType[LispType["InternalBlock"] = 42] = "InternalBlock";
+	LispType[LispType["Expression"] = 43] = "Expression";
+	LispType[LispType["Await"] = 44] = "Await";
+	LispType[LispType["New"] = 45] = "New";
+	LispType[LispType["Throw"] = 46] = "Throw";
+	LispType[LispType["Minus"] = 47] = "Minus";
+	LispType[LispType["Divide"] = 48] = "Divide";
+	LispType[LispType["Power"] = 49] = "Power";
+	LispType[LispType["Multiply"] = 50] = "Multiply";
+	LispType[LispType["Modulus"] = 51] = "Modulus";
+	LispType[LispType["Equal"] = 52] = "Equal";
+	LispType[LispType["NotEqual"] = 53] = "NotEqual";
+	LispType[LispType["SmallerEqualThan"] = 54] = "SmallerEqualThan";
+	LispType[LispType["LargerEqualThan"] = 55] = "LargerEqualThan";
+	LispType[LispType["SmallerThan"] = 56] = "SmallerThan";
+	LispType[LispType["LargerThan"] = 57] = "LargerThan";
+	LispType[LispType["Negative"] = 58] = "Negative";
+	LispType[LispType["Positive"] = 59] = "Positive";
+	LispType[LispType["Typeof"] = 60] = "Typeof";
+	LispType[LispType["Delete"] = 61] = "Delete";
+	LispType[LispType["Instanceof"] = 62] = "Instanceof";
+	LispType[LispType["In"] = 63] = "In";
+	LispType[LispType["Inverse"] = 64] = "Inverse";
+	LispType[LispType["SubractEquals"] = 65] = "SubractEquals";
+	LispType[LispType["AddEquals"] = 66] = "AddEquals";
+	LispType[LispType["DivideEquals"] = 67] = "DivideEquals";
+	LispType[LispType["PowerEquals"] = 68] = "PowerEquals";
+	LispType[LispType["MultiplyEquals"] = 69] = "MultiplyEquals";
+	LispType[LispType["ModulusEquals"] = 70] = "ModulusEquals";
+	LispType[LispType["BitNegateEquals"] = 71] = "BitNegateEquals";
+	LispType[LispType["BitAndEquals"] = 72] = "BitAndEquals";
+	LispType[LispType["BitOrEquals"] = 73] = "BitOrEquals";
+	LispType[LispType["UnsignedShiftRightEquals"] = 74] = "UnsignedShiftRightEquals";
+	LispType[LispType["ShiftRightEquals"] = 75] = "ShiftRightEquals";
+	LispType[LispType["ShiftLeftEquals"] = 76] = "ShiftLeftEquals";
+	LispType[LispType["BitAnd"] = 77] = "BitAnd";
+	LispType[LispType["BitOr"] = 78] = "BitOr";
+	LispType[LispType["BitNegate"] = 79] = "BitNegate";
+	LispType[LispType["BitShiftLeft"] = 80] = "BitShiftLeft";
+	LispType[LispType["BitShiftRight"] = 81] = "BitShiftRight";
+	LispType[LispType["BitUnsignedShiftRight"] = 82] = "BitUnsignedShiftRight";
+	LispType[LispType["BigInt"] = 83] = "BigInt";
+	LispType[LispType["LiteralIndex"] = 84] = "LiteralIndex";
+	LispType[LispType["RegexIndex"] = 85] = "RegexIndex";
+	LispType[LispType["LoopAction"] = 86] = "LoopAction";
+	LispType[LispType["Void"] = 87] = "Void";
+	LispType[LispType["True"] = 88] = "True";
+	LispType[LispType["NullishCoalescing"] = 89] = "NullishCoalescing";
+	LispType[LispType["AndEquals"] = 90] = "AndEquals";
+	LispType[LispType["OrEquals"] = 91] = "OrEquals";
+	LispType[LispType["NullishCoalescingEquals"] = 92] = "NullishCoalescingEquals";
+	LispType[LispType["Block"] = 93] = "Block";
+	LispType[LispType["Labeled"] = 94] = "Labeled";
+	LispType[LispType["Internal"] = 95] = "Internal";
+	LispType[LispType["Yield"] = 96] = "Yield";
+	LispType[LispType["YieldDelegate"] = 97] = "YieldDelegate";
+	LispType[LispType["Hole"] = 98] = "Hole";
+	LispType[LispType["LispEnumSize"] = 99] = "LispEnumSize";
+	return LispType;
+}({});
+//#endregion
+export { AsyncFunction, AsyncGeneratorFunction, GeneratorFunction, LispType, NON_BLOCKING_THRESHOLD, VarType, reservedWords };
+
+//# sourceMappingURL=types.js.map

package/dist/esm/utils/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","names":[],"sources":["../../../src/utils/types.ts"],"sourcesContent":["// Reusable AsyncFunction constructor references\nexport const AsyncFunction: Function = Object.getPrototypeOf(async function () {}).constructor;\nexport const GeneratorFunction: Function = Object.getPrototypeOf(function* () {}).constructor;\nexport const AsyncGeneratorFunction: Function = Object.getPrototypeOf(\n  async function* () {},\n).constructor;\n\nimport type { IEvalContext } from '../eval';\nimport type { Change } from '../executor';\nimport type { IExecutionTree } from '../parser';\nimport type SandboxExec from '../SandboxExec';\nimport type { Scope } from './Scope';\n\nexport interface IOptionParams {\n  audit?: boolean;\n  forbidFunctionCalls?: boolean;\n  forbidFunctionCreation?: boolean;\n  prototypeWhitelist?: Map<Function, Set<string>>;\n  globals?: IGlobals;\n  symbolWhitelist?: ISymbolWhitelist;\n  executionQuota?: bigint;\n  nonBlocking?: boolean;\n  haltOnSandboxError?: boolean;\n  maxParserRecursionDepth?: number;\n  /**\n   * Additional function replacements to merge with the built-in tick-checking replacements.\n   * Maps a native function to a factory that receives the IContext and returns the replacement.\n   * When sandboxed code accesses a property that returns a mapped function, the factory is\n   * called once per context and the result is cached and returned instead.\n   */\n  functionReplacements?: Map<Function, (ctx: IContext) => Function>;\n}\n\nexport interface IOptions {\n  audit: boolean;\n  forbidFunctionCalls: boolean;\n  forbidFunctionCreation: boolean;\n  prototypeWhitelist: Map<Function, Set<PropertyKey>>;\n  globals: IGlobals;\n  symbolWhitelist: ISymbolWhitelist;\n  executionQuota?: bigint;\n  haltOnSandboxError?: boolean;\n  maxParserRecursionDepth: number;\n  nonBlocking: boolean;\n  functionReplacements: Map<\n    Function,\n    (ctx: IExecContext, builtInReplacement?: Function) => Function\n  >;\n}\n\nexport interface IContext {\n  sandbox: SandboxExec;\n  globalScope: Scope;\n  sandboxGlobal: ISandboxGlobal;\n  globalsWhitelist: Set<any>;\n  prototypeWhitelist: Map<any, Set<PropertyKey>>;\n  sandboxedFunctions: WeakSet<Function>;\n  sandboxSymbols: SandboxSymbolContext;\n  options: IOptions;\n  auditReport?: IAuditReport;\n  ticks: Ticks;\n}\n\nexport interface IAuditReport {\n  globalsAccess: Set<unknown>;\n  prototypeAccess: { [name: string]: Set<PropertyKey> };\n}\n\nexport interface Ticks {\n  ticks: bigint;\n  tickLimit?: bigint;\n  nextYield?: bigint;\n}\n\nexport type SubscriptionSubject = object;\n\nexport type HaltContext =\n  | {\n      type: 'error';\n      error: Error;\n      ticks: Ticks;\n      scope: Scope;\n      context: IExecContext;\n    }\n  | {\n      type: 'manual';\n      error?: never;\n      ticks?: never;\n      scope?: never;\n      context?: never;\n    }\n  | {\n      type: 'yield';\n      error?: never;\n      ticks?: never;\n      scope?: never;\n      context?: never;\n    };\n\nexport interface IExecContext extends IExecutionTree {\n  ctx: IContext;\n  getSubscriptions: Set<(obj: SubscriptionSubject, name: string) => void>;\n  setSubscriptions: WeakMap<SubscriptionSubject, Map<string, Set<(modification: Change) => void>>>;\n  changeSubscriptions: WeakMap<SubscriptionSubject, Set<(modification: Change) => void>>;\n  setSubscriptionsGlobal: WeakMap<\n    SubscriptionSubject,\n    Map<string, Set<(modification: Change) => void>>\n  >;\n  changeSubscriptionsGlobal: WeakMap<SubscriptionSubject, Set<(modification: Change) => void>>;\n  registerSandboxFunction: (fn: (...args: any[]) => any) => void;\n  evals: Map<Function, Function>;\n  allowJit: boolean;\n  evalContext?: IEvalContext;\n}\n\nexport interface ISandboxGlobal {\n  [key: string]: unknown;\n}\n\nexport interface ISymbolWhitelist {\n  [key: string]: symbol;\n}\n\nexport interface SandboxSymbolContext {\n  ctor?: Function;\n  registry: Map<string, symbol>;\n  reverseRegistry: Map<symbol, string>;\n  whitelist: ISymbolWhitelist;\n}\n\nexport type IGlobals = ISandboxGlobal;\n\nexport interface IScope {\n  [key: string]: any;\n}\n\nexport const NON_BLOCKING_THRESHOLD = 50_000n;\n\nexport const reservedWords = new Set([\n  'await',\n  'break',\n  'case',\n  'catch',\n  'class',\n  'const',\n  'continue',\n  'debugger',\n  'default',\n  'delete',\n  'do',\n  'else',\n  'enum',\n  'export',\n  'extends',\n  'false',\n  'finally',\n  'for',\n  'function',\n  'if',\n  'implements',\n  'import',\n  'in',\n  'instanceof',\n  'let',\n  'new',\n  'null',\n  'return',\n  'super',\n  'switch',\n  'this',\n  'throw',\n  'true',\n  'try',\n  'typeof',\n  'var',\n  'void',\n  'while',\n  'with',\n]);\n\nexport const enum VarType {\n  let = 'let',\n  const = 'const',\n  var = 'var',\n  internal = 'internal',\n}\n\nexport const enum LispType {\n  None,\n  Prop,\n  StringIndex,\n  Let,\n  Const,\n  Call,\n  KeyVal,\n  Number,\n  Return,\n  Assign,\n  InlineFunction,\n  ArrowFunction,\n  CreateArray,\n  If,\n  IfCase,\n  InlineIf,\n  InlineIfCase,\n  SpreadObject,\n  SpreadArray,\n  ArrayProp,\n  PropOptional,\n  CallOptional,\n  CreateObject,\n  Group,\n  Not,\n  IncrementBefore,\n  IncrementAfter,\n  DecrementBefore,\n  DecrementAfter,\n  And,\n  Or,\n  StrictNotEqual,\n  StrictEqual,\n  Plus,\n  Var,\n  GlobalSymbol,\n  Literal,\n  Function,\n  Loop,\n  Try,\n  Switch,\n  SwitchCase,\n  InternalBlock,\n  Expression,\n  Await,\n  New,\n  Throw,\n  Minus,\n  Divide,\n  Power,\n  Multiply,\n  Modulus,\n  Equal,\n  NotEqual,\n  SmallerEqualThan,\n  LargerEqualThan,\n  SmallerThan,\n  LargerThan,\n  Negative,\n  Positive,\n  Typeof,\n  Delete,\n  Instanceof,\n  In,\n  Inverse,\n  SubractEquals,\n  AddEquals,\n  DivideEquals,\n  PowerEquals,\n  MultiplyEquals,\n  ModulusEquals,\n  BitNegateEquals,\n  BitAndEquals,\n  BitOrEquals,\n  UnsignedShiftRightEquals,\n  ShiftRightEquals,\n  ShiftLeftEquals,\n  BitAnd,\n  BitOr,\n  BitNegate,\n  BitShiftLeft,\n  BitShiftRight,\n  BitUnsignedShiftRight,\n  BigInt,\n  LiteralIndex,\n  RegexIndex,\n  LoopAction,\n  Void,\n  True,\n  NullishCoalescing,\n  AndEquals,\n  OrEquals,\n  NullishCoalescingEquals,\n  Block,\n  Labeled,\n  Internal,\n  Yield,\n  YieldDelegate,\n  Hole,\n\n  LispEnumSize,\n}\n"],"mappings":";AACA,IAAa,gBAA0B,OAAO,eAAe,iBAAkB,GAAG,CAAC;AACnF,IAAa,oBAA8B,OAAO,eAAe,aAAa,GAAG,CAAC;AAClF,IAAa,yBAAmC,OAAO,eACrD,mBAAmB,GACpB,CAAC;AAmIF,IAAa,yBAAyB;AAEtC,IAAa,gBAAgB,IAAI,IAAI;CACnC;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACD,CAAC;AAEF,IAAkB,UAAX,yBAAA,SAAA;AACL,SAAA,SAAA;AACA,SAAA,WAAA;AACA,SAAA,SAAA;AACA,SAAA,cAAA;;KACD;AAED,IAAkB,WAAX,yBAAA,UAAA;AACL,UAAA,SAAA,UAAA,KAAA;AACA,UAAA,SAAA,UAAA,KAAA;AACA,UAAA,SAAA,iBAAA,KAAA;AACA,UAAA,SAAA,SAAA,KAAA;AACA,UAAA,SAAA,WAAA,KAAA;AACA,UAAA,SAAA,UAAA,KAAA;AACA,UAAA,SAAA,YAAA,KAAA;AACA,UAAA,SAAA,YAAA,KAAA;AACA,UAAA,SAAA,YAAA,KAAA;AACA,UAAA,SAAA,YAAA,KAAA;AACA,UAAA,SAAA,oBAAA,MAAA;AACA,UAAA,SAAA,mBAAA,MAAA;AACA,UAAA,SAAA,iBAAA,MAAA;AACA,UAAA,SAAA,QAAA,MAAA;AACA,UAAA,SAAA,YAAA,MAAA;AACA,UAAA,SAAA,cAAA,MAAA;AACA,UAAA,SAAA,kBAAA,MAAA;AACA,UAAA,SAAA,kBAAA,MAAA;AACA,UAAA,SAAA,iBAAA,MAAA;AACA,UAAA,SAAA,eAAA,MAAA;AACA,UAAA,SAAA,kBAAA,MAAA;AACA,UAAA,SAAA,kBAAA,MAAA;AACA,UAAA,SAAA,kBAAA,MAAA;AACA,UAAA,SAAA,WAAA,MAAA;AACA,UAAA,SAAA,SAAA,MAAA;AACA,UAAA,SAAA,qBAAA,MAAA;AACA,UAAA,SAAA,oBAAA,MAAA;AACA,UAAA,SAAA,qBAAA,MAAA;AACA,UAAA,SAAA,oBAAA,MAAA;AACA,UAAA,SAAA,SAAA,MAAA;AACA,UAAA,SAAA,QAAA,MAAA;AACA,UAAA,SAAA,oBAAA,MAAA;AACA,UAAA,SAAA,iBAAA,MAAA;AACA,UAAA,SAAA,UAAA,MAAA;AACA,UAAA,SAAA,SAAA,MAAA;AACA,UAAA,SAAA,kBAAA,MAAA;AACA,UAAA,SAAA,aAAA,MAAA;AACA,UAAA,SAAA,cAAA,MAAA;AACA,UAAA,SAAA,UAAA,MAAA;AACA,UAAA,SAAA,SAAA,MAAA;AACA,UAAA,SAAA,YAAA,MAAA;AACA,UAAA,SAAA,gBAAA,MAAA;AACA,UAAA,SAAA,mBAAA,MAAA;AACA,UAAA,SAAA,gBAAA,MAAA;AACA,UAAA,SAAA,WAAA,MAAA;AACA,UAAA,SAAA,SAAA,MAAA;AACA,UAAA,SAAA,WAAA,MAAA;AACA,UAAA,SAAA,WAAA,MAAA;AACA,UAAA,SAAA,YAAA,MAAA;AACA,UAAA,SAAA,WAAA,MAAA;AACA,UAAA,SAAA,cAAA,MAAA;AACA,UAAA,SAAA,aAAA,MAAA;AACA,UAAA,SAAA,WAAA,MAAA;AACA,UAAA,SAAA,cAAA,MAAA;AACA,UAAA,SAAA,sBAAA,MAAA;AACA,UAAA,SAAA,qBAAA,MAAA;AACA,UAAA,SAAA,iBAAA,MAAA;AACA,UAAA,SAAA,gBAAA,MAAA;AACA,UAAA,SAAA,cAAA,MAAA;AACA,UAAA,SAAA,cAAA,MAAA;AACA,UAAA,SAAA,YAAA,MAAA;AACA,UAAA,SAAA,YAAA,MAAA;AACA,UAAA,SAAA,gBAAA,MAAA;AACA,UAAA,SAAA,QAAA,MAAA;AACA,UAAA,SAAA,aAAA,MAAA;AACA,UAAA,SAAA,mBAAA,MAAA;AACA,UAAA,SAAA,eAAA,MAAA;AACA,UAAA,SAAA,kBAAA,MAAA;AACA,UAAA,SAAA,iBAAA,MAAA;AACA,UAAA,SAAA,oBAAA,MAAA;AACA,UAAA,SAAA,mBAAA,MAAA;AACA,UAAA,SAAA,qBAAA,MAAA;AACA,UAAA,SAAA,kBAAA,MAAA;AACA,UAAA,SAAA,iBAAA,MAAA;AACA,UAAA,SAAA,8BAAA,MAAA;AACA,UAAA,SAAA,sBAAA,MAAA;AACA,UAAA,SAAA,qBAAA,MAAA;AACA,UAAA,SAAA,YAAA,MAAA;AACA,UAAA,SAAA,WAAA,MAAA;AACA,UAAA,SAAA,eAAA,MAAA;AACA,UAAA,SAAA,kBAAA,MAAA;AACA,UAAA,SAAA,mBAAA,MAAA;AACA,UAAA,SAAA,2BAAA,MAAA;AACA,UAAA,SAAA,YAAA,MAAA;AACA,UAAA,SAAA,kBAAA,MAAA;AACA,UAAA,SAAA,gBAAA,MAAA;AACA,UAAA,SAAA,gBAAA,MAAA;AACA,UAAA,SAAA,UAAA,MAAA;AACA,UAAA,SAAA,UAAA,MAAA;AACA,UAAA,SAAA,uBAAA,MAAA;AACA,UAAA,SAAA,eAAA,MAAA;AACA,UAAA,SAAA,cAAA,MAAA;AACA,UAAA,SAAA,6BAAA,MAAA;AACA,UAAA,SAAA,WAAA,MAAA;AACA,UAAA,SAAA,aAAA,MAAA;AACA,UAAA,SAAA,cAAA,MAAA;AACA,UAAA,SAAA,WAAA,MAAA;AACA,UAAA,SAAA,mBAAA,MAAA;AACA,UAAA,SAAA,UAAA,MAAA;AAEA,UAAA,SAAA,kBAAA,MAAA;;KACD"}

package/dist/esm/utils/unraw.js

@@ -0,0 +1,147 @@
+//#region src/utils/unraw.ts
+/**
+* Parse a string as a base-16 number. This is more strict than `parseInt` as it
+* will not allow any other characters, including (for example) "+", "-", and
+* ".".
+* @param hex A string containing a hexadecimal number.
+* @returns The parsed integer, or `NaN` if the string is not a valid hex
+* number.
+*/
+function parseHexToInt(hex) {
+	return !hex.match(/[^a-f0-9]/i) ? parseInt(hex, 16) : NaN;
+}
+/**
+* Check the validity and length of a hexadecimal code and optionally enforces
+* a specific number of hex digits.
+* @param hex The string to validate and parse.
+* @param errorName The name of the error message to throw a `SyntaxError` with
+* if `hex` is invalid. This is used to index `errorMessages`.
+* @param enforcedLength If provided, will throw an error if `hex` is not
+* exactly this many characters.
+* @returns The parsed hex number as a normal number.
+* @throws {SyntaxError} If the code is not valid.
+*/
+function validateAndParseHex(hex, errorName, enforcedLength) {
+	const parsedHex = parseHexToInt(hex);
+	if (Number.isNaN(parsedHex) || enforcedLength !== void 0 && enforcedLength !== hex.length) throw new SyntaxError(errorName + ": " + hex);
+	return parsedHex;
+}
+/**
+* Parse a two-digit hexadecimal character escape code.
+* @param code The two-digit hexadecimal number that represents the character to
+* output.
+* @returns The single character represented by the code.
+* @throws {SyntaxError} If the code is not valid hex or is not the right
+* length.
+*/
+function parseHexadecimalCode(code) {
+	const parsedCode = validateAndParseHex(code, "Malformed Hexadecimal", 2);
+	return String.fromCharCode(parsedCode);
+}
+/**
+* Parse a four-digit Unicode character escape code.
+* @param code The four-digit unicode number that represents the character to
+* output.
+* @param surrogateCode Optional four-digit unicode surrogate that represents
+* the other half of the character to output.
+* @returns The single character represented by the code.
+* @throws {SyntaxError} If the codes are not valid hex or are not the right
+* length.
+*/
+function parseUnicodeCode(code, surrogateCode) {
+	const parsedCode = validateAndParseHex(code, "Malformed Unicode", 4);
+	if (surrogateCode !== void 0) {
+		const parsedSurrogateCode = validateAndParseHex(surrogateCode, "Malformed Unicode", 4);
+		return String.fromCharCode(parsedCode, parsedSurrogateCode);
+	}
+	return String.fromCharCode(parsedCode);
+}
+/**
+* Test if the text is surrounded by curly braces (`{}`).
+* @param text Text to check.
+* @returns `true` if the text is in the form `{*}`.
+*/
+function isCurlyBraced(text) {
+	return text.charAt(0) === "{" && text.charAt(text.length - 1) === "}";
+}
+/**
+* Parse a Unicode code point character escape code.
+* @param codePoint A unicode escape code point, including the surrounding curly
+* braces.
+* @returns The single character represented by the code.
+* @throws {SyntaxError} If the code is not valid hex or does not have the
+* surrounding curly braces.
+*/
+function parseUnicodeCodePointCode(codePoint) {
+	if (!isCurlyBraced(codePoint)) throw new SyntaxError("Malformed Unicode: +" + codePoint);
+	const parsedCode = validateAndParseHex(codePoint.slice(1, -1), "Malformed Unicode");
+	try {
+		return String.fromCodePoint(parsedCode);
+	} catch (err) {
+		throw err instanceof RangeError ? /* @__PURE__ */ new SyntaxError("Code Point Limit:" + parsedCode) : err;
+	}
+}
+/**
+* Map of unescaped letters to their corresponding special JS escape characters.
+* Intentionally does not include characters that map to themselves like "\'".
+*/
+var singleCharacterEscapes = new Map([
+	["b", "\b"],
+	["f", "\f"],
+	["n", "\n"],
+	["r", "\r"],
+	["t", "	"],
+	["v", "\v"],
+	["0", "\0"]
+]);
+/**
+* Parse a single character escape sequence and return the matching character.
+* If none is matched, defaults to `code`.
+* @param code A single character code.
+*/
+function parseSingleCharacterCode(code) {
+	return singleCharacterEscapes.get(code) || code;
+}
+/**
+* Matches every escape sequence possible, including invalid ones.
+*
+* All capture groups (described below) are unique (only one will match), except
+* for 4, which can only potentially match if 3 does.
+*
+* **Capture Groups:**
+* 0. A single backslash
+* 1. Hexadecimal code
+* 2. Unicode code point code with surrounding curly braces
+* 3. Unicode escape code with surrogate
+* 4. Surrogate code
+* 5. Unicode escape code without surrogate
+* 6. Octal code _NOTE: includes "0"._
+* 7. A single character (will never be \, x, u, or 0-3)
+*/
+var escapeMatch = /\\(?:(\\)|x([\s\S]{0,2})|u(\{[^}]*\}?)|u([\s\S]{4})\\u([^{][\s\S]{0,3})|u([\s\S]{0,4})|([0-3]?[0-7]{1,2})|([\s\S])|$)/g;
+/**
+* Replace raw escape character strings with their escape characters.
+* @param raw A string where escape characters are represented as raw string
+* values like `\'` rather than `'`.
+* @param allowOctals If `true`, will process the now-deprecated octal escape
+* sequences (ie, `\111`).
+* @returns The processed string, with escape characters replaced by their
+* respective actual Unicode characters.
+*/
+function unraw(raw) {
+	return raw.replace(escapeMatch, function(_, backslash, hex, codePoint, unicodeWithSurrogate, surrogate, unicode, octal, singleCharacter) {
+		if (backslash !== void 0) return "\\";
+		if (hex !== void 0) return parseHexadecimalCode(hex);
+		if (codePoint !== void 0) return parseUnicodeCodePointCode(codePoint);
+		if (unicodeWithSurrogate !== void 0) return parseUnicodeCode(unicodeWithSurrogate, surrogate);
+		if (unicode !== void 0) return parseUnicodeCode(unicode);
+		if (octal === "0") return "\0";
+		if (octal !== void 0) throw new SyntaxError("Octal Deprecation: " + octal);
+		if (singleCharacter !== void 0) return parseSingleCharacterCode(singleCharacter);
+		throw new SyntaxError("End of string");
+	});
+}
+//#endregion
+export { unraw as default };
+
+//# sourceMappingURL=unraw.js.map

package/dist/esm/utils/unraw.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"unraw.js","names":[],"sources":["../../../src/utils/unraw.ts"],"sourcesContent":["/**\n * Parse a string as a base-16 number. This is more strict than `parseInt` as it\n * will not allow any other characters, including (for example) \"+\", \"-\", and\n * \".\".\n * @param hex A string containing a hexadecimal number.\n * @returns The parsed integer, or `NaN` if the string is not a valid hex\n * number.\n */\nfunction parseHexToInt(hex: string): number {\n  const isOnlyHexChars = !hex.match(/[^a-f0-9]/i);\n  return isOnlyHexChars ? parseInt(hex, 16) : NaN;\n}\n\n/**\n * Check the validity and length of a hexadecimal code and optionally enforces\n * a specific number of hex digits.\n * @param hex The string to validate and parse.\n * @param errorName The name of the error message to throw a `SyntaxError` with\n * if `hex` is invalid. This is used to index `errorMessages`.\n * @param enforcedLength If provided, will throw an error if `hex` is not\n * exactly this many characters.\n * @returns The parsed hex number as a normal number.\n * @throws {SyntaxError} If the code is not valid.\n */\nfunction validateAndParseHex(hex: string, errorName: string, enforcedLength?: number): number {\n  const parsedHex = parseHexToInt(hex);\n  if (Number.isNaN(parsedHex) || (enforcedLength !== undefined && enforcedLength !== hex.length)) {\n    throw new SyntaxError(errorName + ': ' + hex);\n  }\n  return parsedHex;\n}\n\n/**\n * Parse a two-digit hexadecimal character escape code.\n * @param code The two-digit hexadecimal number that represents the character to\n * output.\n * @returns The single character represented by the code.\n * @throws {SyntaxError} If the code is not valid hex or is not the right\n * length.\n */\nfunction parseHexadecimalCode(code: string): string {\n  const parsedCode = validateAndParseHex(code, 'Malformed Hexadecimal', 2);\n  return String.fromCharCode(parsedCode);\n}\n\n/**\n * Parse a four-digit Unicode character escape code.\n * @param code The four-digit unicode number that represents the character to\n * output.\n * @param surrogateCode Optional four-digit unicode surrogate that represents\n * the other half of the character to output.\n * @returns The single character represented by the code.\n * @throws {SyntaxError} If the codes are not valid hex or are not the right\n * length.\n */\nfunction parseUnicodeCode(code: string, surrogateCode?: string): string {\n  const parsedCode = validateAndParseHex(code, 'Malformed Unicode', 4);\n\n  if (surrogateCode !== undefined) {\n    const parsedSurrogateCode = validateAndParseHex(surrogateCode, 'Malformed Unicode', 4);\n    return String.fromCharCode(parsedCode, parsedSurrogateCode);\n  }\n\n  return String.fromCharCode(parsedCode);\n}\n\n/**\n * Test if the text is surrounded by curly braces (`{}`).\n * @param text Text to check.\n * @returns `true` if the text is in the form `{*}`.\n */\nfunction isCurlyBraced(text: string): boolean {\n  return text.charAt(0) === '{' && text.charAt(text.length - 1) === '}';\n}\n\n/**\n * Parse a Unicode code point character escape code.\n * @param codePoint A unicode escape code point, including the surrounding curly\n * braces.\n * @returns The single character represented by the code.\n * @throws {SyntaxError} If the code is not valid hex or does not have the\n * surrounding curly braces.\n */\nfunction parseUnicodeCodePointCode(codePoint: string): string {\n  if (!isCurlyBraced(codePoint)) {\n    throw new SyntaxError('Malformed Unicode: +' + codePoint);\n  }\n  const withoutBraces = codePoint.slice(1, -1);\n  const parsedCode = validateAndParseHex(withoutBraces, 'Malformed Unicode');\n\n  try {\n    return String.fromCodePoint(parsedCode);\n  } catch (err) {\n    throw err instanceof RangeError ? new SyntaxError('Code Point Limit:' + parsedCode) : err;\n  }\n}\n\n/**\n * Map of unescaped letters to their corresponding special JS escape characters.\n * Intentionally does not include characters that map to themselves like \"\\'\".\n */\nconst singleCharacterEscapes = new Map<string, string>([\n  ['b', '\\b'],\n  ['f', '\\f'],\n  ['n', '\\n'],\n  ['r', '\\r'],\n  ['t', '\\t'],\n  ['v', '\\v'],\n  ['0', '\\0'],\n]);\n\n/**\n * Parse a single character escape sequence and return the matching character.\n * If none is matched, defaults to `code`.\n * @param code A single character code.\n */\nfunction parseSingleCharacterCode(code: string): string {\n  return singleCharacterEscapes.get(code) || code;\n}\n\n/**\n * Matches every escape sequence possible, including invalid ones.\n *\n * All capture groups (described below) are unique (only one will match), except\n * for 4, which can only potentially match if 3 does.\n *\n * **Capture Groups:**\n * 0. A single backslash\n * 1. Hexadecimal code\n * 2. Unicode code point code with surrounding curly braces\n * 3. Unicode escape code with surrogate\n * 4. Surrogate code\n * 5. Unicode escape code without surrogate\n * 6. Octal code _NOTE: includes \"0\"._\n * 7. A single character (will never be \\, x, u, or 0-3)\n */\nconst escapeMatch =\n  /\\\\(?:(\\\\)|x([\\s\\S]{0,2})|u(\\{[^}]*\\}?)|u([\\s\\S]{4})\\\\u([^{][\\s\\S]{0,3})|u([\\s\\S]{0,4})|([0-3]?[0-7]{1,2})|([\\s\\S])|$)/g;\n\n/**\n * Replace raw escape character strings with their escape characters.\n * @param raw A string where escape characters are represented as raw string\n * values like `\\'` rather than `'`.\n * @param allowOctals If `true`, will process the now-deprecated octal escape\n * sequences (ie, `\\111`).\n * @returns The processed string, with escape characters replaced by their\n * respective actual Unicode characters.\n */\nexport function unraw(raw: string): string {\n  return raw.replace(\n    escapeMatch,\n    function (\n      _,\n      backslash?: string,\n      hex?: string,\n      codePoint?: string,\n      unicodeWithSurrogate?: string,\n      surrogate?: string,\n      unicode?: string,\n      octal?: string,\n      singleCharacter?: string,\n    ): string {\n      // Compare groups to undefined because empty strings mean different errors\n      // Otherwise, `\\u` would fail the same as `\\` which is wrong.\n      if (backslash !== undefined) {\n        return '\\\\';\n      }\n      if (hex !== undefined) {\n        return parseHexadecimalCode(hex);\n      }\n      if (codePoint !== undefined) {\n        return parseUnicodeCodePointCode(codePoint);\n      }\n      if (unicodeWithSurrogate !== undefined) {\n        return parseUnicodeCode(unicodeWithSurrogate, surrogate);\n      }\n      if (unicode !== undefined) {\n        return parseUnicodeCode(unicode);\n      }\n      if (octal === '0') {\n        return '\\0';\n      }\n      if (octal !== undefined) {\n        throw new SyntaxError('Octal Deprecation: ' + octal);\n      }\n      if (singleCharacter !== undefined) {\n        return parseSingleCharacterCode(singleCharacter);\n      }\n      throw new SyntaxError('End of string');\n    },\n  );\n}\nexport default unraw;\n"],"mappings":";;;;;;;;;AAQA,SAAS,cAAc,KAAqB;AAE1C,QADuB,CAAC,IAAI,MAAM,aAAa,GACvB,SAAS,KAAK,GAAG,GAAG;;;;;;;;;;;;;AAc9C,SAAS,oBAAoB,KAAa,WAAmB,gBAAiC;CAC5F,MAAM,YAAY,cAAc,IAAI;AACpC,KAAI,OAAO,MAAM,UAAU,IAAK,mBAAmB,KAAA,KAAa,mBAAmB,IAAI,OACrF,OAAM,IAAI,YAAY,YAAY,OAAO,IAAI;AAE/C,QAAO;;;;;;;;;;AAWT,SAAS,qBAAqB,MAAsB;CAClD,MAAM,aAAa,oBAAoB,MAAM,yBAAyB,EAAE;AACxE,QAAO,OAAO,aAAa,WAAW;;;;;;;;;;;;AAaxC,SAAS,iBAAiB,MAAc,eAAgC;CACtE,MAAM,aAAa,oBAAoB,MAAM,qBAAqB,EAAE;AAEpE,KAAI,kBAAkB,KAAA,GAAW;EAC/B,MAAM,sBAAsB,oBAAoB,eAAe,qBAAqB,EAAE;AACtF,SAAO,OAAO,aAAa,YAAY,oBAAoB;;AAG7D,QAAO,OAAO,aAAa,WAAW;;;;;;;AAQxC,SAAS,cAAc,MAAuB;AAC5C,QAAO,KAAK,OAAO,EAAE,KAAK,OAAO,KAAK,OAAO,KAAK,SAAS,EAAE,KAAK;;;;;;;;;;AAWpE,SAAS,0BAA0B,WAA2B;AAC5D,KAAI,CAAC,cAAc,UAAU,CAC3B,OAAM,IAAI,YAAY,yBAAyB,UAAU;CAG3D,MAAM,aAAa,oBADG,UAAU,MAAM,GAAG,GAAG,EACU,oBAAoB;AAE1E,KAAI;AACF,SAAO,OAAO,cAAc,WAAW;UAChC,KAAK;AACZ,QAAM,eAAe,6BAAa,IAAI,YAAY,sBAAsB,WAAW,GAAG;;;;;;;AAQ1F,IAAM,yBAAyB,IAAI,IAAoB;CACrD,CAAC,KAAK,KAAK;CACX,CAAC,KAAK,KAAK;CACX,CAAC,KAAK,KAAK;CACX,CAAC,KAAK,KAAK;CACX,CAAC,KAAK,IAAK;CACX,CAAC,KAAK,KAAK;CACX,CAAC,KAAK,KAAK;CACZ,CAAC;;;;;;AAOF,SAAS,yBAAyB,MAAsB;AACtD,QAAO,uBAAuB,IAAI,KAAK,IAAI;;;;;;;;;;;;;;;;;;AAmB7C,IAAM,cACJ;;;;;;;;;;AAWF,SAAgB,MAAM,KAAqB;AACzC,QAAO,IAAI,QACT,aACA,SACE,GACA,WACA,KACA,WACA,sBACA,WACA,SACA,OACA,iBACQ;AAGR,MAAI,cAAc,KAAA,EAChB,QAAO;AAET,MAAI,QAAQ,KAAA,EACV,QAAO,qBAAqB,IAAI;AAElC,MAAI,cAAc,KAAA,EAChB,QAAO,0BAA0B,UAAU;AAE7C,MAAI,yBAAyB,KAAA,EAC3B,QAAO,iBAAiB,sBAAsB,UAAU;AAE1D,MAAI,YAAY,KAAA,EACd,QAAO,iBAAiB,QAAQ;AAElC,MAAI,UAAU,IACZ,QAAO;AAET,MAAI,UAAU,KAAA,EACZ,OAAM,IAAI,YAAY,wBAAwB,MAAM;AAEtD,MAAI,oBAAoB,KAAA,EACtB,QAAO,yBAAyB,gBAAgB;AAElD,QAAM,IAAI,YAAY,gBAAgB;GAEzC"}