SYMBOL INDEX (353 symbols across 32 files)

FILE: examples/ollama/index.mjs
  function getEmbedding (line 16) | async function getEmbedding(prompt) {
  function insertMovie (line 25) | async function insertMovie(id, title, description) {
  function insertMovieIfNotExists (line 34) | async function insertMovieIfNotExists(id, title, description) {
  function findSimilarMovies (line 48) | async function findSimilarMovies(description, limit = 3) {

FILE: packages/libsql-client-wasm/examples/browser/index.js
  function main (line 3) | async function main() {

FILE: packages/libsql-client-wasm/examples/node/index.js
  function main (line 3) | async function main() {

FILE: packages/libsql-client-wasm/src/wasm.ts
  function createClient (line 36) | function createClient(config: Config): Client {
  function _createClient (line 41) | function _createClient(config: ExpandedConfig): Client {
  function inTransaction (line 98) | function inTransaction(db: Database): boolean {
  class Sqlite3Client (line 102) | class Sqlite3Client implements Client {
    method constructor (line 111) | constructor(
    method execute (line 126) | async execute(
    method batch (line 145) | async batch(
    method migrate (line 171) | async migrate(stmts: Array<InStatement>): Promise<Array<ResultSet>> {
    method transaction (line 196) | async transaction(mode: TransactionMode = "write"): Promise<Transactio...
    method executeMultiple (line 203) | async executeMultiple(sql: string): Promise<void> {
    method sync (line 215) | async sync(): Promise<Replicated> {
    method reconnect (line 222) | async reconnect(): Promise<void> {
    method close (line 233) | close(): void {
    method #checkNotClosed (line 241) | #checkNotClosed(): void {
    method #getDb (line 248) | #getDb(): Database {
  class Sqlite3Transaction (line 256) | class Sqlite3Transaction implements Transaction {
    method constructor (line 261) | constructor(database: Database, intMode: IntMode) {
    method execute (line 266) | async execute(stmt: InStatement): Promise<ResultSet> {
    method batch (line 271) | async batch(stmts: Array<InStatement>): Promise<Array<ResultSet>> {
    method executeMultiple (line 278) | async executeMultiple(sql: string): Promise<void> {
    method rollback (line 283) | async rollback(): Promise<void> {
    method commit (line 291) | async commit(): Promise<void> {
    method close (line 296) | close(): void {
    method closed (line 302) | get closed(): boolean {
    method #checkNotClosed (line 306) | #checkNotClosed(): void {
  function executeStmt (line 316) | function executeStmt(
  function rowFromSql (line 392) | function rowFromSql(
  function valueFromSql (line 417) | function valueFromSql(sqlValue: unknown, intMode: IntMode): Value {
  function valueToSql (line 440) | function valueToSql(value: InValue, intMode: IntMode): SqlValue {
  function executeMultiple (line 478) | function executeMultiple(db: Database, sql: string): void {
  function mapSqliteError (line 486) | function mapSqliteError(e: unknown): unknown {

FILE: packages/libsql-client/examples/example.js
  function example (line 3) | async function example() {

FILE: packages/libsql-client/examples/shell.js
  function main (line 5) | async function main() {

FILE: packages/libsql-client/examples/sync.js
  function example (line 4) | async function example() {

FILE: packages/libsql-client/examples/sync_offline.js
  function example (line 4) | async function example() {

FILE: packages/libsql-client/examples/sync_vector.js
  function example (line 4) | async function example() {

FILE: packages/libsql-client/smoke_test/vercel/app/api/function.ts
  function respond (line 8) | function respond(status: number, responseBody: string) {
  function assert (line 107) | function assert(value: unknown, message?: string) {

FILE: packages/libsql-client/smoke_test/vercel/test.js
  function getEnv (line 7) | function getEnv(name) {
  function npm (line 18) | async function npm(
  function deployToVercel (line 63) | async function deployToVercel(clientUrlInsideVercel) {
  function runTests (line 130) | async function runTests(functionUrl) {
  function runTest (line 140) | async function runTest(functionUrl, testCase) {
  function main (line 154) | async function main() {

FILE: packages/libsql-client/smoke_test/workers/test.js
  function main (line 7) | async function main() {
  function runWorker (line 57) | async function runWorker(local, clientUrlInsideWorker) {
  function runTest (line 86) | async function runTest(worker, testCase) {

FILE: packages/libsql-client/smoke_test/workers/worker.js
  method fetch (line 4) | async fetch(request, env, ctx) {
  function assert (line 104) | function assert(value, message) {

FILE: packages/libsql-client/src/__tests__/client.test.ts
  function withClient (line 42) | function withClient(
  function withInMemoryClient (line 56) | function withInMemoryClient(
  function testRoundtrip (line 332) | function testRoundtrip(
  function testRoundtripError (line 353) | function testRoundtripError(
  function customFetch (line 1583) | function customFetch(request: Request): Promise<Response> {

FILE: packages/libsql-client/src/__tests__/helpers.ts
  type CodeMatch (line 6) | type CodeMatch = {
  type AsymmetricMatchers (line 50) | interface AsymmetricMatchers {
  type Matchers (line 53) | interface Matchers<R> {

FILE: packages/libsql-client/src/hrana.ts
  method constructor (line 21) | constructor(mode: TransactionMode, version: hrana.ProtocolVersion) {
  method execute (line 35) | execute(stmt: InStatement): Promise<ResultSet> {
  method batch (line 39) | async batch(stmts: Array<InStatement>): Promise<Array<ResultSet>> {
  method executeMultiple (line 176) | async executeMultiple(sql: string): Promise<void> {
  method rollback (line 208) | async rollback(): Promise<void> {
  method commit (line 241) | async commit(): Promise<void> {
  function executeHranaBatch (line 273) | async function executeHranaBatch(
  function stmtToHrana (line 357) | function stmtToHrana(stmt: InStatement | [string, InArgs?]): hrana.Stmt {
  function resultSetFromHrana (line 384) | function resultSetFromHrana(hranaRows: hrana.RowsResult): ResultSet {
  function mapHranaError (line 402) | function mapHranaError(e: unknown): unknown {
  function mapHranaErrorCode (line 411) | function mapHranaErrorCode(e: hrana.ClientError): string {

FILE: packages/libsql-client/src/http.ts
  function createClient (line 29) | function createClient(config: Config): Client {
  function _createClient (line 34) | function _createClient(config: ExpandedConfig): Client {
  class HttpClient (line 75) | class HttpClient implements Client {
    method constructor (line 87) | constructor(
    method limit (line 113) | private async limit<T>(fn: () => Promise<T>): Promise<T> {
    method execute (line 117) | async execute(
    method batch (line 155) | async batch(
    method migrate (line 208) | async migrate(stmts: Array<InStatement>): Promise<Array<ResultSet>> {
    method transaction (line 240) | async transaction(
    method executeMultiple (line 257) | async executeMultiple(sql: string): Promise<void> {
    method sync (line 277) | sync(): Promise<Replicated> {
    method close (line 284) | close(): void {
    method reconnect (line 288) | async reconnect(): Promise<void> {
    method closed (line 306) | get closed(): boolean {
  class HttpTransaction (line 311) | class HttpTransaction extends HranaTransaction implements Transaction {
    method constructor (line 316) | constructor(
    method _getStream (line 327) | override _getStream(): hrana.Stream {
    method _getSqlCache (line 332) | override _getSqlCache(): SqlCache {
    method close (line 336) | override close(): void {
    method closed (line 340) | override get closed(): boolean {

FILE: packages/libsql-client/src/node.ts
  function createClient (line 15) | function createClient(config: Config): Client {
  function _createClient (line 19) | function _createClient(config: ExpandedConfig) {

FILE: packages/libsql-client/src/sql_cache.ts
  class SqlCache (line 3) | class SqlCache {
    method constructor (line 8) | constructor(owner: hrana.SqlOwner, capacity: number) {
    method apply (line 21) | apply(hranaStmts: Array<hrana.Stmt>): void {
  class Lru (line 67) | class Lru<K, V> {
    method constructor (line 72) | constructor() {
    method get (line 76) | get(key: K): V | undefined {
    method set (line 86) | set(key: K, value: V): void {
    method peekLru (line 90) | peekLru(): [K, V] | undefined {
    method delete (line 97) | delete(key: K): void {
    method size (line 101) | get size(): number {

FILE: packages/libsql-client/src/sqlite3.ts
  function createClient (line 29) | function createClient(config: Config): Client {
  function _createClient (line 34) | function _createClient(config: ExpandedConfig): Client {
  class Sqlite3Client (line 102) | class Sqlite3Client implements Client {
    method constructor (line 111) | constructor(
    method execute (line 125) | async execute(
    method batch (line 144) | async batch(
    method migrate (line 195) | async migrate(stmts: Array<InStatement>): Promise<Array<ResultSet>> {
    method transaction (line 239) | async transaction(mode: TransactionMode = "write"): Promise<Transactio...
    method executeMultiple (line 246) | async executeMultiple(sql: string): Promise<void> {
    method sync (line 258) | async sync(): Promise<Replicated> {
    method reconnect (line 267) | async reconnect(): Promise<void> {
    method close (line 278) | close(): void {
    method #checkNotClosed (line 286) | #checkNotClosed(): void {
    method #getDb (line 293) | #getDb(): Database.Database {
  class Sqlite3Transaction (line 301) | class Sqlite3Transaction implements Transaction {
    method constructor (line 306) | constructor(database: Database.Database, intMode: IntMode) {
    method execute (line 314) | async execute(
    method batch (line 333) | async batch(
    method executeMultiple (line 367) | async executeMultiple(sql: string): Promise<void> {
    method rollback (line 372) | async rollback(): Promise<void> {
    method commit (line 380) | async commit(): Promise<void> {
    method close (line 385) | close(): void {
    method closed (line 391) | get closed(): boolean {
    method #checkNotClosed (line 395) | #checkNotClosed(): void {
  function executeStmt (line 405) | function executeStmt(
  function rowFromSql (line 474) | function rowFromSql(
  function valueFromSql (line 499) | function valueFromSql(sqlValue: unknown, intMode: IntMode): Value {
  function valueToSql (line 524) | function valueToSql(value: InValue, intMode: IntMode): unknown {
  function executeMultiple (line 564) | function executeMultiple(db: Database.Database, sql: string): void {
  function mapSqliteError (line 572) | function mapSqliteError(e: unknown): unknown {
  function mapToBaseCode (line 583) | function mapToBaseCode(rawCode: number | undefined): string {

FILE: packages/libsql-client/src/web.ts
  function createClient (line 12) | function createClient(config: Config): Client {
  function _createClient (line 17) | function _createClient(config: ExpandedConfig): Client {

FILE: packages/libsql-client/src/ws.ts
  function createClient (line 30) | function createClient(config: Config): WsClient {
  function _createClient (line 35) | function _createClient(config: ExpandedConfig): WsClient {
  type ConnState (line 96) | interface ConnState {
  type StreamState (line 113) | interface StreamState {
  class WsClient (line 121) | class WsClient implements Client {
    method constructor (line 136) | constructor(
    method limit (line 153) | private async limit<T>(fn: () => Promise<T>): Promise<T> {
    method execute (line 157) | async execute(
    method batch (line 194) | async batch(
    method migrate (line 236) | async migrate(stmts: Array<InStatement>): Promise<Array<ResultSet>> {
    method transaction (line 265) | async transaction(mode: TransactionMode = "write"): Promise<WsTransact...
    method executeMultiple (line 280) | async executeMultiple(sql: string): Promise<void> {
    method sync (line 298) | sync(): Promise<Replicated> {
    method #openStream (line 305) | async #openStream(): Promise<StreamState> {
    method #openConn (line 391) | #openConn(client?: hrana.WsClient): ConnState {
    method reconnect (line 406) | async reconnect(): Promise<void> {
    method _closeStream (line 435) | _closeStream(streamState: StreamState): void {
    method close (line 450) | close(): void {
  class WsTransaction (line 463) | class WsTransaction extends HranaTransaction implements Transaction {
    method constructor (line 468) | constructor(
    method _getStream (line 480) | override _getStream(): hrana.Stream {
    method _getSqlCache (line 485) | override _getSqlCache(): SqlCache {
    method close (line 489) | override close(): void {
    method closed (line 493) | override get closed(): boolean {

FILE: packages/libsql-core/src/api.ts
  type Config (line 2) | interface Config {
  type IntMode (line 68) | type IntMode = "number" | "bigint" | "string";
  type Client (line 74) | interface Client {
  type Transaction (line 298) | interface Transaction {
  type TransactionMode (line 392) | type TransactionMode = "write" | "read" | "deferred";
  type ResultSet (line 407) | interface ResultSet {
  type Row (line 463) | interface Row {
  type Replicated (line 477) | type Replicated =
  type Value (line 481) | type Value = null | string | number | bigint | ArrayBuffer;
  type InValue (line 483) | type InValue = Value | boolean | Uint8Array | Date;
  type InStatement (line 485) | type InStatement = { sql: string; args?: InArgs } | string;
  type InArgs (line 486) | type InArgs = Array<InValue> | Record<string, InValue>;
  class LibsqlError (line 489) | class LibsqlError extends Error {
    method constructor (line 497) | constructor(
  class LibsqlBatchError (line 516) | class LibsqlBatchError extends LibsqlError {
    method constructor (line 520) | constructor(

FILE: packages/libsql-core/src/config.ts
  type ExpandedConfig (line 7) | interface ExpandedConfig {
  type ExpandedScheme (line 24) | type ExpandedScheme = "wss" | "ws" | "https" | "http" | "file";
  type queryParamDef (line 26) | type queryParamDef = {
  type queryParamsDef (line 30) | type queryParamsDef = { [key: string]: queryParamDef };
  function isInMemoryConfig (line 34) | function isInMemoryConfig(config: ExpandedConfig): boolean {
  function expandConfig (line 41) | function expandConfig(

FILE: packages/libsql-core/src/uri.ts
  type Uri (line 8) | interface Uri {
  type HierPart (line 16) | interface HierPart {
  type Authority (line 21) | interface Authority {
  type Userinfo (line 27) | interface Userinfo {
  type Query (line 32) | interface Query {
  type KeyValue (line 36) | interface KeyValue {
  function parseUri (line 41) | function parseUri(text: string): Uri {
  constant URI_RE (line 66) | const URI_RE = (() => {
  function parseAuthority (line 78) | function parseAuthority(text: string): Authority {
  constant AUTHORITY_RE (line 103) | const AUTHORITY_RE = (() => {
  function parseQuery (line 112) | function parseQuery(text: string): Query {
  function percentDecode (line 139) | function percentDecode(text: string): string {
  function encodeBaseUrl (line 156) | function encodeBaseUrl(
  function encodeHost (line 183) | function encodeHost(host: string): string {
  function encodePort (line 187) | function encodePort(port: number | undefined): string {
  function encodeUserinfo (line 191) | function encodeUserinfo(userinfo: Userinfo | undefined): string {

FILE: packages/libsql-core/src/util.ts
  function transactionModeToBegin (line 14) | function transactionModeToBegin(mode: TransactionMode): string {
  class ResultSetImpl (line 28) | class ResultSetImpl implements ResultSet {
    method constructor (line 35) | constructor(
    method toJSON (line 49) | toJSON(): any {
  function rowToJson (line 63) | function rowToJson(row: Row): unknown {
  function valueToJson (line 67) | function valueToJson(value: Value): unknown {

FILE: testing/hrana-test-server/c3.py
  class Conn (line 126) | class Conn:
    method __init__ (line 127) | def __init__(self, db_ptr):
    method open (line 131) | def open(cls, filename):
    method close (line 139) | def close(self):
    method __del__ (line 144) | def __del__(self):
    method extended_result_codes (line 147) | def extended_result_codes(self, onoff):
    method errmsg (line 151) | def errmsg(self):
    method errstr (line 156) | def errstr(cls, code):
    method exec (line 159) | def exec(self, sql):
    method txn_state (line 167) | def txn_state(self):
    method prepare (line 172) | def prepare(self, sql):
    method changes (line 186) | def changes(self):
    method total_changes (line 190) | def total_changes(self):
    method last_insert_rowid (line 194) | def last_insert_rowid(self):
    method limit (line 198) | def limit(self, id, new_val):
    method busy_timeout (line 202) | def busy_timeout(self, ms):
    method get_autocommit (line 206) | def get_autocommit(self):
  class Stmt (line 210) | class Stmt:
    method __init__ (line 211) | def __init__(self, conn, stmt_ptr):
    method close (line 215) | def close(self):
    method __del__ (line 220) | def __del__(self):
    method param_count (line 223) | def param_count(self):
    method param_index (line 227) | def param_index(self, name):
    method param_name (line 232) | def param_name(self, param_i):
    method bind (line 237) | def bind(self, param_i, value):
    method step (line 255) | def step(self):
    method column_count (line 264) | def column_count(self):
    method column_name (line 268) | def column_name(self, column_i):
    method column_decltype (line 272) | def column_decltype(self, column_i):
    method column (line 277) | def column(self, column_i):
    method readonly (line 302) | def readonly(self):
    method isexplain (line 306) | def isexplain(self):
  class SqliteError (line 311) | class SqliteError(RuntimeError):
    method __init__ (line 312) | def __init__(self, message, error_code=None) -> None:
  function _try (line 318) | def _try(error_code, conn=None):

FILE: testing/hrana-test-server/from_proto.py
  function ws_client_msg (line 3) | def ws_client_msg(p):
  function ws_hello_msg (line 12) | def ws_hello_msg(p):
  function ws_request_msg (line 18) | def ws_request_msg(p):
  function ws_open_stream_req (line 48) | def ws_open_stream_req(p):
  function ws_close_stream_req (line 51) | def ws_close_stream_req(p):
  function ws_execute_req (line 54) | def ws_execute_req(p):
  function ws_batch_req (line 61) | def ws_batch_req(p):
  function ws_open_cursor_req (line 68) | def ws_open_cursor_req(p):
  function ws_close_cursor_req (line 76) | def ws_close_cursor_req(p):
  function ws_fetch_cursor_req (line 82) | def ws_fetch_cursor_req(p):
  function ws_sequence_req (line 89) | def ws_sequence_req(p):
  function ws_describe_req (line 97) | def ws_describe_req(p):
  function ws_store_sql_req (line 105) | def ws_store_sql_req(p):
  function ws_close_sql_req (line 112) | def ws_close_sql_req(p):
  function ws_get_autocommit_req (line 118) | def ws_get_autocommit_req(p):
  function http_pipeline_req_body (line 126) | def http_pipeline_req_body(p):
  function http_stream_request (line 132) | def http_stream_request(p):
  function http_execute_stream_req (line 153) | def http_execute_stream_req(p):
  function http_batch_stream_req (line 156) | def http_batch_stream_req(p):
  function http_sequence_stream_req (line 159) | def http_sequence_stream_req(p):
  function http_describe_stream_req (line 166) | def http_describe_stream_req(p):
  function http_store_sql_stream_req (line 173) | def http_store_sql_stream_req(p):
  function http_close_sql_stream_req (line 176) | def http_close_sql_stream_req(p):
  function http_cursor_req_body (line 179) | def http_cursor_req_body(p):
  function batch (line 187) | def batch(p):
  function batch_step (line 190) | def batch_step(p):
  function batch_cond (line 196) | def batch_cond(p):
  function stmt (line 213) | def stmt(p):
  function named_arg (line 222) | def named_arg(p):
  function value (line 228) | def value(p):

FILE: testing/hrana-test-server/server_v1.py
  function main (line 16) | async def main(command):
  function handle_get_index (line 55) | async def handle_get_index(req):
  function handle_websocket (line 67) | async def handle_websocket(app, ws):
  function handle_post_execute (line 158) | async def handle_post_execute(req):
  function handle_post_batch (line 170) | async def handle_post_batch(req):
  function connect (line 182) | def connect(db_file):
  class CloseWebSocket (line 187) | class CloseWebSocket(BaseException):
  class CloseTcpSocket (line 190) | class CloseTcpSocket(BaseException):
  function execute_stmt (line 193) | def execute_stmt(conn, stmt):
  function execute_batch (line 248) | def execute_batch(conn, batch):
  function eval_cond (line 274) | def eval_cond(step_results, step_errors, cond):
  function value_to_sqlite (line 288) | def value_to_sqlite(value):
  function value_from_sqlite (line 302) | def value_from_sqlite(value):
  class ResponseError (line 316) | class ResponseError(RuntimeError):
  function to_thread (line 319) | async def to_thread(func):

FILE: testing/hrana-test-server/server_v2.py
  class HttpStream (line 21) | class HttpStream:
  function main (line 26) | async def main(command):
  function handle_get_index (line 69) | async def handle_get_index(req):
  function handle_websocket (line 81) | async def handle_websocket(app, ws):
  function handle_post_execute (line 196) | async def handle_post_execute(req):
  function handle_post_batch (line 208) | async def handle_post_batch(req):
  function handle_post_pipeline (line 220) | async def handle_post_pipeline(req):
  function connect (line 295) | def connect(db_file):
  function get_sql (line 303) | def get_sql(sqls, obj):
  class CloseWebSocket (line 313) | class CloseWebSocket(BaseException):
  class CloseTcpSocket (line 316) | class CloseTcpSocket(BaseException):
  function execute_stmt (line 319) | def execute_stmt(conn, sqls, stmt):
  function describe_stmt (line 410) | def describe_stmt(conn, sql):
  function execute_sequence (line 441) | def execute_sequence(conn, sql):
  function execute_batch (line 452) | def execute_batch(conn, sqls, batch):
  function eval_cond (line 478) | def eval_cond(step_results, step_errors, cond):
  function value_to_sqlite (line 492) | def value_to_sqlite(value):
  function value_from_sqlite (line 506) | def value_from_sqlite(value):
  class ResponseError (line 521) | class ResponseError(RuntimeError):
    method __init__ (line 522) | def __init__(self, message, code=None):
    method tojson (line 532) | def tojson(self):
  function to_thread (line 539) | async def to_thread(func):

FILE: testing/hrana-test-server/server_v3.py
  class HttpStream (line 27) | class HttpStream:
  function main (line 32) | async def main(command):
  function handle_get_index (line 79) | async def handle_get_index(req):
  function handle_websocket (line 95) | async def handle_websocket(app, ws):
  function handle_post_pipeline (line 245) | async def handle_post_pipeline(req):
  function handle_post_cursor (line 327) | async def handle_post_cursor(req):
  function handle_baton (line 367) | async def handle_baton(app, baton):
  function encode_varint (line 380) | def encode_varint(num):
  function connect (line 392) | def connect(db_file):
  function get_sql (line 400) | def get_sql(sqls, obj):
  class CloseWebSocket (line 410) | class CloseWebSocket(BaseException):
  class CloseTcpSocket (line 413) | class CloseTcpSocket(BaseException):
  function execute_stmt (line 416) | def execute_stmt(conn, sqls, stmt):
  function describe_stmt (line 507) | def describe_stmt(conn, sql):
  function execute_sequence (line 538) | def execute_sequence(conn, sql):
  function execute_cursor (line 549) | def execute_cursor(conn, sqls, batch):
  function execute_batch (line 578) | def execute_batch(conn, sqls, batch):
  function eval_cond (line 604) | def eval_cond(conn, step_results, step_errors, cond):
  function value_to_sqlite (line 620) | def value_to_sqlite(value):
  function value_from_sqlite (line 634) | def value_from_sqlite(value):
  class ResponseError (line 649) | class ResponseError(RuntimeError):
    method __init__ (line 650) | def __init__(self, message, code=None):
    method tojson (line 660) | def tojson(self):
  function to_thread (line 667) | async def to_thread(func):

FILE: testing/hrana-test-server/to_proto.py
  function ws_server_msg (line 5) | def ws_server_msg(p, m):
  function ws_execute_resp (line 40) | def ws_execute_resp(p, m):
  function ws_batch_resp (line 43) | def ws_batch_resp(p, m):
  function ws_fetch_cursor_resp (line 46) | def ws_fetch_cursor_resp(p, m):
  function ws_describe_resp (line 51) | def ws_describe_resp(p, m):
  function ws_get_autocommit_resp (line 54) | def ws_get_autocommit_resp(p, m):
  function http_pipeline_resp_body (line 59) | def http_pipeline_resp_body(p, m):
  function http_stream_result (line 67) | def http_stream_result(p, m):
  function http_stream_response (line 73) | def http_stream_response(p, m):
  function http_cursor_resp_body (line 91) | def http_cursor_resp_body(p, m):
  function error (line 99) | def error(p, m):
  function cursor_entry (line 104) | def cursor_entry(p, m):
  function stmt_result (line 122) | def stmt_result(p, m):
  function col (line 131) | def col(p, m):
  function row (line 136) | def row(p, m):
  function batch_result (line 140) | def batch_result(p, m):
  function describe_result (line 149) | def describe_result(p, m):
  function describe_param (line 157) | def describe_param(p, m):
  function describe_col (line 161) | def describe_col(p, m):
  function value (line 166) | def value(p, m):